yjz-web-sdk 1.0.0

package/lib/yjz-web-sdk.js

@@ -0,0 +1,3872 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+function _mergeNamespaces(n, m) {
+  for (var i = 0; i < m.length; i++) {
+    const e = m[i];
+    if (typeof e !== "string" && !Array.isArray(e)) {
+      for (const k in e) {
+        if (k !== "default" && !(k in n)) {
+          const d = Object.getOwnPropertyDescriptor(e, k);
+          if (d) {
+            Object.defineProperty(n, k, d.get ? d : {
+              enumerable: true,
+              get: () => e[k]
+            });
+          }
+        }
+      }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var eventemitter3 = { exports: {} };
+var hasRequiredEventemitter3;
+function requireEventemitter3() {
+  if (hasRequiredEventemitter3) return eventemitter3.exports;
+  hasRequiredEventemitter3 = 1;
+  (function(module) {
+    var has = Object.prototype.hasOwnProperty, prefix = "~";
+    function Events() {
+    }
+    if (Object.create) {
+      Events.prototype = /* @__PURE__ */ Object.create(null);
+      if (!new Events().__proto__) prefix = false;
+    }
+    function EE(fn, context, once) {
+      this.fn = fn;
+      this.context = context;
+      this.once = once || false;
+    }
+    function addListener(emitter, event, fn, context, once) {
+      if (typeof fn !== "function") {
+        throw new TypeError("The listener must be a function");
+      }
+      var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event;
+      if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;
+      else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);
+      else emitter._events[evt] = [emitter._events[evt], listener];
+      return emitter;
+    }
+    function clearEvent(emitter, evt) {
+      if (--emitter._eventsCount === 0) emitter._events = new Events();
+      else delete emitter._events[evt];
+    }
+    function EventEmitter2() {
+      this._events = new Events();
+      this._eventsCount = 0;
+    }
+    EventEmitter2.prototype.eventNames = function eventNames() {
+      var names = [], events, name;
+      if (this._eventsCount === 0) return names;
+      for (name in events = this._events) {
+        if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);
+      }
+      if (Object.getOwnPropertySymbols) {
+        return names.concat(Object.getOwnPropertySymbols(events));
+      }
+      return names;
+    };
+    EventEmitter2.prototype.listeners = function listeners(event) {
+      var evt = prefix ? prefix + event : event, handlers = this._events[evt];
+      if (!handlers) return [];
+      if (handlers.fn) return [handlers.fn];
+      for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
+        ee[i] = handlers[i].fn;
+      }
+      return ee;
+    };
+    EventEmitter2.prototype.listenerCount = function listenerCount(event) {
+      var evt = prefix ? prefix + event : event, listeners = this._events[evt];
+      if (!listeners) return 0;
+      if (listeners.fn) return 1;
+      return listeners.length;
+    };
+    EventEmitter2.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt]) return false;
+      var listeners = this._events[evt], len = arguments.length, args, i;
+      if (listeners.fn) {
+        if (listeners.once) this.removeListener(event, listeners.fn, void 0, true);
+        switch (len) {
+          case 1:
+            return listeners.fn.call(listeners.context), true;
+          case 2:
+            return listeners.fn.call(listeners.context, a1), true;
+          case 3:
+            return listeners.fn.call(listeners.context, a1, a2), true;
+          case 4:
+            return listeners.fn.call(listeners.context, a1, a2, a3), true;
+          case 5:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+          case 6:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+        }
+        for (i = 1, args = new Array(len - 1); i < len; i++) {
+          args[i - 1] = arguments[i];
+        }
+        listeners.fn.apply(listeners.context, args);
+      } else {
+        var length = listeners.length, j;
+        for (i = 0; i < length; i++) {
+          if (listeners[i].once) this.removeListener(event, listeners[i].fn, void 0, true);
+          switch (len) {
+            case 1:
+              listeners[i].fn.call(listeners[i].context);
+              break;
+            case 2:
+              listeners[i].fn.call(listeners[i].context, a1);
+              break;
+            case 3:
+              listeners[i].fn.call(listeners[i].context, a1, a2);
+              break;
+            case 4:
+              listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+              break;
+            default:
+              if (!args) for (j = 1, args = new Array(len - 1); j < len; j++) {
+                args[j - 1] = arguments[j];
+              }
+              listeners[i].fn.apply(listeners[i].context, args);
+          }
+        }
+      }
+      return true;
+    };
+    EventEmitter2.prototype.on = function on(event, fn, context) {
+      return addListener(this, event, fn, context, false);
+    };
+    EventEmitter2.prototype.once = function once(event, fn, context) {
+      return addListener(this, event, fn, context, true);
+    };
+    EventEmitter2.prototype.removeListener = function removeListener(event, fn, context, once) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt]) return this;
+      if (!fn) {
+        clearEvent(this, evt);
+        return this;
+      }
+      var listeners = this._events[evt];
+      if (listeners.fn) {
+        if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
+          clearEvent(this, evt);
+        }
+      } else {
+        for (var i = 0, events = [], length = listeners.length; i < length; i++) {
+          if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
+            events.push(listeners[i]);
+          }
+        }
+        if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;
+        else clearEvent(this, evt);
+      }
+      return this;
+    };
+    EventEmitter2.prototype.removeAllListeners = function removeAllListeners(event) {
+      var evt;
+      if (event) {
+        evt = prefix ? prefix + event : event;
+        if (this._events[evt]) clearEvent(this, evt);
+      } else {
+        this._events = new Events();
+        this._eventsCount = 0;
+      }
+      return this;
+    };
+    EventEmitter2.prototype.off = EventEmitter2.prototype.removeListener;
+    EventEmitter2.prototype.addListener = EventEmitter2.prototype.on;
+    EventEmitter2.prefixed = prefix;
+    EventEmitter2.EventEmitter = EventEmitter2;
+    {
+      module.exports = EventEmitter2;
+    }
+  })(eventemitter3);
+  return eventemitter3.exports;
+}
+var eventemitter3Exports = requireEventemitter3();
+const EventEmitter = /* @__PURE__ */ getDefaultExportFromCjs(eventemitter3Exports);
+var MessageType = /* @__PURE__ */ ((MessageType2) => {
+  MessageType2["Peers"] = "Peers";
+  MessageType2["Offer"] = "Offer";
+  MessageType2["Answer"] = "Answer";
+  MessageType2["IceCandidates"] = "IceCandidates";
+  MessageType2["SignOut"] = "SignOut";
+  MessageType2["NotAvailable"] = "NotAvailable";
+  MessageType2["Ping"] = "Ping";
+  MessageType2["Pong"] = "Pong";
+  return MessageType2;
+})(MessageType || {});
+var SendType = /* @__PURE__ */ ((SendType2) => {
+  SendType2["SignIn"] = "SignIn";
+  SendType2["SignOut"] = "SignOut";
+  SendType2["Answer"] = "Answer";
+  SendType2["Offer"] = "Offer";
+  SendType2["IceCandidates"] = "IceCandidates";
+  SendType2["Pong"] = "Pong";
+  SendType2["Identity"] = "Web";
+  return SendType2;
+})(SendType || {});
+var FailCode = /* @__PURE__ */ ((FailCode2) => {
+  FailCode2[FailCode2["SOCKET"] = 10001] = "SOCKET";
+  FailCode2[FailCode2["SOCKET_CLOSE"] = 10002] = "SOCKET_CLOSE";
+  FailCode2[FailCode2["CREATE_OFFER"] = 10003] = "CREATE_OFFER";
+  FailCode2[FailCode2["HANDLE_OFFER"] = 10004] = "HANDLE_OFFER";
+  FailCode2[FailCode2["CREATE_ANSWER"] = 10005] = "CREATE_ANSWER";
+  FailCode2[FailCode2["HANDLE_ANSWER"] = 10006] = "HANDLE_ANSWER";
+  FailCode2[FailCode2["LOCAL_DES"] = 10007] = "LOCAL_DES";
+  FailCode2[FailCode2["REMOTE_DES"] = 10008] = "REMOTE_DES";
+  FailCode2[FailCode2["HANDLE_ICE"] = 10009] = "HANDLE_ICE";
+  FailCode2[FailCode2["ICE_STATE"] = 10010] = "ICE_STATE";
+  FailCode2[FailCode2["CAMERA"] = 10011] = "CAMERA";
+  FailCode2[FailCode2["NOT_AVAILABLE"] = 10012] = "NOT_AVAILABLE";
+  FailCode2[FailCode2["DATACHANNEL_ERR"] = 10013] = "DATACHANNEL_ERR";
+  FailCode2[FailCode2["STREAM_STATE"] = 10014] = "STREAM_STATE";
+  return FailCode2;
+})(FailCode || {});
+const FailInfoMap = {
+  [
+    10001
+    /* SOCKET */
+  ]: { type: "socket", description: "WebSocket连接失败" },
+  [
+    10002
+    /* SOCKET_CLOSE */
+  ]: { type: "socket_close", description: "WebSocket已关闭" },
+  [
+    10003
+    /* CREATE_OFFER */
+  ]: { type: "createOffer", description: "创建offer失败" },
+  [
+    10004
+    /* HANDLE_OFFER */
+  ]: { type: "handleOffer", description: "处理offer失败" },
+  [
+    10005
+    /* CREATE_ANSWER */
+  ]: { type: "createAnswer", description: "创建answer失败" },
+  [
+    10006
+    /* HANDLE_ANSWER */
+  ]: { type: "handleAnswer", description: "处理answer失败" },
+  [
+    10007
+    /* LOCAL_DES */
+  ]: { type: "setLocalDescription", description: "设置本地描述失败" },
+  [
+    10008
+    /* REMOTE_DES */
+  ]: { type: "setRemoteDescription", description: "设置远端描述失败" },
+  [
+    10009
+    /* HANDLE_ICE */
+  ]: { type: "handleICE", description: "处理 ICE 失败" },
+  [
+    10010
+    /* ICE_STATE */
+  ]: { type: "iceState", description: "ICE 状态异常" },
+  [
+    10011
+    /* CAMERA */
+  ]: { type: "camera", description: "摄像头异常" },
+  [
+    10012
+    /* NOT_AVAILABLE */
+  ]: { type: "notAvailable", description: "云机已关机或者不存在" },
+  [
+    10013
+    /* DATACHANNEL_ERR */
+  ]: { type: "datachannel_err", description: "信令通道错误" },
+  [
+    10014
+    /* STREAM_STATE */
+  ]: { type: "stream_state", description: "webrtc统计信息获取失败" }
+};
+function createWebRtcError(code, rawError) {
+  const info = FailInfoMap[code];
+  return {
+    code,
+    type: info.type,
+    message: info.description,
+    rawError
+  };
+}
+var EmitType = /* @__PURE__ */ ((EmitType2) => {
+  EmitType2["signalMessage"] = "signalMessage";
+  EmitType2["webrtcError"] = "webrtcError";
+  EmitType2["sendAnswer"] = "sendAnswer";
+  EmitType2["sendOffer"] = "sendOffer";
+  EmitType2["sendICEMessage"] = "sendICEMessage";
+  EmitType2["streamTrack"] = "streamTrack";
+  EmitType2["iceConnectionState"] = "iceConnectionState";
+  EmitType2["cloudStatusChanged"] = "cloudStatusChanged";
+  EmitType2["statisticInfo"] = "statisticInfo";
+  return EmitType2;
+})(EmitType || {});
+class SignalingClient extends EventEmitter {
+  constructor(config) {
+    super();
+    // 私有属性 config，用于存储 WebRTC 配置信息
+    __publicField(this, "config");
+    // 根据实际情况替换为具体配置类型
+    // 私有属性 webSocket，用于存储 WebSocket 连接实例，初始值为 null
+    __publicField(this, "webSocket", null);
+    __publicField(this, "timeout", null);
+    this.config = config;
+  }
+  /**
+   * 启动 WebSocket 连接，并注册各事件处理
+   */
+  start() {
+    this.webSocket = new WebSocket(this.config.signalServerUrl);
+    this.webSocket.onopen = () => {
+      this.sendSignInMessage();
+      if (this.timeout === null) {
+        this.timeout = setTimeout(() => {
+          this.emit(EmitType.webrtcError, createWebRtcError(FailCode.NOT_AVAILABLE, ""));
+          this.timeout = null;
+        }, 4e3);
+      }
+    };
+    this.webSocket.onclose = () => {
+      this.webSocket = null;
+    };
+    this.webSocket.onerror = (event) => {
+      this.emit(EmitType.webrtcError, createWebRtcError(FailCode.SOCKET, event));
+    };
+    this.webSocket.onmessage = (event) => {
+      const message = JSON.parse(event.data);
+      if (message.type === MessageType.Offer) {
+        if (this.timeout) {
+          clearTimeout(this.timeout);
+          this.timeout = null;
+        }
+      }
+      this.emit(EmitType.signalMessage, message);
+    };
+  }
+  /**
+   * 关闭 WebSocket 连接，并通知外部
+   */
+  close() {
+    if (this.webSocket) {
+      this.webSocket.onopen = null;
+      this.webSocket.onmessage = null;
+      this.webSocket.onerror = null;
+      this.webSocket.onclose = null;
+      if (this.webSocket.readyState === WebSocket.OPEN || this.webSocket.readyState === WebSocket.CONNECTING) {
+        this.webSocket.close(1e3, "Normal Closure");
+      }
+      this.webSocket = null;
+    }
+    this.removeAllListeners();
+  }
+  /**
+   * 发送消息到服务端
+   * @param message - 消息字符串
+   */
+  sendMessage(message) {
+    if (this.webSocket && this.webSocket.readyState === WebSocket.OPEN) {
+      this.webSocket.send(message);
+    }
+  }
+  sendSignInMessage() {
+    const message = {
+      type: SendType.SignIn,
+      identity: SendType.Identity,
+      turnServerUri: this.config.turnServerUri,
+      roomId: this.config.roomId
+    };
+    const jsonMessage = JSON.stringify(message);
+    this.sendMessage(jsonMessage);
+  }
+}
+var ChannelDataType = /* @__PURE__ */ ((ChannelDataType2) => {
+  ChannelDataType2["ClickData"] = "ClickData";
+  ChannelDataType2["ClipboardData"] = "ClipboardData";
+  ChannelDataType2["ActionCommand"] = "ActionCommand";
+  ChannelDataType2["ActionInput"] = "ActionInput";
+  ChannelDataType2["ActionChinese"] = "ActionChinese";
+  ChannelDataType2["ActionRequestCloudDeviceInfo"] = "ActionRequestCloudDeviceInfo";
+  ChannelDataType2["ActionClarity"] = "ActionClarity";
+  return ChannelDataType2;
+})(ChannelDataType || {});
+const ActionType = Object.freeze({
+  ACTION_DOWN: 0,
+  ACTION_MOVE: 2,
+  ACTION_UP: 1
+});
+const StreamRotation = {
+  ROTATION_0: 0,
+  ROTATION_180: 2
+};
+const ContainerDirection = {
+  Vertical: 0,
+  Horizontal: 1
+};
+class TouchData {
+  constructor(action, p, x, y, offsetTime, type = "adb") {
+    __publicField(this, "action");
+    __publicField(this, "p");
+    __publicField(this, "x");
+    __publicField(this, "y");
+    __publicField(this, "offsetTime");
+    __publicField(this, "type");
+    this.action = action;
+    this.p = p;
+    this.x = x;
+    this.y = y;
+    this.offsetTime = offsetTime;
+    this.type = type;
+  }
+}
+class InputData {
+  constructor(text) {
+    __publicField(this, "text");
+    this.text = text;
+  }
+}
+class KeyEventData {
+  constructor(keyCode, meta) {
+    __publicField(this, "keyCode");
+    __publicField(this, "meta");
+    this.keyCode = keyCode;
+    this.meta = meta;
+  }
+}
+class ChannelData {
+  constructor(type, data = null) {
+    __publicField(this, "type");
+    __publicField(this, "data");
+    this.type = type;
+    this.data = data;
+  }
+  toString() {
+    return JSON.stringify({ type: this.type, data: this.data });
+  }
+  /**
+   * 格式化数据
+   * 如果数据已经是字符串，则直接返回；否则使用 JSON.stringify() 转换为字符串
+   * @param data 待转换数据
+   * @returns 格式化后的字符串
+   */
+  static formatData(data) {
+    return typeof data === "string" ? data : JSON.stringify(data);
+  }
+  /**
+   * 生成点击数据
+   * @param touchData 触摸数据，可以是任意类型
+   */
+  static click(touchData) {
+    return new ChannelData("ClickData", this.formatData(touchData));
+  }
+  /**
+   * 生成剪贴板数据
+   * @param data 剪贴板数据，可以是字符串或其他类型
+   */
+  static clipboard(data) {
+    return new ChannelData("ClipboardData", this.formatData(data));
+  }
+  /**
+   * 生成输入数据
+   * @param data 输入数据对象
+   */
+  static input(data) {
+    return new ChannelData("ActionInput", this.formatData(data));
+  }
+  /**
+   * 生成中文输入数据
+   * @param data 中文输入数据
+   */
+  static chinese(data) {
+    return new ChannelData("ActionChinese", this.formatData(data));
+  }
+  /**
+   * 生成请求云设备信息数据
+   */
+  static requestCloudDeviceInfo() {
+    return new ChannelData("ActionRequestCloudDeviceInfo", "");
+  }
+  /**
+   * 生成清晰度数据（clarity）
+   * @param data 清晰度数据
+   */
+  static clarity(data) {
+    return new ChannelData("ActionClarity", this.formatData(data));
+  }
+}
+class WebRTCConfig {
+  constructor(options = {}) {
+    __publicField(this, "signalServerUrl");
+    __publicField(this, "myId");
+    __publicField(this, "roomId");
+    __publicField(this, "targetId");
+    __publicField(this, "stunServerUri");
+    __publicField(this, "stunServerUriAli");
+    __publicField(this, "stunServerUriTel");
+    __publicField(this, "turnServerUri");
+    __publicField(this, "turnServerUserName");
+    __publicField(this, "turnServerPassword");
+    this.signalServerUrl = options.signalServerUrl || "";
+    this.myId = options.myId || "";
+    this.roomId = options.roomId || "";
+    this.targetId = options.targetId || "";
+    this.stunServerUri = options.stunServerUri || "stun:stun.l.google.com:19302";
+    this.stunServerUriAli = options.stunServerUriAli || "stun:stun.middle.aliyun.com:3478";
+    this.stunServerUriTel = options.stunServerUriTel || "stun:stun.qq.com:3478";
+    this.turnServerUri = options.turnServerUri || "turn:btweb.yajuzhen.com:3478";
+    this.turnServerUserName = options.turnServerUserName || "yangyj";
+    this.turnServerPassword = options.turnServerPassword || "hb@2025@168";
+  }
+}
+let logDisabled_ = true;
+let deprecationWarnings_ = true;
+function extractVersion(uastring, expr, pos) {
+  const match = uastring.match(expr);
+  return match && match.length >= pos && parseInt(match[pos], 10);
+}
+function wrapPeerConnectionEvent(window2, eventNameToWrap, wrapper) {
+  if (!window2.RTCPeerConnection) {
+    return;
+  }
+  const proto = window2.RTCPeerConnection.prototype;
+  const nativeAddEventListener = proto.addEventListener;
+  proto.addEventListener = function(nativeEventName, cb) {
+    if (nativeEventName !== eventNameToWrap) {
+      return nativeAddEventListener.apply(this, arguments);
+    }
+    const wrappedCallback = (e) => {
+      const modifiedEvent = wrapper(e);
+      if (modifiedEvent) {
+        if (cb.handleEvent) {
+          cb.handleEvent(modifiedEvent);
+        } else {
+          cb(modifiedEvent);
+        }
+      }
+    };
+    this._eventMap = this._eventMap || {};
+    if (!this._eventMap[eventNameToWrap]) {
+      this._eventMap[eventNameToWrap] = /* @__PURE__ */ new Map();
+    }
+    this._eventMap[eventNameToWrap].set(cb, wrappedCallback);
+    return nativeAddEventListener.apply(this, [
+      nativeEventName,
+      wrappedCallback
+    ]);
+  };
+  const nativeRemoveEventListener = proto.removeEventListener;
+  proto.removeEventListener = function(nativeEventName, cb) {
+    if (nativeEventName !== eventNameToWrap || !this._eventMap || !this._eventMap[eventNameToWrap]) {
+      return nativeRemoveEventListener.apply(this, arguments);
+    }
+    if (!this._eventMap[eventNameToWrap].has(cb)) {
+      return nativeRemoveEventListener.apply(this, arguments);
+    }
+    const unwrappedCb = this._eventMap[eventNameToWrap].get(cb);
+    this._eventMap[eventNameToWrap].delete(cb);
+    if (this._eventMap[eventNameToWrap].size === 0) {
+      delete this._eventMap[eventNameToWrap];
+    }
+    if (Object.keys(this._eventMap).length === 0) {
+      delete this._eventMap;
+    }
+    return nativeRemoveEventListener.apply(this, [
+      nativeEventName,
+      unwrappedCb
+    ]);
+  };
+  Object.defineProperty(proto, "on" + eventNameToWrap, {
+    get() {
+      return this["_on" + eventNameToWrap];
+    },
+    set(cb) {
+      if (this["_on" + eventNameToWrap]) {
+        this.removeEventListener(
+          eventNameToWrap,
+          this["_on" + eventNameToWrap]
+        );
+        delete this["_on" + eventNameToWrap];
+      }
+      if (cb) {
+        this.addEventListener(
+          eventNameToWrap,
+          this["_on" + eventNameToWrap] = cb
+        );
+      }
+    },
+    enumerable: true,
+    configurable: true
+  });
+}
+function disableLog(bool) {
+  if (typeof bool !== "boolean") {
+    return new Error("Argument type: " + typeof bool + ". Please use a boolean.");
+  }
+  logDisabled_ = bool;
+  return bool ? "adapter.js logging disabled" : "adapter.js logging enabled";
+}
+function disableWarnings(bool) {
+  if (typeof bool !== "boolean") {
+    return new Error("Argument type: " + typeof bool + ". Please use a boolean.");
+  }
+  deprecationWarnings_ = !bool;
+  return "adapter.js deprecation warnings " + (bool ? "disabled" : "enabled");
+}
+function log() {
+  if (typeof window === "object") {
+    if (logDisabled_) {
+      return;
+    }
+    if (typeof console !== "undefined" && typeof console.log === "function") {
+      console.log.apply(console, arguments);
+    }
+  }
+}
+function deprecated(oldMethod, newMethod) {
+  if (!deprecationWarnings_) {
+    return;
+  }
+  console.warn(oldMethod + " is deprecated, please use " + newMethod + " instead.");
+}
+function detectBrowser(window2) {
+  const result = { browser: null, version: null };
+  if (typeof window2 === "undefined" || !window2.navigator || !window2.navigator.userAgent) {
+    result.browser = "Not a browser.";
+    return result;
+  }
+  const { navigator: navigator2 } = window2;
+  if (navigator2.userAgentData && navigator2.userAgentData.brands) {
+    const chromium = navigator2.userAgentData.brands.find((brand) => {
+      return brand.brand === "Chromium";
+    });
+    if (chromium) {
+      return { browser: "chrome", version: parseInt(chromium.version, 10) };
+    }
+  }
+  if (navigator2.mozGetUserMedia) {
+    result.browser = "firefox";
+    result.version = extractVersion(
+      navigator2.userAgent,
+      /Firefox\/(\d+)\./,
+      1
+    );
+  } else if (navigator2.webkitGetUserMedia || window2.isSecureContext === false && window2.webkitRTCPeerConnection) {
+    result.browser = "chrome";
+    result.version = extractVersion(
+      navigator2.userAgent,
+      /Chrom(e|ium)\/(\d+)\./,
+      2
+    );
+  } else if (window2.RTCPeerConnection && navigator2.userAgent.match(/AppleWebKit\/(\d+)\./)) {
+    result.browser = "safari";
+    result.version = extractVersion(
+      navigator2.userAgent,
+      /AppleWebKit\/(\d+)\./,
+      1
+    );
+    result.supportsUnifiedPlan = window2.RTCRtpTransceiver && "currentDirection" in window2.RTCRtpTransceiver.prototype;
+  } else {
+    result.browser = "Not a supported browser.";
+    return result;
+  }
+  return result;
+}
+function isObject(val) {
+  return Object.prototype.toString.call(val) === "[object Object]";
+}
+function compactObject(data) {
+  if (!isObject(data)) {
+    return data;
+  }
+  return Object.keys(data).reduce(function(accumulator, key) {
+    const isObj = isObject(data[key]);
+    const value = isObj ? compactObject(data[key]) : data[key];
+    const isEmptyObject = isObj && !Object.keys(value).length;
+    if (value === void 0 || isEmptyObject) {
+      return accumulator;
+    }
+    return Object.assign(accumulator, { [key]: value });
+  }, {});
+}
+function walkStats(stats, base, resultSet) {
+  if (!base || resultSet.has(base.id)) {
+    return;
+  }
+  resultSet.set(base.id, base);
+  Object.keys(base).forEach((name) => {
+    if (name.endsWith("Id")) {
+      walkStats(stats, stats.get(base[name]), resultSet);
+    } else if (name.endsWith("Ids")) {
+      base[name].forEach((id) => {
+        walkStats(stats, stats.get(id), resultSet);
+      });
+    }
+  });
+}
+function filterStats(result, track, outbound) {
+  const streamStatsType = outbound ? "outbound-rtp" : "inbound-rtp";
+  const filteredResult = /* @__PURE__ */ new Map();
+  if (track === null) {
+    return filteredResult;
+  }
+  const trackStats = [];
+  result.forEach((value) => {
+    if (value.type === "track" && value.trackIdentifier === track.id) {
+      trackStats.push(value);
+    }
+  });
+  trackStats.forEach((trackStat) => {
+    result.forEach((stats) => {
+      if (stats.type === streamStatsType && stats.trackId === trackStat.id) {
+        walkStats(result, stats, filteredResult);
+      }
+    });
+  });
+  return filteredResult;
+}
+const logging = log;
+function shimGetUserMedia$2(window2, browserDetails) {
+  const navigator2 = window2 && window2.navigator;
+  if (!navigator2.mediaDevices) {
+    return;
+  }
+  const constraintsToChrome_ = function(c) {
+    if (typeof c !== "object" || c.mandatory || c.optional) {
+      return c;
+    }
+    const cc = {};
+    Object.keys(c).forEach((key) => {
+      if (key === "require" || key === "advanced" || key === "mediaSource") {
+        return;
+      }
+      const r = typeof c[key] === "object" ? c[key] : { ideal: c[key] };
+      if (r.exact !== void 0 && typeof r.exact === "number") {
+        r.min = r.max = r.exact;
+      }
+      const oldname_ = function(prefix, name) {
+        if (prefix) {
+          return prefix + name.charAt(0).toUpperCase() + name.slice(1);
+        }
+        return name === "deviceId" ? "sourceId" : name;
+      };
+      if (r.ideal !== void 0) {
+        cc.optional = cc.optional || [];
+        let oc = {};
+        if (typeof r.ideal === "number") {
+          oc[oldname_("min", key)] = r.ideal;
+          cc.optional.push(oc);
+          oc = {};
+          oc[oldname_("max", key)] = r.ideal;
+          cc.optional.push(oc);
+        } else {
+          oc[oldname_("", key)] = r.ideal;
+          cc.optional.push(oc);
+        }
+      }
+      if (r.exact !== void 0 && typeof r.exact !== "number") {
+        cc.mandatory = cc.mandatory || {};
+        cc.mandatory[oldname_("", key)] = r.exact;
+      } else {
+        ["min", "max"].forEach((mix) => {
+          if (r[mix] !== void 0) {
+            cc.mandatory = cc.mandatory || {};
+            cc.mandatory[oldname_(mix, key)] = r[mix];
+          }
+        });
+      }
+    });
+    if (c.advanced) {
+      cc.optional = (cc.optional || []).concat(c.advanced);
+    }
+    return cc;
+  };
+  const shimConstraints_ = function(constraints, func) {
+    if (browserDetails.version >= 61) {
+      return func(constraints);
+    }
+    constraints = JSON.parse(JSON.stringify(constraints));
+    if (constraints && typeof constraints.audio === "object") {
+      const remap = function(obj, a, b) {
+        if (a in obj && !(b in obj)) {
+          obj[b] = obj[a];
+          delete obj[a];
+        }
+      };
+      constraints = JSON.parse(JSON.stringify(constraints));
+      remap(constraints.audio, "autoGainControl", "googAutoGainControl");
+      remap(constraints.audio, "noiseSuppression", "googNoiseSuppression");
+      constraints.audio = constraintsToChrome_(constraints.audio);
+    }
+    if (constraints && typeof constraints.video === "object") {
+      let face = constraints.video.facingMode;
+      face = face && (typeof face === "object" ? face : { ideal: face });
+      const getSupportedFacingModeLies = browserDetails.version < 66;
+      if (face && (face.exact === "user" || face.exact === "environment" || face.ideal === "user" || face.ideal === "environment") && !(navigator2.mediaDevices.getSupportedConstraints && navigator2.mediaDevices.getSupportedConstraints().facingMode && !getSupportedFacingModeLies)) {
+        delete constraints.video.facingMode;
+        let matches;
+        if (face.exact === "environment" || face.ideal === "environment") {
+          matches = ["back", "rear"];
+        } else if (face.exact === "user" || face.ideal === "user") {
+          matches = ["front"];
+        }
+        if (matches) {
+          return navigator2.mediaDevices.enumerateDevices().then((devices) => {
+            devices = devices.filter((d) => d.kind === "videoinput");
+            let dev = devices.find((d) => matches.some((match) => d.label.toLowerCase().includes(match)));
+            if (!dev && devices.length && matches.includes("back")) {
+              dev = devices[devices.length - 1];
+            }
+            if (dev) {
+              constraints.video.deviceId = face.exact ? { exact: dev.deviceId } : { ideal: dev.deviceId };
+            }
+            constraints.video = constraintsToChrome_(constraints.video);
+            logging("chrome: " + JSON.stringify(constraints));
+            return func(constraints);
+          });
+        }
+      }
+      constraints.video = constraintsToChrome_(constraints.video);
+    }
+    logging("chrome: " + JSON.stringify(constraints));
+    return func(constraints);
+  };
+  const shimError_ = function(e) {
+    if (browserDetails.version >= 64) {
+      return e;
+    }
+    return {
+      name: {
+        PermissionDeniedError: "NotAllowedError",
+        PermissionDismissedError: "NotAllowedError",
+        InvalidStateError: "NotAllowedError",
+        DevicesNotFoundError: "NotFoundError",
+        ConstraintNotSatisfiedError: "OverconstrainedError",
+        TrackStartError: "NotReadableError",
+        MediaDeviceFailedDueToShutdown: "NotAllowedError",
+        MediaDeviceKillSwitchOn: "NotAllowedError",
+        TabCaptureError: "AbortError",
+        ScreenCaptureError: "AbortError",
+        DeviceCaptureError: "AbortError"
+      }[e.name] || e.name,
+      message: e.message,
+      constraint: e.constraint || e.constraintName,
+      toString() {
+        return this.name + (this.message && ": ") + this.message;
+      }
+    };
+  };
+  const getUserMedia_ = function(constraints, onSuccess, onError) {
+    shimConstraints_(constraints, (c) => {
+      navigator2.webkitGetUserMedia(c, onSuccess, (e) => {
+        if (onError) {
+          onError(shimError_(e));
+        }
+      });
+    });
+  };
+  navigator2.getUserMedia = getUserMedia_.bind(navigator2);
+  if (navigator2.mediaDevices.getUserMedia) {
+    const origGetUserMedia = navigator2.mediaDevices.getUserMedia.bind(navigator2.mediaDevices);
+    navigator2.mediaDevices.getUserMedia = function(cs) {
+      return shimConstraints_(cs, (c) => origGetUserMedia(c).then((stream) => {
+        if (c.audio && !stream.getAudioTracks().length || c.video && !stream.getVideoTracks().length) {
+          stream.getTracks().forEach((track) => {
+            track.stop();
+          });
+          throw new DOMException("", "NotFoundError");
+        }
+        return stream;
+      }, (e) => Promise.reject(shimError_(e))));
+    };
+  }
+}
+function shimMediaStream(window2) {
+  window2.MediaStream = window2.MediaStream || window2.webkitMediaStream;
+}
+function shimOnTrack$1(window2) {
+  if (typeof window2 === "object" && window2.RTCPeerConnection && !("ontrack" in window2.RTCPeerConnection.prototype)) {
+    Object.defineProperty(window2.RTCPeerConnection.prototype, "ontrack", {
+      get() {
+        return this._ontrack;
+      },
+      set(f) {
+        if (this._ontrack) {
+          this.removeEventListener("track", this._ontrack);
+        }
+        this.addEventListener("track", this._ontrack = f);
+      },
+      enumerable: true,
+      configurable: true
+    });
+    const origSetRemoteDescription = window2.RTCPeerConnection.prototype.setRemoteDescription;
+    window2.RTCPeerConnection.prototype.setRemoteDescription = function setRemoteDescription() {
+      if (!this._ontrackpoly) {
+        this._ontrackpoly = (e) => {
+          e.stream.addEventListener("addtrack", (te) => {
+            let receiver;
+            if (window2.RTCPeerConnection.prototype.getReceivers) {
+              receiver = this.getReceivers().find((r) => r.track && r.track.id === te.track.id);
+            } else {
+              receiver = { track: te.track };
+            }
+            const event = new Event("track");
+            event.track = te.track;
+            event.receiver = receiver;
+            event.transceiver = { receiver };
+            event.streams = [e.stream];
+            this.dispatchEvent(event);
+          });
+          e.stream.getTracks().forEach((track) => {
+            let receiver;
+            if (window2.RTCPeerConnection.prototype.getReceivers) {
+              receiver = this.getReceivers().find((r) => r.track && r.track.id === track.id);
+            } else {
+              receiver = { track };
+            }
+            const event = new Event("track");
+            event.track = track;
+            event.receiver = receiver;
+            event.transceiver = { receiver };
+            event.streams = [e.stream];
+            this.dispatchEvent(event);
+          });
+        };
+        this.addEventListener("addstream", this._ontrackpoly);
+      }
+      return origSetRemoteDescription.apply(this, arguments);
+    };
+  } else {
+    wrapPeerConnectionEvent(window2, "track", (e) => {
+      if (!e.transceiver) {
+        Object.defineProperty(
+          e,
+          "transceiver",
+          { value: { receiver: e.receiver } }
+        );
+      }
+      return e;
+    });
+  }
+}
+function shimGetSendersWithDtmf(window2) {
+  if (typeof window2 === "object" && window2.RTCPeerConnection && !("getSenders" in window2.RTCPeerConnection.prototype) && "createDTMFSender" in window2.RTCPeerConnection.prototype) {
+    const shimSenderWithDtmf = function(pc, track) {
+      return {
+        track,
+        get dtmf() {
+          if (this._dtmf === void 0) {
+            if (track.kind === "audio") {
+              this._dtmf = pc.createDTMFSender(track);
+            } else {
+              this._dtmf = null;
+            }
+          }
+          return this._dtmf;
+        },
+        _pc: pc
+      };
+    };
+    if (!window2.RTCPeerConnection.prototype.getSenders) {
+      window2.RTCPeerConnection.prototype.getSenders = function getSenders() {
+        this._senders = this._senders || [];
+        return this._senders.slice();
+      };
+      const origAddTrack = window2.RTCPeerConnection.prototype.addTrack;
+      window2.RTCPeerConnection.prototype.addTrack = function addTrack(track, stream) {
+        let sender = origAddTrack.apply(this, arguments);
+        if (!sender) {
+          sender = shimSenderWithDtmf(this, track);
+          this._senders.push(sender);
+        }
+        return sender;
+      };
+      const origRemoveTrack = window2.RTCPeerConnection.prototype.removeTrack;
+      window2.RTCPeerConnection.prototype.removeTrack = function removeTrack(sender) {
+        origRemoveTrack.apply(this, arguments);
+        const idx = this._senders.indexOf(sender);
+        if (idx !== -1) {
+          this._senders.splice(idx, 1);
+        }
+      };
+    }
+    const origAddStream = window2.RTCPeerConnection.prototype.addStream;
+    window2.RTCPeerConnection.prototype.addStream = function addStream(stream) {
+      this._senders = this._senders || [];
+      origAddStream.apply(this, [stream]);
+      stream.getTracks().forEach((track) => {
+        this._senders.push(shimSenderWithDtmf(this, track));
+      });
+    };
+    const origRemoveStream = window2.RTCPeerConnection.prototype.removeStream;
+    window2.RTCPeerConnection.prototype.removeStream = function removeStream(stream) {
+      this._senders = this._senders || [];
+      origRemoveStream.apply(this, [stream]);
+      stream.getTracks().forEach((track) => {
+        const sender = this._senders.find((s) => s.track === track);
+        if (sender) {
+          this._senders.splice(this._senders.indexOf(sender), 1);
+        }
+      });
+    };
+  } else if (typeof window2 === "object" && window2.RTCPeerConnection && "getSenders" in window2.RTCPeerConnection.prototype && "createDTMFSender" in window2.RTCPeerConnection.prototype && window2.RTCRtpSender && !("dtmf" in window2.RTCRtpSender.prototype)) {
+    const origGetSenders = window2.RTCPeerConnection.prototype.getSenders;
+    window2.RTCPeerConnection.prototype.getSenders = function getSenders() {
+      const senders = origGetSenders.apply(this, []);
+      senders.forEach((sender) => sender._pc = this);
+      return senders;
+    };
+    Object.defineProperty(window2.RTCRtpSender.prototype, "dtmf", {
+      get() {
+        if (this._dtmf === void 0) {
+          if (this.track.kind === "audio") {
+            this._dtmf = this._pc.createDTMFSender(this.track);
+          } else {
+            this._dtmf = null;
+          }
+        }
+        return this._dtmf;
+      }
+    });
+  }
+}
+function shimSenderReceiverGetStats(window2) {
+  if (!(typeof window2 === "object" && window2.RTCPeerConnection && window2.RTCRtpSender && window2.RTCRtpReceiver)) {
+    return;
+  }
+  if (!("getStats" in window2.RTCRtpSender.prototype)) {
+    const origGetSenders = window2.RTCPeerConnection.prototype.getSenders;
+    if (origGetSenders) {
+      window2.RTCPeerConnection.prototype.getSenders = function getSenders() {
+        const senders = origGetSenders.apply(this, []);
+        senders.forEach((sender) => sender._pc = this);
+        return senders;
+      };
+    }
+    const origAddTrack = window2.RTCPeerConnection.prototype.addTrack;
+    if (origAddTrack) {
+      window2.RTCPeerConnection.prototype.addTrack = function addTrack() {
+        const sender = origAddTrack.apply(this, arguments);
+        sender._pc = this;
+        return sender;
+      };
+    }
+    window2.RTCRtpSender.prototype.getStats = function getStats() {
+      const sender = this;
+      return this._pc.getStats().then((result) => (
+        /* Note: this will include stats of all senders that
+         *   send a track with the same id as sender.track as
+         *   it is not possible to identify the RTCRtpSender.
+         */
+        filterStats(result, sender.track, true)
+      ));
+    };
+  }
+  if (!("getStats" in window2.RTCRtpReceiver.prototype)) {
+    const origGetReceivers = window2.RTCPeerConnection.prototype.getReceivers;
+    if (origGetReceivers) {
+      window2.RTCPeerConnection.prototype.getReceivers = function getReceivers() {
+        const receivers = origGetReceivers.apply(this, []);
+        receivers.forEach((receiver) => receiver._pc = this);
+        return receivers;
+      };
+    }
+    wrapPeerConnectionEvent(window2, "track", (e) => {
+      e.receiver._pc = e.srcElement;
+      return e;
+    });
+    window2.RTCRtpReceiver.prototype.getStats = function getStats() {
+      const receiver = this;
+      return this._pc.getStats().then((result) => filterStats(result, receiver.track, false));
+    };
+  }
+  if (!("getStats" in window2.RTCRtpSender.prototype && "getStats" in window2.RTCRtpReceiver.prototype)) {
+    return;
+  }
+  const origGetStats = window2.RTCPeerConnection.prototype.getStats;
+  window2.RTCPeerConnection.prototype.getStats = function getStats() {
+    if (arguments.length > 0 && arguments[0] instanceof window2.MediaStreamTrack) {
+      const track = arguments[0];
+      let sender;
+      let receiver;
+      let err;
+      this.getSenders().forEach((s) => {
+        if (s.track === track) {
+          if (sender) {
+            err = true;
+          } else {
+            sender = s;
+          }
+        }
+      });
+      this.getReceivers().forEach((r) => {
+        if (r.track === track) {
+          if (receiver) {
+            err = true;
+          } else {
+            receiver = r;
+          }
+        }
+        return r.track === track;
+      });
+      if (err || sender && receiver) {
+        return Promise.reject(new DOMException(
+          "There are more than one sender or receiver for the track.",
+          "InvalidAccessError"
+        ));
+      } else if (sender) {
+        return sender.getStats();
+      } else if (receiver) {
+        return receiver.getStats();
+      }
+      return Promise.reject(new DOMException(
+        "There is no sender or receiver for the track.",
+        "InvalidAccessError"
+      ));
+    }
+    return origGetStats.apply(this, arguments);
+  };
+}
+function shimAddTrackRemoveTrackWithNative(window2) {
+  window2.RTCPeerConnection.prototype.getLocalStreams = function getLocalStreams() {
+    this._shimmedLocalStreams = this._shimmedLocalStreams || {};
+    return Object.keys(this._shimmedLocalStreams).map((streamId) => this._shimmedLocalStreams[streamId][0]);
+  };
+  const origAddTrack = window2.RTCPeerConnection.prototype.addTrack;
+  window2.RTCPeerConnection.prototype.addTrack = function addTrack(track, stream) {
+    if (!stream) {
+      return origAddTrack.apply(this, arguments);
+    }
+    this._shimmedLocalStreams = this._shimmedLocalStreams || {};
+    const sender = origAddTrack.apply(this, arguments);
+    if (!this._shimmedLocalStreams[stream.id]) {
+      this._shimmedLocalStreams[stream.id] = [stream, sender];
+    } else if (this._shimmedLocalStreams[stream.id].indexOf(sender) === -1) {
+      this._shimmedLocalStreams[stream.id].push(sender);
+    }
+    return sender;
+  };
+  const origAddStream = window2.RTCPeerConnection.prototype.addStream;
+  window2.RTCPeerConnection.prototype.addStream = function addStream(stream) {
+    this._shimmedLocalStreams = this._shimmedLocalStreams || {};
+    stream.getTracks().forEach((track) => {
+      const alreadyExists = this.getSenders().find((s) => s.track === track);
+      if (alreadyExists) {
+        throw new DOMException(
+          "Track already exists.",
+          "InvalidAccessError"
+        );
+      }
+    });
+    const existingSenders = this.getSenders();
+    origAddStream.apply(this, arguments);
+    const newSenders = this.getSenders().filter((newSender) => existingSenders.indexOf(newSender) === -1);
+    this._shimmedLocalStreams[stream.id] = [stream].concat(newSenders);
+  };
+  const origRemoveStream = window2.RTCPeerConnection.prototype.removeStream;
+  window2.RTCPeerConnection.prototype.removeStream = function removeStream(stream) {
+    this._shimmedLocalStreams = this._shimmedLocalStreams || {};
+    delete this._shimmedLocalStreams[stream.id];
+    return origRemoveStream.apply(this, arguments);
+  };
+  const origRemoveTrack = window2.RTCPeerConnection.prototype.removeTrack;
+  window2.RTCPeerConnection.prototype.removeTrack = function removeTrack(sender) {
+    this._shimmedLocalStreams = this._shimmedLocalStreams || {};
+    if (sender) {
+      Object.keys(this._shimmedLocalStreams).forEach((streamId) => {
+        const idx = this._shimmedLocalStreams[streamId].indexOf(sender);
+        if (idx !== -1) {
+          this._shimmedLocalStreams[streamId].splice(idx, 1);
+        }
+        if (this._shimmedLocalStreams[streamId].length === 1) {
+          delete this._shimmedLocalStreams[streamId];
+        }
+      });
+    }
+    return origRemoveTrack.apply(this, arguments);
+  };
+}
+function shimAddTrackRemoveTrack(window2, browserDetails) {
+  if (!window2.RTCPeerConnection) {
+    return;
+  }
+  if (window2.RTCPeerConnection.prototype.addTrack && browserDetails.version >= 65) {
+    return shimAddTrackRemoveTrackWithNative(window2);
+  }
+  const origGetLocalStreams = window2.RTCPeerConnection.prototype.getLocalStreams;
+  window2.RTCPeerConnection.prototype.getLocalStreams = function getLocalStreams() {
+    const nativeStreams = origGetLocalStreams.apply(this);
+    this._reverseStreams = this._reverseStreams || {};
+    return nativeStreams.map((stream) => this._reverseStreams[stream.id]);
+  };
+  const origAddStream = window2.RTCPeerConnection.prototype.addStream;
+  window2.RTCPeerConnection.prototype.addStream = function addStream(stream) {
+    this._streams = this._streams || {};
+    this._reverseStreams = this._reverseStreams || {};
+    stream.getTracks().forEach((track) => {
+      const alreadyExists = this.getSenders().find((s) => s.track === track);
+      if (alreadyExists) {
+        throw new DOMException(
+          "Track already exists.",
+          "InvalidAccessError"
+        );
+      }
+    });
+    if (!this._reverseStreams[stream.id]) {
+      const newStream = new window2.MediaStream(stream.getTracks());
+      this._streams[stream.id] = newStream;
+      this._reverseStreams[newStream.id] = stream;
+      stream = newStream;
+    }
+    origAddStream.apply(this, [stream]);
+  };
+  const origRemoveStream = window2.RTCPeerConnection.prototype.removeStream;
+  window2.RTCPeerConnection.prototype.removeStream = function removeStream(stream) {
+    this._streams = this._streams || {};
+    this._reverseStreams = this._reverseStreams || {};
+    origRemoveStream.apply(this, [this._streams[stream.id] || stream]);
+    delete this._reverseStreams[this._streams[stream.id] ? this._streams[stream.id].id : stream.id];
+    delete this._streams[stream.id];
+  };
+  window2.RTCPeerConnection.prototype.addTrack = function addTrack(track, stream) {
+    if (this.signalingState === "closed") {
+      throw new DOMException(
+        "The RTCPeerConnection's signalingState is 'closed'.",
+        "InvalidStateError"
+      );
+    }
+    const streams = [].slice.call(arguments, 1);
+    if (streams.length !== 1 || !streams[0].getTracks().find((t) => t === track)) {
+      throw new DOMException(
+        "The adapter.js addTrack polyfill only supports a single  stream which is associated with the specified track.",
+        "NotSupportedError"
+      );
+    }
+    const alreadyExists = this.getSenders().find((s) => s.track === track);
+    if (alreadyExists) {
+      throw new DOMException(
+        "Track already exists.",
+        "InvalidAccessError"
+      );
+    }
+    this._streams = this._streams || {};
+    this._reverseStreams = this._reverseStreams || {};
+    const oldStream = this._streams[stream.id];
+    if (oldStream) {
+      oldStream.addTrack(track);
+      Promise.resolve().then(() => {
+        this.dispatchEvent(new Event("negotiationneeded"));
+      });
+    } else {
+      const newStream = new window2.MediaStream([track]);
+      this._streams[stream.id] = newStream;
+      this._reverseStreams[newStream.id] = stream;
+      this.addStream(newStream);
+    }
+    return this.getSenders().find((s) => s.track === track);
+  };
+  function replaceInternalStreamId(pc, description) {
+    let sdp2 = description.sdp;
+    Object.keys(pc._reverseStreams || []).forEach((internalId) => {
+      const externalStream = pc._reverseStreams[internalId];
+      const internalStream = pc._streams[externalStream.id];
+      sdp2 = sdp2.replace(
+        new RegExp(internalStream.id, "g"),
+        externalStream.id
+      );
+    });
+    return new RTCSessionDescription({
+      type: description.type,
+      sdp: sdp2
+    });
+  }
+  function replaceExternalStreamId(pc, description) {
+    let sdp2 = description.sdp;
+    Object.keys(pc._reverseStreams || []).forEach((internalId) => {
+      const externalStream = pc._reverseStreams[internalId];
+      const internalStream = pc._streams[externalStream.id];
+      sdp2 = sdp2.replace(
+        new RegExp(externalStream.id, "g"),
+        internalStream.id
+      );
+    });
+    return new RTCSessionDescription({
+      type: description.type,
+      sdp: sdp2
+    });
+  }
+  ["createOffer", "createAnswer"].forEach(function(method) {
+    const nativeMethod = window2.RTCPeerConnection.prototype[method];
+    const methodObj = { [method]() {
+      const args = arguments;
+      const isLegacyCall = arguments.length && typeof arguments[0] === "function";
+      if (isLegacyCall) {
+        return nativeMethod.apply(this, [
+          (description) => {
+            const desc = replaceInternalStreamId(this, description);
+            args[0].apply(null, [desc]);
+          },
+          (err) => {
+            if (args[1]) {
+              args[1].apply(null, err);
+            }
+          },
+          arguments[2]
+        ]);
+      }
+      return nativeMethod.apply(this, arguments).then((description) => replaceInternalStreamId(this, description));
+    } };
+    window2.RTCPeerConnection.prototype[method] = methodObj[method];
+  });
+  const origSetLocalDescription = window2.RTCPeerConnection.prototype.setLocalDescription;
+  window2.RTCPeerConnection.prototype.setLocalDescription = function setLocalDescription() {
+    if (!arguments.length || !arguments[0].type) {
+      return origSetLocalDescription.apply(this, arguments);
+    }
+    arguments[0] = replaceExternalStreamId(this, arguments[0]);
+    return origSetLocalDescription.apply(this, arguments);
+  };
+  const origLocalDescription = Object.getOwnPropertyDescriptor(
+    window2.RTCPeerConnection.prototype,
+    "localDescription"
+  );
+  Object.defineProperty(
+    window2.RTCPeerConnection.prototype,
+    "localDescription",
+    {
+      get() {
+        const description = origLocalDescription.get.apply(this);
+        if (description.type === "") {
+          return description;
+        }
+        return replaceInternalStreamId(this, description);
+      }
+    }
+  );
+  window2.RTCPeerConnection.prototype.removeTrack = function removeTrack(sender) {
+    if (this.signalingState === "closed") {
+      throw new DOMException(
+        "The RTCPeerConnection's signalingState is 'closed'.",
+        "InvalidStateError"
+      );
+    }
+    if (!sender._pc) {
+      throw new DOMException("Argument 1 of RTCPeerConnection.removeTrack does not implement interface RTCRtpSender.", "TypeError");
+    }
+    const isLocal = sender._pc === this;
+    if (!isLocal) {
+      throw new DOMException(
+        "Sender was not created by this connection.",
+        "InvalidAccessError"
+      );
+    }
+    this._streams = this._streams || {};
+    let stream;
+    Object.keys(this._streams).forEach((streamid) => {
+      const hasTrack = this._streams[streamid].getTracks().find((track) => sender.track === track);
+      if (hasTrack) {
+        stream = this._streams[streamid];
+      }
+    });
+    if (stream) {
+      if (stream.getTracks().length === 1) {
+        this.removeStream(this._reverseStreams[stream.id]);
+      } else {
+        stream.removeTrack(sender.track);
+      }
+      this.dispatchEvent(new Event("negotiationneeded"));
+    }
+  };
+}
+function shimPeerConnection$1(window2, browserDetails) {
+  if (!window2.RTCPeerConnection && window2.webkitRTCPeerConnection) {
+    window2.RTCPeerConnection = window2.webkitRTCPeerConnection;
+  }
+  if (!window2.RTCPeerConnection) {
+    return;
+  }
+  if (browserDetails.version < 53) {
+    ["setLocalDescription", "setRemoteDescription", "addIceCandidate"].forEach(function(method) {
+      const nativeMethod = window2.RTCPeerConnection.prototype[method];
+      const methodObj = { [method]() {
+        arguments[0] = new (method === "addIceCandidate" ? window2.RTCIceCandidate : window2.RTCSessionDescription)(arguments[0]);
+        return nativeMethod.apply(this, arguments);
+      } };
+      window2.RTCPeerConnection.prototype[method] = methodObj[method];
+    });
+  }
+}
+function fixNegotiationNeeded(window2, browserDetails) {
+  wrapPeerConnectionEvent(window2, "negotiationneeded", (e) => {
+    const pc = e.target;
+    if (browserDetails.version < 72 || pc.getConfiguration && pc.getConfiguration().sdpSemantics === "plan-b") {
+      if (pc.signalingState !== "stable") {
+        return;
+      }
+    }
+    return e;
+  });
+}
+const chromeShim = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  fixNegotiationNeeded,
+  shimAddTrackRemoveTrack,
+  shimAddTrackRemoveTrackWithNative,
+  shimGetSendersWithDtmf,
+  shimGetUserMedia: shimGetUserMedia$2,
+  shimMediaStream,
+  shimOnTrack: shimOnTrack$1,
+  shimPeerConnection: shimPeerConnection$1,
+  shimSenderReceiverGetStats
+}, Symbol.toStringTag, { value: "Module" }));
+function shimGetUserMedia$1(window2, browserDetails) {
+  const navigator2 = window2 && window2.navigator;
+  const MediaStreamTrack = window2 && window2.MediaStreamTrack;
+  navigator2.getUserMedia = function(constraints, onSuccess, onError) {
+    deprecated(
+      "navigator.getUserMedia",
+      "navigator.mediaDevices.getUserMedia"
+    );
+    navigator2.mediaDevices.getUserMedia(constraints).then(onSuccess, onError);
+  };
+  if (!(browserDetails.version > 55 && "autoGainControl" in navigator2.mediaDevices.getSupportedConstraints())) {
+    const remap = function(obj, a, b) {
+      if (a in obj && !(b in obj)) {
+        obj[b] = obj[a];
+        delete obj[a];
+      }
+    };
+    const nativeGetUserMedia = navigator2.mediaDevices.getUserMedia.bind(navigator2.mediaDevices);
+    navigator2.mediaDevices.getUserMedia = function(c) {
+      if (typeof c === "object" && typeof c.audio === "object") {
+        c = JSON.parse(JSON.stringify(c));
+        remap(c.audio, "autoGainControl", "mozAutoGainControl");
+        remap(c.audio, "noiseSuppression", "mozNoiseSuppression");
+      }
+      return nativeGetUserMedia(c);
+    };
+    if (MediaStreamTrack && MediaStreamTrack.prototype.getSettings) {
+      const nativeGetSettings = MediaStreamTrack.prototype.getSettings;
+      MediaStreamTrack.prototype.getSettings = function() {
+        const obj = nativeGetSettings.apply(this, arguments);
+        remap(obj, "mozAutoGainControl", "autoGainControl");
+        remap(obj, "mozNoiseSuppression", "noiseSuppression");
+        return obj;
+      };
+    }
+    if (MediaStreamTrack && MediaStreamTrack.prototype.applyConstraints) {
+      const nativeApplyConstraints = MediaStreamTrack.prototype.applyConstraints;
+      MediaStreamTrack.prototype.applyConstraints = function(c) {
+        if (this.kind === "audio" && typeof c === "object") {
+          c = JSON.parse(JSON.stringify(c));
+          remap(c, "autoGainControl", "mozAutoGainControl");
+          remap(c, "noiseSuppression", "mozNoiseSuppression");
+        }
+        return nativeApplyConstraints.apply(this, [c]);
+      };
+    }
+  }
+}
+function shimGetDisplayMedia(window2, preferredMediaSource) {
+  if (window2.navigator.mediaDevices && "getDisplayMedia" in window2.navigator.mediaDevices) {
+    return;
+  }
+  if (!window2.navigator.mediaDevices) {
+    return;
+  }
+  window2.navigator.mediaDevices.getDisplayMedia = function getDisplayMedia(constraints) {
+    if (!(constraints && constraints.video)) {
+      const err = new DOMException("getDisplayMedia without video constraints is undefined");
+      err.name = "NotFoundError";
+      err.code = 8;
+      return Promise.reject(err);
+    }
+    if (constraints.video === true) {
+      constraints.video = { mediaSource: preferredMediaSource };
+    } else {
+      constraints.video.mediaSource = preferredMediaSource;
+    }
+    return window2.navigator.mediaDevices.getUserMedia(constraints);
+  };
+}
+function shimOnTrack(window2) {
+  if (typeof window2 === "object" && window2.RTCTrackEvent && "receiver" in window2.RTCTrackEvent.prototype && !("transceiver" in window2.RTCTrackEvent.prototype)) {
+    Object.defineProperty(window2.RTCTrackEvent.prototype, "transceiver", {
+      get() {
+        return { receiver: this.receiver };
+      }
+    });
+  }
+}
+function shimPeerConnection(window2, browserDetails) {
+  if (typeof window2 !== "object" || !(window2.RTCPeerConnection || window2.mozRTCPeerConnection)) {
+    return;
+  }
+  if (!window2.RTCPeerConnection && window2.mozRTCPeerConnection) {
+    window2.RTCPeerConnection = window2.mozRTCPeerConnection;
+  }
+  if (browserDetails.version < 53) {
+    ["setLocalDescription", "setRemoteDescription", "addIceCandidate"].forEach(function(method) {
+      const nativeMethod = window2.RTCPeerConnection.prototype[method];
+      const methodObj = { [method]() {
+        arguments[0] = new (method === "addIceCandidate" ? window2.RTCIceCandidate : window2.RTCSessionDescription)(arguments[0]);
+        return nativeMethod.apply(this, arguments);
+      } };
+      window2.RTCPeerConnection.prototype[method] = methodObj[method];
+    });
+  }
+  const modernStatsTypes = {
+    inboundrtp: "inbound-rtp",
+    outboundrtp: "outbound-rtp",
+    candidatepair: "candidate-pair",
+    localcandidate: "local-candidate",
+    remotecandidate: "remote-candidate"
+  };
+  const nativeGetStats = window2.RTCPeerConnection.prototype.getStats;
+  window2.RTCPeerConnection.prototype.getStats = function getStats() {
+    const [selector, onSucc, onErr] = arguments;
+    return nativeGetStats.apply(this, [selector || null]).then((stats) => {
+      if (browserDetails.version < 53 && !onSucc) {
+        try {
+          stats.forEach((stat) => {
+            stat.type = modernStatsTypes[stat.type] || stat.type;
+          });
+        } catch (e) {
+          if (e.name !== "TypeError") {
+            throw e;
+          }
+          stats.forEach((stat, i) => {
+            stats.set(i, Object.assign({}, stat, {
+              type: modernStatsTypes[stat.type] || stat.type
+            }));
+          });
+        }
+      }
+      return stats;
+    }).then(onSucc, onErr);
+  };
+}
+function shimSenderGetStats(window2) {
+  if (!(typeof window2 === "object" && window2.RTCPeerConnection && window2.RTCRtpSender)) {
+    return;
+  }
+  if (window2.RTCRtpSender && "getStats" in window2.RTCRtpSender.prototype) {
+    return;
+  }
+  const origGetSenders = window2.RTCPeerConnection.prototype.getSenders;
+  if (origGetSenders) {
+    window2.RTCPeerConnection.prototype.getSenders = function getSenders() {
+      const senders = origGetSenders.apply(this, []);
+      senders.forEach((sender) => sender._pc = this);
+      return senders;
+    };
+  }
+  const origAddTrack = window2.RTCPeerConnection.prototype.addTrack;
+  if (origAddTrack) {
+    window2.RTCPeerConnection.prototype.addTrack = function addTrack() {
+      const sender = origAddTrack.apply(this, arguments);
+      sender._pc = this;
+      return sender;
+    };
+  }
+  window2.RTCRtpSender.prototype.getStats = function getStats() {
+    return this.track ? this._pc.getStats(this.track) : Promise.resolve(/* @__PURE__ */ new Map());
+  };
+}
+function shimReceiverGetStats(window2) {
+  if (!(typeof window2 === "object" && window2.RTCPeerConnection && window2.RTCRtpSender)) {
+    return;
+  }
+  if (window2.RTCRtpSender && "getStats" in window2.RTCRtpReceiver.prototype) {
+    return;
+  }
+  const origGetReceivers = window2.RTCPeerConnection.prototype.getReceivers;
+  if (origGetReceivers) {
+    window2.RTCPeerConnection.prototype.getReceivers = function getReceivers() {
+      const receivers = origGetReceivers.apply(this, []);
+      receivers.forEach((receiver) => receiver._pc = this);
+      return receivers;
+    };
+  }
+  wrapPeerConnectionEvent(window2, "track", (e) => {
+    e.receiver._pc = e.srcElement;
+    return e;
+  });
+  window2.RTCRtpReceiver.prototype.getStats = function getStats() {
+    return this._pc.getStats(this.track);
+  };
+}
+function shimRemoveStream(window2) {
+  if (!window2.RTCPeerConnection || "removeStream" in window2.RTCPeerConnection.prototype) {
+    return;
+  }
+  window2.RTCPeerConnection.prototype.removeStream = function removeStream(stream) {
+    deprecated("removeStream", "removeTrack");
+    this.getSenders().forEach((sender) => {
+      if (sender.track && stream.getTracks().includes(sender.track)) {
+        this.removeTrack(sender);
+      }
+    });
+  };
+}
+function shimRTCDataChannel(window2) {
+  if (window2.DataChannel && !window2.RTCDataChannel) {
+    window2.RTCDataChannel = window2.DataChannel;
+  }
+}
+function shimAddTransceiver(window2) {
+  if (!(typeof window2 === "object" && window2.RTCPeerConnection)) {
+    return;
+  }
+  const origAddTransceiver = window2.RTCPeerConnection.prototype.addTransceiver;
+  if (origAddTransceiver) {
+    window2.RTCPeerConnection.prototype.addTransceiver = function addTransceiver() {
+      this.setParametersPromises = [];
+      let sendEncodings = arguments[1] && arguments[1].sendEncodings;
+      if (sendEncodings === void 0) {
+        sendEncodings = [];
+      }
+      sendEncodings = [...sendEncodings];
+      const shouldPerformCheck = sendEncodings.length > 0;
+      if (shouldPerformCheck) {
+        sendEncodings.forEach((encodingParam) => {
+          if ("rid" in encodingParam) {
+            const ridRegex = /^[a-z0-9]{0,16}$/i;
+            if (!ridRegex.test(encodingParam.rid)) {
+              throw new TypeError("Invalid RID value provided.");
+            }
+          }
+          if ("scaleResolutionDownBy" in encodingParam) {
+            if (!(parseFloat(encodingParam.scaleResolutionDownBy) >= 1)) {
+              throw new RangeError("scale_resolution_down_by must be >= 1.0");
+            }
+          }
+          if ("maxFramerate" in encodingParam) {
+            if (!(parseFloat(encodingParam.maxFramerate) >= 0)) {
+              throw new RangeError("max_framerate must be >= 0.0");
+            }
+          }
+        });
+      }
+      const transceiver = origAddTransceiver.apply(this, arguments);
+      if (shouldPerformCheck) {
+        const { sender } = transceiver;
+        const params = sender.getParameters();
+        if (!("encodings" in params) || // Avoid being fooled by patched getParameters() below.
+        params.encodings.length === 1 && Object.keys(params.encodings[0]).length === 0) {
+          params.encodings = sendEncodings;
+          sender.sendEncodings = sendEncodings;
+          this.setParametersPromises.push(
+            sender.setParameters(params).then(() => {
+              delete sender.sendEncodings;
+            }).catch(() => {
+              delete sender.sendEncodings;
+            })
+          );
+        }
+      }
+      return transceiver;
+    };
+  }
+}
+function shimGetParameters(window2) {
+  if (!(typeof window2 === "object" && window2.RTCRtpSender)) {
+    return;
+  }
+  const origGetParameters = window2.RTCRtpSender.prototype.getParameters;
+  if (origGetParameters) {
+    window2.RTCRtpSender.prototype.getParameters = function getParameters() {
+      const params = origGetParameters.apply(this, arguments);
+      if (!("encodings" in params)) {
+        params.encodings = [].concat(this.sendEncodings || [{}]);
+      }
+      return params;
+    };
+  }
+}
+function shimCreateOffer(window2) {
+  if (!(typeof window2 === "object" && window2.RTCPeerConnection)) {
+    return;
+  }
+  const origCreateOffer = window2.RTCPeerConnection.prototype.createOffer;
+  window2.RTCPeerConnection.prototype.createOffer = function createOffer2() {
+    if (this.setParametersPromises && this.setParametersPromises.length) {
+      return Promise.all(this.setParametersPromises).then(() => {
+        return origCreateOffer.apply(this, arguments);
+      }).finally(() => {
+        this.setParametersPromises = [];
+      });
+    }
+    return origCreateOffer.apply(this, arguments);
+  };
+}
+function shimCreateAnswer(window2) {
+  if (!(typeof window2 === "object" && window2.RTCPeerConnection)) {
+    return;
+  }
+  const origCreateAnswer = window2.RTCPeerConnection.prototype.createAnswer;
+  window2.RTCPeerConnection.prototype.createAnswer = function createAnswer2() {
+    if (this.setParametersPromises && this.setParametersPromises.length) {
+      return Promise.all(this.setParametersPromises).then(() => {
+        return origCreateAnswer.apply(this, arguments);
+      }).finally(() => {
+        this.setParametersPromises = [];
+      });
+    }
+    return origCreateAnswer.apply(this, arguments);
+  };
+}
+const firefoxShim = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  shimAddTransceiver,
+  shimCreateAnswer,
+  shimCreateOffer,
+  shimGetDisplayMedia,
+  shimGetParameters,
+  shimGetUserMedia: shimGetUserMedia$1,
+  shimOnTrack,
+  shimPeerConnection,
+  shimRTCDataChannel,
+  shimReceiverGetStats,
+  shimRemoveStream,
+  shimSenderGetStats
+}, Symbol.toStringTag, { value: "Module" }));
+function shimLocalStreamsAPI(window2) {
+  if (typeof window2 !== "object" || !window2.RTCPeerConnection) {
+    return;
+  }
+  if (!("getLocalStreams" in window2.RTCPeerConnection.prototype)) {
+    window2.RTCPeerConnection.prototype.getLocalStreams = function getLocalStreams() {
+      if (!this._localStreams) {
+        this._localStreams = [];
+      }
+      return this._localStreams;
+    };
+  }
+  if (!("addStream" in window2.RTCPeerConnection.prototype)) {
+    const _addTrack = window2.RTCPeerConnection.prototype.addTrack;
+    window2.RTCPeerConnection.prototype.addStream = function addStream(stream) {
+      if (!this._localStreams) {
+        this._localStreams = [];
+      }
+      if (!this._localStreams.includes(stream)) {
+        this._localStreams.push(stream);
+      }
+      stream.getAudioTracks().forEach((track) => _addTrack.call(
+        this,
+        track,
+        stream
+      ));
+      stream.getVideoTracks().forEach((track) => _addTrack.call(
+        this,
+        track,
+        stream
+      ));
+    };
+    window2.RTCPeerConnection.prototype.addTrack = function addTrack(track, ...streams) {
+      if (streams) {
+        streams.forEach((stream) => {
+          if (!this._localStreams) {
+            this._localStreams = [stream];
+          } else if (!this._localStreams.includes(stream)) {
+            this._localStreams.push(stream);
+          }
+        });
+      }
+      return _addTrack.apply(this, arguments);
+    };
+  }
+  if (!("removeStream" in window2.RTCPeerConnection.prototype)) {
+    window2.RTCPeerConnection.prototype.removeStream = function removeStream(stream) {
+      if (!this._localStreams) {
+        this._localStreams = [];
+      }
+      const index = this._localStreams.indexOf(stream);
+      if (index === -1) {
+        return;
+      }
+      this._localStreams.splice(index, 1);
+      const tracks = stream.getTracks();
+      this.getSenders().forEach((sender) => {
+        if (tracks.includes(sender.track)) {
+          this.removeTrack(sender);
+        }
+      });
+    };
+  }
+}
+function shimRemoteStreamsAPI(window2) {
+  if (typeof window2 !== "object" || !window2.RTCPeerConnection) {
+    return;
+  }
+  if (!("getRemoteStreams" in window2.RTCPeerConnection.prototype)) {
+    window2.RTCPeerConnection.prototype.getRemoteStreams = function getRemoteStreams() {
+      return this._remoteStreams ? this._remoteStreams : [];
+    };
+  }
+  if (!("onaddstream" in window2.RTCPeerConnection.prototype)) {
+    Object.defineProperty(window2.RTCPeerConnection.prototype, "onaddstream", {
+      get() {
+        return this._onaddstream;
+      },
+      set(f) {
+        if (this._onaddstream) {
+          this.removeEventListener("addstream", this._onaddstream);
+          this.removeEventListener("track", this._onaddstreampoly);
+        }
+        this.addEventListener("addstream", this._onaddstream = f);
+        this.addEventListener("track", this._onaddstreampoly = (e) => {
+          e.streams.forEach((stream) => {
+            if (!this._remoteStreams) {
+              this._remoteStreams = [];
+            }
+            if (this._remoteStreams.includes(stream)) {
+              return;
+            }
+            this._remoteStreams.push(stream);
+            const event = new Event("addstream");
+            event.stream = stream;
+            this.dispatchEvent(event);
+          });
+        });
+      }
+    });
+    const origSetRemoteDescription = window2.RTCPeerConnection.prototype.setRemoteDescription;
+    window2.RTCPeerConnection.prototype.setRemoteDescription = function setRemoteDescription() {
+      const pc = this;
+      if (!this._onaddstreampoly) {
+        this.addEventListener("track", this._onaddstreampoly = function(e) {
+          e.streams.forEach((stream) => {
+            if (!pc._remoteStreams) {
+              pc._remoteStreams = [];
+            }
+            if (pc._remoteStreams.indexOf(stream) >= 0) {
+              return;
+            }
+            pc._remoteStreams.push(stream);
+            const event = new Event("addstream");
+            event.stream = stream;
+            pc.dispatchEvent(event);
+          });
+        });
+      }
+      return origSetRemoteDescription.apply(pc, arguments);
+    };
+  }
+}
+function shimCallbacksAPI(window2) {
+  if (typeof window2 !== "object" || !window2.RTCPeerConnection) {
+    return;
+  }
+  const prototype = window2.RTCPeerConnection.prototype;
+  const origCreateOffer = prototype.createOffer;
+  const origCreateAnswer = prototype.createAnswer;
+  const setLocalDescription = prototype.setLocalDescription;
+  const setRemoteDescription = prototype.setRemoteDescription;
+  const addIceCandidate2 = prototype.addIceCandidate;
+  prototype.createOffer = function createOffer2(successCallback, failureCallback) {
+    const options = arguments.length >= 2 ? arguments[2] : arguments[0];
+    const promise = origCreateOffer.apply(this, [options]);
+    if (!failureCallback) {
+      return promise;
+    }
+    promise.then(successCallback, failureCallback);
+    return Promise.resolve();
+  };
+  prototype.createAnswer = function createAnswer2(successCallback, failureCallback) {
+    const options = arguments.length >= 2 ? arguments[2] : arguments[0];
+    const promise = origCreateAnswer.apply(this, [options]);
+    if (!failureCallback) {
+      return promise;
+    }
+    promise.then(successCallback, failureCallback);
+    return Promise.resolve();
+  };
+  let withCallback = function(description, successCallback, failureCallback) {
+    const promise = setLocalDescription.apply(this, [description]);
+    if (!failureCallback) {
+      return promise;
+    }
+    promise.then(successCallback, failureCallback);
+    return Promise.resolve();
+  };
+  prototype.setLocalDescription = withCallback;
+  withCallback = function(description, successCallback, failureCallback) {
+    const promise = setRemoteDescription.apply(this, [description]);
+    if (!failureCallback) {
+      return promise;
+    }
+    promise.then(successCallback, failureCallback);
+    return Promise.resolve();
+  };
+  prototype.setRemoteDescription = withCallback;
+  withCallback = function(candidate, successCallback, failureCallback) {
+    const promise = addIceCandidate2.apply(this, [candidate]);
+    if (!failureCallback) {
+      return promise;
+    }
+    promise.then(successCallback, failureCallback);
+    return Promise.resolve();
+  };
+  prototype.addIceCandidate = withCallback;
+}
+function shimGetUserMedia(window2) {
+  const navigator2 = window2 && window2.navigator;
+  if (navigator2.mediaDevices && navigator2.mediaDevices.getUserMedia) {
+    const mediaDevices = navigator2.mediaDevices;
+    const _getUserMedia = mediaDevices.getUserMedia.bind(mediaDevices);
+    navigator2.mediaDevices.getUserMedia = (constraints) => {
+      return _getUserMedia(shimConstraints(constraints));
+    };
+  }
+  if (!navigator2.getUserMedia && navigator2.mediaDevices && navigator2.mediaDevices.getUserMedia) {
+    navigator2.getUserMedia = (function getUserMedia(constraints, cb, errcb) {
+      navigator2.mediaDevices.getUserMedia(constraints).then(cb, errcb);
+    }).bind(navigator2);
+  }
+}
+function shimConstraints(constraints) {
+  if (constraints && constraints.video !== void 0) {
+    return Object.assign(
+      {},
+      constraints,
+      { video: compactObject(constraints.video) }
+    );
+  }
+  return constraints;
+}
+function shimRTCIceServerUrls(window2) {
+  if (!window2.RTCPeerConnection) {
+    return;
+  }
+  const OrigPeerConnection = window2.RTCPeerConnection;
+  window2.RTCPeerConnection = function RTCPeerConnection(pcConfig, pcConstraints) {
+    if (pcConfig && pcConfig.iceServers) {
+      const newIceServers = [];
+      for (let i = 0; i < pcConfig.iceServers.length; i++) {
+        let server = pcConfig.iceServers[i];
+        if (server.urls === void 0 && server.url) {
+          deprecated("RTCIceServer.url", "RTCIceServer.urls");
+          server = JSON.parse(JSON.stringify(server));
+          server.urls = server.url;
+          delete server.url;
+          newIceServers.push(server);
+        } else {
+          newIceServers.push(pcConfig.iceServers[i]);
+        }
+      }
+      pcConfig.iceServers = newIceServers;
+    }
+    return new OrigPeerConnection(pcConfig, pcConstraints);
+  };
+  window2.RTCPeerConnection.prototype = OrigPeerConnection.prototype;
+  if ("generateCertificate" in OrigPeerConnection) {
+    Object.defineProperty(window2.RTCPeerConnection, "generateCertificate", {
+      get() {
+        return OrigPeerConnection.generateCertificate;
+      }
+    });
+  }
+}
+function shimTrackEventTransceiver(window2) {
+  if (typeof window2 === "object" && window2.RTCTrackEvent && "receiver" in window2.RTCTrackEvent.prototype && !("transceiver" in window2.RTCTrackEvent.prototype)) {
+    Object.defineProperty(window2.RTCTrackEvent.prototype, "transceiver", {
+      get() {
+        return { receiver: this.receiver };
+      }
+    });
+  }
+}
+function shimCreateOfferLegacy(window2) {
+  const origCreateOffer = window2.RTCPeerConnection.prototype.createOffer;
+  window2.RTCPeerConnection.prototype.createOffer = function createOffer2(offerOptions) {
+    if (offerOptions) {
+      if (typeof offerOptions.offerToReceiveAudio !== "undefined") {
+        offerOptions.offerToReceiveAudio = !!offerOptions.offerToReceiveAudio;
+      }
+      const audioTransceiver = this.getTransceivers().find((transceiver) => transceiver.receiver.track.kind === "audio");
+      if (offerOptions.offerToReceiveAudio === false && audioTransceiver) {
+        if (audioTransceiver.direction === "sendrecv") {
+          if (audioTransceiver.setDirection) {
+            audioTransceiver.setDirection("sendonly");
+          } else {
+            audioTransceiver.direction = "sendonly";
+          }
+        } else if (audioTransceiver.direction === "recvonly") {
+          if (audioTransceiver.setDirection) {
+            audioTransceiver.setDirection("inactive");
+          } else {
+            audioTransceiver.direction = "inactive";
+          }
+        }
+      } else if (offerOptions.offerToReceiveAudio === true && !audioTransceiver) {
+        this.addTransceiver("audio", { direction: "recvonly" });
+      }
+      if (typeof offerOptions.offerToReceiveVideo !== "undefined") {
+        offerOptions.offerToReceiveVideo = !!offerOptions.offerToReceiveVideo;
+      }
+      const videoTransceiver = this.getTransceivers().find((transceiver) => transceiver.receiver.track.kind === "video");
+      if (offerOptions.offerToReceiveVideo === false && videoTransceiver) {
+        if (videoTransceiver.direction === "sendrecv") {
+          if (videoTransceiver.setDirection) {
+            videoTransceiver.setDirection("sendonly");
+          } else {
+            videoTransceiver.direction = "sendonly";
+          }
+        } else if (videoTransceiver.direction === "recvonly") {
+          if (videoTransceiver.setDirection) {
+            videoTransceiver.setDirection("inactive");
+          } else {
+            videoTransceiver.direction = "inactive";
+          }
+        }
+      } else if (offerOptions.offerToReceiveVideo === true && !videoTransceiver) {
+        this.addTransceiver("video", { direction: "recvonly" });
+      }
+    }
+    return origCreateOffer.apply(this, arguments);
+  };
+}
+function shimAudioContext(window2) {
+  if (typeof window2 !== "object" || window2.AudioContext) {
+    return;
+  }
+  window2.AudioContext = window2.webkitAudioContext;
+}
+const safariShim = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  shimAudioContext,
+  shimCallbacksAPI,
+  shimConstraints,
+  shimCreateOfferLegacy,
+  shimGetUserMedia,
+  shimLocalStreamsAPI,
+  shimRTCIceServerUrls,
+  shimRemoteStreamsAPI,
+  shimTrackEventTransceiver
+}, Symbol.toStringTag, { value: "Module" }));
+var sdp$1 = { exports: {} };
+var hasRequiredSdp;
+function requireSdp() {
+  if (hasRequiredSdp) return sdp$1.exports;
+  hasRequiredSdp = 1;
+  (function(module) {
+    const SDPUtils2 = {};
+    SDPUtils2.generateIdentifier = function() {
+      return Math.random().toString(36).substring(2, 12);
+    };
+    SDPUtils2.localCName = SDPUtils2.generateIdentifier();
+    SDPUtils2.splitLines = function(blob) {
+      return blob.trim().split("\n").map((line) => line.trim());
+    };
+    SDPUtils2.splitSections = function(blob) {
+      const parts = blob.split("\nm=");
+      return parts.map((part, index) => (index > 0 ? "m=" + part : part).trim() + "\r\n");
+    };
+    SDPUtils2.getDescription = function(blob) {
+      const sections = SDPUtils2.splitSections(blob);
+      return sections && sections[0];
+    };
+    SDPUtils2.getMediaSections = function(blob) {
+      const sections = SDPUtils2.splitSections(blob);
+      sections.shift();
+      return sections;
+    };
+    SDPUtils2.matchPrefix = function(blob, prefix) {
+      return SDPUtils2.splitLines(blob).filter((line) => line.indexOf(prefix) === 0);
+    };
+    SDPUtils2.parseCandidate = function(line) {
+      let parts;
+      if (line.indexOf("a=candidate:") === 0) {
+        parts = line.substring(12).split(" ");
+      } else {
+        parts = line.substring(10).split(" ");
+      }
+      const candidate = {
+        foundation: parts[0],
+        component: { 1: "rtp", 2: "rtcp" }[parts[1]] || parts[1],
+        protocol: parts[2].toLowerCase(),
+        priority: parseInt(parts[3], 10),
+        ip: parts[4],
+        address: parts[4],
+        // address is an alias for ip.
+        port: parseInt(parts[5], 10),
+        // skip parts[6] == 'typ'
+        type: parts[7]
+      };
+      for (let i = 8; i < parts.length; i += 2) {
+        switch (parts[i]) {
+          case "raddr":
+            candidate.relatedAddress = parts[i + 1];
+            break;
+          case "rport":
+            candidate.relatedPort = parseInt(parts[i + 1], 10);
+            break;
+          case "tcptype":
+            candidate.tcpType = parts[i + 1];
+            break;
+          case "ufrag":
+            candidate.ufrag = parts[i + 1];
+            candidate.usernameFragment = parts[i + 1];
+            break;
+          default:
+            if (candidate[parts[i]] === void 0) {
+              candidate[parts[i]] = parts[i + 1];
+            }
+            break;
+        }
+      }
+      return candidate;
+    };
+    SDPUtils2.writeCandidate = function(candidate) {
+      const sdp2 = [];
+      sdp2.push(candidate.foundation);
+      const component = candidate.component;
+      if (component === "rtp") {
+        sdp2.push(1);
+      } else if (component === "rtcp") {
+        sdp2.push(2);
+      } else {
+        sdp2.push(component);
+      }
+      sdp2.push(candidate.protocol.toUpperCase());
+      sdp2.push(candidate.priority);
+      sdp2.push(candidate.address || candidate.ip);
+      sdp2.push(candidate.port);
+      const type = candidate.type;
+      sdp2.push("typ");
+      sdp2.push(type);
+      if (type !== "host" && candidate.relatedAddress && candidate.relatedPort) {
+        sdp2.push("raddr");
+        sdp2.push(candidate.relatedAddress);
+        sdp2.push("rport");
+        sdp2.push(candidate.relatedPort);
+      }
+      if (candidate.tcpType && candidate.protocol.toLowerCase() === "tcp") {
+        sdp2.push("tcptype");
+        sdp2.push(candidate.tcpType);
+      }
+      if (candidate.usernameFragment || candidate.ufrag) {
+        sdp2.push("ufrag");
+        sdp2.push(candidate.usernameFragment || candidate.ufrag);
+      }
+      return "candidate:" + sdp2.join(" ");
+    };
+    SDPUtils2.parseIceOptions = function(line) {
+      return line.substring(14).split(" ");
+    };
+    SDPUtils2.parseRtpMap = function(line) {
+      let parts = line.substring(9).split(" ");
+      const parsed = {
+        payloadType: parseInt(parts.shift(), 10)
+        // was: id
+      };
+      parts = parts[0].split("/");
+      parsed.name = parts[0];
+      parsed.clockRate = parseInt(parts[1], 10);
+      parsed.channels = parts.length === 3 ? parseInt(parts[2], 10) : 1;
+      parsed.numChannels = parsed.channels;
+      return parsed;
+    };
+    SDPUtils2.writeRtpMap = function(codec) {
+      let pt = codec.payloadType;
+      if (codec.preferredPayloadType !== void 0) {
+        pt = codec.preferredPayloadType;
+      }
+      const channels = codec.channels || codec.numChannels || 1;
+      return "a=rtpmap:" + pt + " " + codec.name + "/" + codec.clockRate + (channels !== 1 ? "/" + channels : "") + "\r\n";
+    };
+    SDPUtils2.parseExtmap = function(line) {
+      const parts = line.substring(9).split(" ");
+      return {
+        id: parseInt(parts[0], 10),
+        direction: parts[0].indexOf("/") > 0 ? parts[0].split("/")[1] : "sendrecv",
+        uri: parts[1],
+        attributes: parts.slice(2).join(" ")
+      };
+    };
+    SDPUtils2.writeExtmap = function(headerExtension) {
+      return "a=extmap:" + (headerExtension.id || headerExtension.preferredId) + (headerExtension.direction && headerExtension.direction !== "sendrecv" ? "/" + headerExtension.direction : "") + " " + headerExtension.uri + (headerExtension.attributes ? " " + headerExtension.attributes : "") + "\r\n";
+    };
+    SDPUtils2.parseFmtp = function(line) {
+      const parsed = {};
+      let kv;
+      const parts = line.substring(line.indexOf(" ") + 1).split(";");
+      for (let j = 0; j < parts.length; j++) {
+        kv = parts[j].trim().split("=");
+        parsed[kv[0].trim()] = kv[1];
+      }
+      return parsed;
+    };
+    SDPUtils2.writeFmtp = function(codec) {
+      let line = "";
+      let pt = codec.payloadType;
+      if (codec.preferredPayloadType !== void 0) {
+        pt = codec.preferredPayloadType;
+      }
+      if (codec.parameters && Object.keys(codec.parameters).length) {
+        const params = [];
+        Object.keys(codec.parameters).forEach((param) => {
+          if (codec.parameters[param] !== void 0) {
+            params.push(param + "=" + codec.parameters[param]);
+          } else {
+            params.push(param);
+          }
+        });
+        line += "a=fmtp:" + pt + " " + params.join(";") + "\r\n";
+      }
+      return line;
+    };
+    SDPUtils2.parseRtcpFb = function(line) {
+      const parts = line.substring(line.indexOf(" ") + 1).split(" ");
+      return {
+        type: parts.shift(),
+        parameter: parts.join(" ")
+      };
+    };
+    SDPUtils2.writeRtcpFb = function(codec) {
+      let lines = "";
+      let pt = codec.payloadType;
+      if (codec.preferredPayloadType !== void 0) {
+        pt = codec.preferredPayloadType;
+      }
+      if (codec.rtcpFeedback && codec.rtcpFeedback.length) {
+        codec.rtcpFeedback.forEach((fb) => {
+          lines += "a=rtcp-fb:" + pt + " " + fb.type + (fb.parameter && fb.parameter.length ? " " + fb.parameter : "") + "\r\n";
+        });
+      }
+      return lines;
+    };
+    SDPUtils2.parseSsrcMedia = function(line) {
+      const sp = line.indexOf(" ");
+      const parts = {
+        ssrc: parseInt(line.substring(7, sp), 10)
+      };
+      const colon = line.indexOf(":", sp);
+      if (colon > -1) {
+        parts.attribute = line.substring(sp + 1, colon);
+        parts.value = line.substring(colon + 1);
+      } else {
+        parts.attribute = line.substring(sp + 1);
+      }
+      return parts;
+    };
+    SDPUtils2.parseSsrcGroup = function(line) {
+      const parts = line.substring(13).split(" ");
+      return {
+        semantics: parts.shift(),
+        ssrcs: parts.map((ssrc) => parseInt(ssrc, 10))
+      };
+    };
+    SDPUtils2.getMid = function(mediaSection) {
+      const mid = SDPUtils2.matchPrefix(mediaSection, "a=mid:")[0];
+      if (mid) {
+        return mid.substring(6);
+      }
+    };
+    SDPUtils2.parseFingerprint = function(line) {
+      const parts = line.substring(14).split(" ");
+      return {
+        algorithm: parts[0].toLowerCase(),
+        // algorithm is case-sensitive in Edge.
+        value: parts[1].toUpperCase()
+        // the definition is upper-case in RFC 4572.
+      };
+    };
+    SDPUtils2.getDtlsParameters = function(mediaSection, sessionpart) {
+      const lines = SDPUtils2.matchPrefix(
+        mediaSection + sessionpart,
+        "a=fingerprint:"
+      );
+      return {
+        role: "auto",
+        fingerprints: lines.map(SDPUtils2.parseFingerprint)
+      };
+    };
+    SDPUtils2.writeDtlsParameters = function(params, setupType) {
+      let sdp2 = "a=setup:" + setupType + "\r\n";
+      params.fingerprints.forEach((fp) => {
+        sdp2 += "a=fingerprint:" + fp.algorithm + " " + fp.value + "\r\n";
+      });
+      return sdp2;
+    };
+    SDPUtils2.parseCryptoLine = function(line) {
+      const parts = line.substring(9).split(" ");
+      return {
+        tag: parseInt(parts[0], 10),
+        cryptoSuite: parts[1],
+        keyParams: parts[2],
+        sessionParams: parts.slice(3)
+      };
+    };
+    SDPUtils2.writeCryptoLine = function(parameters) {
+      return "a=crypto:" + parameters.tag + " " + parameters.cryptoSuite + " " + (typeof parameters.keyParams === "object" ? SDPUtils2.writeCryptoKeyParams(parameters.keyParams) : parameters.keyParams) + (parameters.sessionParams ? " " + parameters.sessionParams.join(" ") : "") + "\r\n";
+    };
+    SDPUtils2.parseCryptoKeyParams = function(keyParams) {
+      if (keyParams.indexOf("inline:") !== 0) {
+        return null;
+      }
+      const parts = keyParams.substring(7).split("|");
+      return {
+        keyMethod: "inline",
+        keySalt: parts[0],
+        lifeTime: parts[1],
+        mkiValue: parts[2] ? parts[2].split(":")[0] : void 0,
+        mkiLength: parts[2] ? parts[2].split(":")[1] : void 0
+      };
+    };
+    SDPUtils2.writeCryptoKeyParams = function(keyParams) {
+      return keyParams.keyMethod + ":" + keyParams.keySalt + (keyParams.lifeTime ? "|" + keyParams.lifeTime : "") + (keyParams.mkiValue && keyParams.mkiLength ? "|" + keyParams.mkiValue + ":" + keyParams.mkiLength : "");
+    };
+    SDPUtils2.getCryptoParameters = function(mediaSection, sessionpart) {
+      const lines = SDPUtils2.matchPrefix(
+        mediaSection + sessionpart,
+        "a=crypto:"
+      );
+      return lines.map(SDPUtils2.parseCryptoLine);
+    };
+    SDPUtils2.getIceParameters = function(mediaSection, sessionpart) {
+      const ufrag = SDPUtils2.matchPrefix(
+        mediaSection + sessionpart,
+        "a=ice-ufrag:"
+      )[0];
+      const pwd = SDPUtils2.matchPrefix(
+        mediaSection + sessionpart,
+        "a=ice-pwd:"
+      )[0];
+      if (!(ufrag && pwd)) {
+        return null;
+      }
+      return {
+        usernameFragment: ufrag.substring(12),
+        password: pwd.substring(10)
+      };
+    };
+    SDPUtils2.writeIceParameters = function(params) {
+      let sdp2 = "a=ice-ufrag:" + params.usernameFragment + "\r\na=ice-pwd:" + params.password + "\r\n";
+      if (params.iceLite) {
+        sdp2 += "a=ice-lite\r\n";
+      }
+      return sdp2;
+    };
+    SDPUtils2.parseRtpParameters = function(mediaSection) {
+      const description = {
+        codecs: [],
+        headerExtensions: [],
+        fecMechanisms: [],
+        rtcp: []
+      };
+      const lines = SDPUtils2.splitLines(mediaSection);
+      const mline = lines[0].split(" ");
+      description.profile = mline[2];
+      for (let i = 3; i < mline.length; i++) {
+        const pt = mline[i];
+        const rtpmapline = SDPUtils2.matchPrefix(
+          mediaSection,
+          "a=rtpmap:" + pt + " "
+        )[0];
+        if (rtpmapline) {
+          const codec = SDPUtils2.parseRtpMap(rtpmapline);
+          const fmtps = SDPUtils2.matchPrefix(
+            mediaSection,
+            "a=fmtp:" + pt + " "
+          );
+          codec.parameters = fmtps.length ? SDPUtils2.parseFmtp(fmtps[0]) : {};
+          codec.rtcpFeedback = SDPUtils2.matchPrefix(
+            mediaSection,
+            "a=rtcp-fb:" + pt + " "
+          ).map(SDPUtils2.parseRtcpFb);
+          description.codecs.push(codec);
+          switch (codec.name.toUpperCase()) {
+            case "RED":
+            case "ULPFEC":
+              description.fecMechanisms.push(codec.name.toUpperCase());
+              break;
+          }
+        }
+      }
+      SDPUtils2.matchPrefix(mediaSection, "a=extmap:").forEach((line) => {
+        description.headerExtensions.push(SDPUtils2.parseExtmap(line));
+      });
+      const wildcardRtcpFb = SDPUtils2.matchPrefix(mediaSection, "a=rtcp-fb:* ").map(SDPUtils2.parseRtcpFb);
+      description.codecs.forEach((codec) => {
+        wildcardRtcpFb.forEach((fb) => {
+          const duplicate = codec.rtcpFeedback.find((existingFeedback) => {
+            return existingFeedback.type === fb.type && existingFeedback.parameter === fb.parameter;
+          });
+          if (!duplicate) {
+            codec.rtcpFeedback.push(fb);
+          }
+        });
+      });
+      return description;
+    };
+    SDPUtils2.writeRtpDescription = function(kind, caps) {
+      let sdp2 = "";
+      sdp2 += "m=" + kind + " ";
+      sdp2 += caps.codecs.length > 0 ? "9" : "0";
+      sdp2 += " " + (caps.profile || "UDP/TLS/RTP/SAVPF") + " ";
+      sdp2 += caps.codecs.map((codec) => {
+        if (codec.preferredPayloadType !== void 0) {
+          return codec.preferredPayloadType;
+        }
+        return codec.payloadType;
+      }).join(" ") + "\r\n";
+      sdp2 += "c=IN IP4 0.0.0.0\r\n";
+      sdp2 += "a=rtcp:9 IN IP4 0.0.0.0\r\n";
+      caps.codecs.forEach((codec) => {
+        sdp2 += SDPUtils2.writeRtpMap(codec);
+        sdp2 += SDPUtils2.writeFmtp(codec);
+        sdp2 += SDPUtils2.writeRtcpFb(codec);
+      });
+      let maxptime = 0;
+      caps.codecs.forEach((codec) => {
+        if (codec.maxptime > maxptime) {
+          maxptime = codec.maxptime;
+        }
+      });
+      if (maxptime > 0) {
+        sdp2 += "a=maxptime:" + maxptime + "\r\n";
+      }
+      if (caps.headerExtensions) {
+        caps.headerExtensions.forEach((extension) => {
+          sdp2 += SDPUtils2.writeExtmap(extension);
+        });
+      }
+      return sdp2;
+    };
+    SDPUtils2.parseRtpEncodingParameters = function(mediaSection) {
+      const encodingParameters = [];
+      const description = SDPUtils2.parseRtpParameters(mediaSection);
+      const hasRed = description.fecMechanisms.indexOf("RED") !== -1;
+      const hasUlpfec = description.fecMechanisms.indexOf("ULPFEC") !== -1;
+      const ssrcs = SDPUtils2.matchPrefix(mediaSection, "a=ssrc:").map((line) => SDPUtils2.parseSsrcMedia(line)).filter((parts) => parts.attribute === "cname");
+      const primarySsrc = ssrcs.length > 0 && ssrcs[0].ssrc;
+      let secondarySsrc;
+      const flows = SDPUtils2.matchPrefix(mediaSection, "a=ssrc-group:FID").map((line) => {
+        const parts = line.substring(17).split(" ");
+        return parts.map((part) => parseInt(part, 10));
+      });
+      if (flows.length > 0 && flows[0].length > 1 && flows[0][0] === primarySsrc) {
+        secondarySsrc = flows[0][1];
+      }
+      description.codecs.forEach((codec) => {
+        if (codec.name.toUpperCase() === "RTX" && codec.parameters.apt) {
+          let encParam = {
+            ssrc: primarySsrc,
+            codecPayloadType: parseInt(codec.parameters.apt, 10)
+          };
+          if (primarySsrc && secondarySsrc) {
+            encParam.rtx = { ssrc: secondarySsrc };
+          }
+          encodingParameters.push(encParam);
+          if (hasRed) {
+            encParam = JSON.parse(JSON.stringify(encParam));
+            encParam.fec = {
+              ssrc: primarySsrc,
+              mechanism: hasUlpfec ? "red+ulpfec" : "red"
+            };
+            encodingParameters.push(encParam);
+          }
+        }
+      });
+      if (encodingParameters.length === 0 && primarySsrc) {
+        encodingParameters.push({
+          ssrc: primarySsrc
+        });
+      }
+      let bandwidth = SDPUtils2.matchPrefix(mediaSection, "b=");
+      if (bandwidth.length) {
+        if (bandwidth[0].indexOf("b=TIAS:") === 0) {
+          bandwidth = parseInt(bandwidth[0].substring(7), 10);
+        } else if (bandwidth[0].indexOf("b=AS:") === 0) {
+          bandwidth = parseInt(bandwidth[0].substring(5), 10) * 1e3 * 0.95 - 50 * 40 * 8;
+        } else {
+          bandwidth = void 0;
+        }
+        encodingParameters.forEach((params) => {
+          params.maxBitrate = bandwidth;
+        });
+      }
+      return encodingParameters;
+    };
+    SDPUtils2.parseRtcpParameters = function(mediaSection) {
+      const rtcpParameters = {};
+      const remoteSsrc = SDPUtils2.matchPrefix(mediaSection, "a=ssrc:").map((line) => SDPUtils2.parseSsrcMedia(line)).filter((obj) => obj.attribute === "cname")[0];
+      if (remoteSsrc) {
+        rtcpParameters.cname = remoteSsrc.value;
+        rtcpParameters.ssrc = remoteSsrc.ssrc;
+      }
+      const rsize = SDPUtils2.matchPrefix(mediaSection, "a=rtcp-rsize");
+      rtcpParameters.reducedSize = rsize.length > 0;
+      rtcpParameters.compound = rsize.length === 0;
+      const mux = SDPUtils2.matchPrefix(mediaSection, "a=rtcp-mux");
+      rtcpParameters.mux = mux.length > 0;
+      return rtcpParameters;
+    };
+    SDPUtils2.writeRtcpParameters = function(rtcpParameters) {
+      let sdp2 = "";
+      if (rtcpParameters.reducedSize) {
+        sdp2 += "a=rtcp-rsize\r\n";
+      }
+      if (rtcpParameters.mux) {
+        sdp2 += "a=rtcp-mux\r\n";
+      }
+      if (rtcpParameters.ssrc !== void 0 && rtcpParameters.cname) {
+        sdp2 += "a=ssrc:" + rtcpParameters.ssrc + " cname:" + rtcpParameters.cname + "\r\n";
+      }
+      return sdp2;
+    };
+    SDPUtils2.parseMsid = function(mediaSection) {
+      let parts;
+      const spec = SDPUtils2.matchPrefix(mediaSection, "a=msid:");
+      if (spec.length === 1) {
+        parts = spec[0].substring(7).split(" ");
+        return { stream: parts[0], track: parts[1] };
+      }
+      const planB = SDPUtils2.matchPrefix(mediaSection, "a=ssrc:").map((line) => SDPUtils2.parseSsrcMedia(line)).filter((msidParts) => msidParts.attribute === "msid");
+      if (planB.length > 0) {
+        parts = planB[0].value.split(" ");
+        return { stream: parts[0], track: parts[1] };
+      }
+    };
+    SDPUtils2.parseSctpDescription = function(mediaSection) {
+      const mline = SDPUtils2.parseMLine(mediaSection);
+      const maxSizeLine = SDPUtils2.matchPrefix(mediaSection, "a=max-message-size:");
+      let maxMessageSize;
+      if (maxSizeLine.length > 0) {
+        maxMessageSize = parseInt(maxSizeLine[0].substring(19), 10);
+      }
+      if (isNaN(maxMessageSize)) {
+        maxMessageSize = 65536;
+      }
+      const sctpPort = SDPUtils2.matchPrefix(mediaSection, "a=sctp-port:");
+      if (sctpPort.length > 0) {
+        return {
+          port: parseInt(sctpPort[0].substring(12), 10),
+          protocol: mline.fmt,
+          maxMessageSize
+        };
+      }
+      const sctpMapLines = SDPUtils2.matchPrefix(mediaSection, "a=sctpmap:");
+      if (sctpMapLines.length > 0) {
+        const parts = sctpMapLines[0].substring(10).split(" ");
+        return {
+          port: parseInt(parts[0], 10),
+          protocol: parts[1],
+          maxMessageSize
+        };
+      }
+    };
+    SDPUtils2.writeSctpDescription = function(media, sctp) {
+      let output = [];
+      if (media.protocol !== "DTLS/SCTP") {
+        output = [
+          "m=" + media.kind + " 9 " + media.protocol + " " + sctp.protocol + "\r\n",
+          "c=IN IP4 0.0.0.0\r\n",
+          "a=sctp-port:" + sctp.port + "\r\n"
+        ];
+      } else {
+        output = [
+          "m=" + media.kind + " 9 " + media.protocol + " " + sctp.port + "\r\n",
+          "c=IN IP4 0.0.0.0\r\n",
+          "a=sctpmap:" + sctp.port + " " + sctp.protocol + " 65535\r\n"
+        ];
+      }
+      if (sctp.maxMessageSize !== void 0) {
+        output.push("a=max-message-size:" + sctp.maxMessageSize + "\r\n");
+      }
+      return output.join("");
+    };
+    SDPUtils2.generateSessionId = function() {
+      return Math.random().toString().substr(2, 22);
+    };
+    SDPUtils2.writeSessionBoilerplate = function(sessId, sessVer, sessUser) {
+      let sessionId;
+      const version = sessVer !== void 0 ? sessVer : 2;
+      if (sessId) {
+        sessionId = sessId;
+      } else {
+        sessionId = SDPUtils2.generateSessionId();
+      }
+      const user = sessUser || "thisisadapterortc";
+      return "v=0\r\no=" + user + " " + sessionId + " " + version + " IN IP4 127.0.0.1\r\ns=-\r\nt=0 0\r\n";
+    };
+    SDPUtils2.getDirection = function(mediaSection, sessionpart) {
+      const lines = SDPUtils2.splitLines(mediaSection);
+      for (let i = 0; i < lines.length; i++) {
+        switch (lines[i]) {
+          case "a=sendrecv":
+          case "a=sendonly":
+          case "a=recvonly":
+          case "a=inactive":
+            return lines[i].substring(2);
+        }
+      }
+      if (sessionpart) {
+        return SDPUtils2.getDirection(sessionpart);
+      }
+      return "sendrecv";
+    };
+    SDPUtils2.getKind = function(mediaSection) {
+      const lines = SDPUtils2.splitLines(mediaSection);
+      const mline = lines[0].split(" ");
+      return mline[0].substring(2);
+    };
+    SDPUtils2.isRejected = function(mediaSection) {
+      return mediaSection.split(" ", 2)[1] === "0";
+    };
+    SDPUtils2.parseMLine = function(mediaSection) {
+      const lines = SDPUtils2.splitLines(mediaSection);
+      const parts = lines[0].substring(2).split(" ");
+      return {
+        kind: parts[0],
+        port: parseInt(parts[1], 10),
+        protocol: parts[2],
+        fmt: parts.slice(3).join(" ")
+      };
+    };
+    SDPUtils2.parseOLine = function(mediaSection) {
+      const line = SDPUtils2.matchPrefix(mediaSection, "o=")[0];
+      const parts = line.substring(2).split(" ");
+      return {
+        username: parts[0],
+        sessionId: parts[1],
+        sessionVersion: parseInt(parts[2], 10),
+        netType: parts[3],
+        addressType: parts[4],
+        address: parts[5]
+      };
+    };
+    SDPUtils2.isValidSDP = function(blob) {
+      if (typeof blob !== "string" || blob.length === 0) {
+        return false;
+      }
+      const lines = SDPUtils2.splitLines(blob);
+      for (let i = 0; i < lines.length; i++) {
+        if (lines[i].length < 2 || lines[i].charAt(1) !== "=") {
+          return false;
+        }
+      }
+      return true;
+    };
+    {
+      module.exports = SDPUtils2;
+    }
+  })(sdp$1);
+  return sdp$1.exports;
+}
+var sdpExports = requireSdp();
+const SDPUtils = /* @__PURE__ */ getDefaultExportFromCjs(sdpExports);
+const sdp = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: SDPUtils
+}, [sdpExports]);
+function shimRTCIceCandidate(window2) {
+  if (!window2.RTCIceCandidate || window2.RTCIceCandidate && "foundation" in window2.RTCIceCandidate.prototype) {
+    return;
+  }
+  const NativeRTCIceCandidate = window2.RTCIceCandidate;
+  window2.RTCIceCandidate = function RTCIceCandidate2(args) {
+    if (typeof args === "object" && args.candidate && args.candidate.indexOf("a=") === 0) {
+      args = JSON.parse(JSON.stringify(args));
+      args.candidate = args.candidate.substring(2);
+    }
+    if (args.candidate && args.candidate.length) {
+      const nativeCandidate = new NativeRTCIceCandidate(args);
+      const parsedCandidate = SDPUtils.parseCandidate(args.candidate);
+      for (const key in parsedCandidate) {
+        if (!(key in nativeCandidate)) {
+          Object.defineProperty(
+            nativeCandidate,
+            key,
+            { value: parsedCandidate[key] }
+          );
+        }
+      }
+      nativeCandidate.toJSON = function toJSON() {
+        return {
+          candidate: nativeCandidate.candidate,
+          sdpMid: nativeCandidate.sdpMid,
+          sdpMLineIndex: nativeCandidate.sdpMLineIndex,
+          usernameFragment: nativeCandidate.usernameFragment
+        };
+      };
+      return nativeCandidate;
+    }
+    return new NativeRTCIceCandidate(args);
+  };
+  window2.RTCIceCandidate.prototype = NativeRTCIceCandidate.prototype;
+  wrapPeerConnectionEvent(window2, "icecandidate", (e) => {
+    if (e.candidate) {
+      Object.defineProperty(e, "candidate", {
+        value: new window2.RTCIceCandidate(e.candidate),
+        writable: "false"
+      });
+    }
+    return e;
+  });
+}
+function shimRTCIceCandidateRelayProtocol(window2) {
+  if (!window2.RTCIceCandidate || window2.RTCIceCandidate && "relayProtocol" in window2.RTCIceCandidate.prototype) {
+    return;
+  }
+  wrapPeerConnectionEvent(window2, "icecandidate", (e) => {
+    if (e.candidate) {
+      const parsedCandidate = SDPUtils.parseCandidate(e.candidate.candidate);
+      if (parsedCandidate.type === "relay") {
+        e.candidate.relayProtocol = {
+          0: "tls",
+          1: "tcp",
+          2: "udp"
+        }[parsedCandidate.priority >> 24];
+      }
+    }
+    return e;
+  });
+}
+function shimMaxMessageSize(window2, browserDetails) {
+  if (!window2.RTCPeerConnection) {
+    return;
+  }
+  if (!("sctp" in window2.RTCPeerConnection.prototype)) {
+    Object.defineProperty(window2.RTCPeerConnection.prototype, "sctp", {
+      get() {
+        return typeof this._sctp === "undefined" ? null : this._sctp;
+      }
+    });
+  }
+  const sctpInDescription = function(description) {
+    if (!description || !description.sdp) {
+      return false;
+    }
+    const sections = SDPUtils.splitSections(description.sdp);
+    sections.shift();
+    return sections.some((mediaSection) => {
+      const mLine = SDPUtils.parseMLine(mediaSection);
+      return mLine && mLine.kind === "application" && mLine.protocol.indexOf("SCTP") !== -1;
+    });
+  };
+  const getRemoteFirefoxVersion = function(description) {
+    const match = description.sdp.match(/mozilla...THIS_IS_SDPARTA-(\d+)/);
+    if (match === null || match.length < 2) {
+      return -1;
+    }
+    const version = parseInt(match[1], 10);
+    return version !== version ? -1 : version;
+  };
+  const getCanSendMaxMessageSize = function(remoteIsFirefox) {
+    let canSendMaxMessageSize = 65536;
+    if (browserDetails.browser === "firefox") {
+      if (browserDetails.version < 57) {
+        if (remoteIsFirefox === -1) {
+          canSendMaxMessageSize = 16384;
+        } else {
+          canSendMaxMessageSize = 2147483637;
+        }
+      } else if (browserDetails.version < 60) {
+        canSendMaxMessageSize = browserDetails.version === 57 ? 65535 : 65536;
+      } else {
+        canSendMaxMessageSize = 2147483637;
+      }
+    }
+    return canSendMaxMessageSize;
+  };
+  const getMaxMessageSize = function(description, remoteIsFirefox) {
+    let maxMessageSize = 65536;
+    if (browserDetails.browser === "firefox" && browserDetails.version === 57) {
+      maxMessageSize = 65535;
+    }
+    const match = SDPUtils.matchPrefix(
+      description.sdp,
+      "a=max-message-size:"
+    );
+    if (match.length > 0) {
+      maxMessageSize = parseInt(match[0].substring(19), 10);
+    } else if (browserDetails.browser === "firefox" && remoteIsFirefox !== -1) {
+      maxMessageSize = 2147483637;
+    }
+    return maxMessageSize;
+  };
+  const origSetRemoteDescription = window2.RTCPeerConnection.prototype.setRemoteDescription;
+  window2.RTCPeerConnection.prototype.setRemoteDescription = function setRemoteDescription() {
+    this._sctp = null;
+    if (browserDetails.browser === "chrome" && browserDetails.version >= 76) {
+      const { sdpSemantics } = this.getConfiguration();
+      if (sdpSemantics === "plan-b") {
+        Object.defineProperty(this, "sctp", {
+          get() {
+            return typeof this._sctp === "undefined" ? null : this._sctp;
+          },
+          enumerable: true,
+          configurable: true
+        });
+      }
+    }
+    if (sctpInDescription(arguments[0])) {
+      const isFirefox = getRemoteFirefoxVersion(arguments[0]);
+      const canSendMMS = getCanSendMaxMessageSize(isFirefox);
+      const remoteMMS = getMaxMessageSize(arguments[0], isFirefox);
+      let maxMessageSize;
+      if (canSendMMS === 0 && remoteMMS === 0) {
+        maxMessageSize = Number.POSITIVE_INFINITY;
+      } else if (canSendMMS === 0 || remoteMMS === 0) {
+        maxMessageSize = Math.max(canSendMMS, remoteMMS);
+      } else {
+        maxMessageSize = Math.min(canSendMMS, remoteMMS);
+      }
+      const sctp = {};
+      Object.defineProperty(sctp, "maxMessageSize", {
+        get() {
+          return maxMessageSize;
+        }
+      });
+      this._sctp = sctp;
+    }
+    return origSetRemoteDescription.apply(this, arguments);
+  };
+}
+function shimSendThrowTypeError(window2) {
+  if (!(window2.RTCPeerConnection && "createDataChannel" in window2.RTCPeerConnection.prototype)) {
+    return;
+  }
+  function wrapDcSend(dc, pc) {
+    const origDataChannelSend = dc.send;
+    dc.send = function send() {
+      const data = arguments[0];
+      const length = data.length || data.size || data.byteLength;
+      if (dc.readyState === "open" && pc.sctp && length > pc.sctp.maxMessageSize) {
+        throw new TypeError("Message too large (can send a maximum of " + pc.sctp.maxMessageSize + " bytes)");
+      }
+      return origDataChannelSend.apply(dc, arguments);
+    };
+  }
+  const origCreateDataChannel = window2.RTCPeerConnection.prototype.createDataChannel;
+  window2.RTCPeerConnection.prototype.createDataChannel = function createDataChannel() {
+    const dataChannel = origCreateDataChannel.apply(this, arguments);
+    wrapDcSend(dataChannel, this);
+    return dataChannel;
+  };
+  wrapPeerConnectionEvent(window2, "datachannel", (e) => {
+    wrapDcSend(e.channel, e.target);
+    return e;
+  });
+}
+function shimConnectionState(window2) {
+  if (!window2.RTCPeerConnection || "connectionState" in window2.RTCPeerConnection.prototype) {
+    return;
+  }
+  const proto = window2.RTCPeerConnection.prototype;
+  Object.defineProperty(proto, "connectionState", {
+    get() {
+      return {
+        completed: "connected",
+        checking: "connecting"
+      }[this.iceConnectionState] || this.iceConnectionState;
+    },
+    enumerable: true,
+    configurable: true
+  });
+  Object.defineProperty(proto, "onconnectionstatechange", {
+    get() {
+      return this._onconnectionstatechange || null;
+    },
+    set(cb) {
+      if (this._onconnectionstatechange) {
+        this.removeEventListener(
+          "connectionstatechange",
+          this._onconnectionstatechange
+        );
+        delete this._onconnectionstatechange;
+      }
+      if (cb) {
+        this.addEventListener(
+          "connectionstatechange",
+          this._onconnectionstatechange = cb
+        );
+      }
+    },
+    enumerable: true,
+    configurable: true
+  });
+  ["setLocalDescription", "setRemoteDescription"].forEach((method) => {
+    const origMethod = proto[method];
+    proto[method] = function() {
+      if (!this._connectionstatechangepoly) {
+        this._connectionstatechangepoly = (e) => {
+          const pc = e.target;
+          if (pc._lastConnectionState !== pc.connectionState) {
+            pc._lastConnectionState = pc.connectionState;
+            const newEvent = new Event("connectionstatechange", e);
+            pc.dispatchEvent(newEvent);
+          }
+          return e;
+        };
+        this.addEventListener(
+          "iceconnectionstatechange",
+          this._connectionstatechangepoly
+        );
+      }
+      return origMethod.apply(this, arguments);
+    };
+  });
+}
+function removeExtmapAllowMixed(window2, browserDetails) {
+  if (!window2.RTCPeerConnection) {
+    return;
+  }
+  if (browserDetails.browser === "chrome" && browserDetails.version >= 71) {
+    return;
+  }
+  if (browserDetails.browser === "safari" && browserDetails.version >= 605) {
+    return;
+  }
+  const nativeSRD = window2.RTCPeerConnection.prototype.setRemoteDescription;
+  window2.RTCPeerConnection.prototype.setRemoteDescription = function setRemoteDescription(desc) {
+    if (desc && desc.sdp && desc.sdp.indexOf("\na=extmap-allow-mixed") !== -1) {
+      const sdp2 = desc.sdp.split("\n").filter((line) => {
+        return line.trim() !== "a=extmap-allow-mixed";
+      }).join("\n");
+      if (window2.RTCSessionDescription && desc instanceof window2.RTCSessionDescription) {
+        arguments[0] = new window2.RTCSessionDescription({
+          type: desc.type,
+          sdp: sdp2
+        });
+      } else {
+        desc.sdp = sdp2;
+      }
+    }
+    return nativeSRD.apply(this, arguments);
+  };
+}
+function shimAddIceCandidateNullOrEmpty(window2, browserDetails) {
+  if (!(window2.RTCPeerConnection && window2.RTCPeerConnection.prototype)) {
+    return;
+  }
+  const nativeAddIceCandidate = window2.RTCPeerConnection.prototype.addIceCandidate;
+  if (!nativeAddIceCandidate || nativeAddIceCandidate.length === 0) {
+    return;
+  }
+  window2.RTCPeerConnection.prototype.addIceCandidate = function addIceCandidate2() {
+    if (!arguments[0]) {
+      if (arguments[1]) {
+        arguments[1].apply(null);
+      }
+      return Promise.resolve();
+    }
+    if ((browserDetails.browser === "chrome" && browserDetails.version < 78 || browserDetails.browser === "firefox" && browserDetails.version < 68 || browserDetails.browser === "safari") && arguments[0] && arguments[0].candidate === "") {
+      return Promise.resolve();
+    }
+    return nativeAddIceCandidate.apply(this, arguments);
+  };
+}
+function shimParameterlessSetLocalDescription(window2, browserDetails) {
+  if (!(window2.RTCPeerConnection && window2.RTCPeerConnection.prototype)) {
+    return;
+  }
+  const nativeSetLocalDescription = window2.RTCPeerConnection.prototype.setLocalDescription;
+  if (!nativeSetLocalDescription || nativeSetLocalDescription.length === 0) {
+    return;
+  }
+  window2.RTCPeerConnection.prototype.setLocalDescription = function setLocalDescription() {
+    let desc = arguments[0] || {};
+    if (typeof desc !== "object" || desc.type && desc.sdp) {
+      return nativeSetLocalDescription.apply(this, arguments);
+    }
+    desc = { type: desc.type, sdp: desc.sdp };
+    if (!desc.type) {
+      switch (this.signalingState) {
+        case "stable":
+        case "have-local-offer":
+        case "have-remote-pranswer":
+          desc.type = "offer";
+          break;
+        default:
+          desc.type = "answer";
+          break;
+      }
+    }
+    if (desc.sdp || desc.type !== "offer" && desc.type !== "answer") {
+      return nativeSetLocalDescription.apply(this, [desc]);
+    }
+    const func = desc.type === "offer" ? this.createOffer : this.createAnswer;
+    return func.apply(this).then((d) => nativeSetLocalDescription.apply(this, [d]));
+  };
+}
+const commonShim = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  removeExtmapAllowMixed,
+  shimAddIceCandidateNullOrEmpty,
+  shimConnectionState,
+  shimMaxMessageSize,
+  shimParameterlessSetLocalDescription,
+  shimRTCIceCandidate,
+  shimRTCIceCandidateRelayProtocol,
+  shimSendThrowTypeError
+}, Symbol.toStringTag, { value: "Module" }));
+function adapterFactory({ window: window2 } = {}, options = {
+  shimChrome: true,
+  shimFirefox: true,
+  shimSafari: true
+}) {
+  const logging2 = log;
+  const browserDetails = detectBrowser(window2);
+  const adapter2 = {
+    browserDetails,
+    commonShim,
+    extractVersion,
+    disableLog,
+    disableWarnings,
+    // Expose sdp as a convenience. For production apps include directly.
+    sdp
+  };
+  switch (browserDetails.browser) {
+    case "chrome":
+      if (!chromeShim || !shimPeerConnection$1 || !options.shimChrome) {
+        logging2("Chrome shim is not included in this adapter release.");
+        return adapter2;
+      }
+      if (browserDetails.version === null) {
+        logging2("Chrome shim can not determine version, not shimming.");
+        return adapter2;
+      }
+      logging2("adapter.js shimming chrome.");
+      adapter2.browserShim = chromeShim;
+      shimAddIceCandidateNullOrEmpty(window2, browserDetails);
+      shimParameterlessSetLocalDescription(window2);
+      shimGetUserMedia$2(window2, browserDetails);
+      shimMediaStream(window2);
+      shimPeerConnection$1(window2, browserDetails);
+      shimOnTrack$1(window2);
+      shimAddTrackRemoveTrack(window2, browserDetails);
+      shimGetSendersWithDtmf(window2);
+      shimSenderReceiverGetStats(window2);
+      fixNegotiationNeeded(window2, browserDetails);
+      shimRTCIceCandidate(window2);
+      shimRTCIceCandidateRelayProtocol(window2);
+      shimConnectionState(window2);
+      shimMaxMessageSize(window2, browserDetails);
+      shimSendThrowTypeError(window2);
+      removeExtmapAllowMixed(window2, browserDetails);
+      break;
+    case "firefox":
+      if (!firefoxShim || !shimPeerConnection || !options.shimFirefox) {
+        logging2("Firefox shim is not included in this adapter release.");
+        return adapter2;
+      }
+      logging2("adapter.js shimming firefox.");
+      adapter2.browserShim = firefoxShim;
+      shimAddIceCandidateNullOrEmpty(window2, browserDetails);
+      shimParameterlessSetLocalDescription(window2);
+      shimGetUserMedia$1(window2, browserDetails);
+      shimPeerConnection(window2, browserDetails);
+      shimOnTrack(window2);
+      shimRemoveStream(window2);
+      shimSenderGetStats(window2);
+      shimReceiverGetStats(window2);
+      shimRTCDataChannel(window2);
+      shimAddTransceiver(window2);
+      shimGetParameters(window2);
+      shimCreateOffer(window2);
+      shimCreateAnswer(window2);
+      shimRTCIceCandidate(window2);
+      shimConnectionState(window2);
+      shimMaxMessageSize(window2, browserDetails);
+      shimSendThrowTypeError(window2);
+      break;
+    case "safari":
+      if (!safariShim || !options.shimSafari) {
+        logging2("Safari shim is not included in this adapter release.");
+        return adapter2;
+      }
+      logging2("adapter.js shimming safari.");
+      adapter2.browserShim = safariShim;
+      shimAddIceCandidateNullOrEmpty(window2, browserDetails);
+      shimParameterlessSetLocalDescription(window2);
+      shimRTCIceServerUrls(window2);
+      shimCreateOfferLegacy(window2);
+      shimCallbacksAPI(window2);
+      shimLocalStreamsAPI(window2);
+      shimRemoteStreamsAPI(window2);
+      shimTrackEventTransceiver(window2);
+      shimGetUserMedia(window2);
+      shimAudioContext(window2);
+      shimRTCIceCandidate(window2);
+      shimRTCIceCandidateRelayProtocol(window2);
+      shimMaxMessageSize(window2, browserDetails);
+      shimSendThrowTypeError(window2);
+      removeExtmapAllowMixed(window2, browserDetails);
+      break;
+    default:
+      logging2("Unsupported browser!");
+      break;
+  }
+  return adapter2;
+}
+const adapter = adapterFactory({ window: typeof window === "undefined" ? void 0 : window });
+const setRemoteDescriptionWithHandleOffer = (peerConnection, sdp2, sendAnswer, onError) => {
+  const description = new RTCSessionDescription({ type: "offer", sdp: sdp2 });
+  peerConnection.setRemoteDescription(description).then(() => createAnswer(peerConnection, sendAnswer, onError)).catch((error) => onError == null ? void 0 : onError(createWebRtcError(FailCode.HANDLE_OFFER, error)));
+};
+const createAnswer = (peerConnection, sendAnswer, onError) => {
+  peerConnection.createAnswer().then((answer) => setLocalDescriptionWithCreateAnswer(peerConnection, answer, sendAnswer, onError)).catch((error) => onError == null ? void 0 : onError(createWebRtcError(FailCode.CREATE_ANSWER, error)));
+};
+const setLocalDescriptionWithCreateAnswer = (peerConnection, answer, sendAnswer, onError) => {
+  peerConnection.setLocalDescription(answer).then(() => {
+    sendAnswer == null ? void 0 : sendAnswer(answer.sdp ?? "");
+  }).catch((error) => onError == null ? void 0 : onError(createWebRtcError(FailCode.LOCAL_DES, error)));
+};
+const createPeerConnection = (config) => {
+  const iceServers = [
+    { urls: config.stunServerUri },
+    { urls: config.stunServerUriAli },
+    {
+      urls: config.turnServerUri,
+      username: config.turnServerUserName,
+      credential: config.turnServerPassword
+    }
+  ];
+  const peerConnectionConfig = {
+    iceServers,
+    iceTransportPolicy: "all",
+    sdpSemantics: "unified-plan",
+    rtcpMuxPolicy: "require",
+    bundlePolicy: "max-bundle"
+  };
+  if (adapter.browserDetails.browser === "chrome") {
+    peerConnectionConfig.sdpSemantics = adapter.browserDetails.version && adapter.browserDetails.version < 72 ? "plan-b" : "unified-plan";
+  }
+  const constraints = {
+    optional: [{ DtlsSrtpKeyAgreement: true }, { googIPv6: true }]
+  };
+  const RTCPeerConnection = window.RTCPeerConnection || window.mozRTCPeerConnection || window.webkitRTCPeerConnection;
+  return new RTCPeerConnection(peerConnectionConfig, constraints);
+};
+const configPeerConnection = (peerConnection, onICEMessage, onTrack, onConnectState, onError) => {
+  peerConnection.onicecandidate = (event) => {
+    if (!event.candidate) {
+      console.log("ICE candidate collection completed");
+      return;
+    }
+    const candidateObj = {
+      sdp: event.candidate.candidate,
+      sdpMid: event.candidate.sdpMid,
+      sdpMLineIndex: event.candidate.sdpMLineIndex
+    };
+    onICEMessage(JSON.stringify(candidateObj));
+  };
+  peerConnection.oniceconnectionstatechange = () => {
+    const state = peerConnection.iceConnectionState;
+    if (!state) {
+      return;
+    }
+    if (state === "failed") {
+      onError == null ? void 0 : onError(createWebRtcError(FailCode.ICE_STATE, "failed"));
+    }
+    onConnectState == null ? void 0 : onConnectState(state);
+  };
+  peerConnection.ontrack = (event) => {
+    const track = event.track;
+    track.contentHint = "detail";
+    onTrack == null ? void 0 : onTrack(track);
+  };
+};
+const setRemoteDescriptionWithHandleAnswer = (peerConnection, sdp2, onError) => {
+  const description = new RTCSessionDescription({ type: "answer", sdp: sdp2 });
+  peerConnection.setRemoteDescription(description).catch((err) => onError == null ? void 0 : onError(createWebRtcError(FailCode.REMOTE_DES, err)));
+};
+const createOffer = (peerConnection, sendOfferMessage, onError) => {
+  peerConnection.createOffer().then((offer) => setLocalDescriptionWithCreateOffer(peerConnection, offer, sendOfferMessage, onError)).catch((err) => onError == null ? void 0 : onError(createWebRtcError(FailCode.CREATE_OFFER, err)));
+};
+const setLocalDescriptionWithCreateOffer = (peerConnection, offer, sendOfferMessage, onError) => {
+  peerConnection.setLocalDescription(offer).then(() => sendOfferMessage(offer.sdp ?? "")).catch((err) => onError == null ? void 0 : onError(createWebRtcError(FailCode.LOCAL_DES, err)));
+};
+const addIceCandidate = (peerConnection, candidate, onError) => {
+  peerConnection.addIceCandidate(candidate).catch((err) => onError == null ? void 0 : onError(createWebRtcError(FailCode.HANDLE_ICE, err)));
+};
+class WebRTCClient extends EventEmitter {
+  constructor(config) {
+    super();
+    __publicField(this, "config");
+    __publicField(this, "peerConnection", null);
+    __publicField(this, "localStream", null);
+    __publicField(this, "isPushingStream", false);
+    __publicField(this, "dataChannel", null);
+    __publicField(this, "statsTimer", null);
+    __publicField(this, "lastReportTime", 0);
+    __publicField(this, "lastBytesReceived", 0);
+    __publicField(this, "lastPacketsLost", 0);
+    __publicField(this, "lastPacketsReceived", 0);
+    __publicField(this, "lostPacketCount", 0);
+    __publicField(this, "maxLostRate", 0);
+    __publicField(this, "decodedCount", 0);
+    __publicField(this, "lastSecondDecodedCount", 0);
+    this.config = config;
+  }
+  async startPush() {
+    if (this.isPushingStream) return;
+    this.isPushingStream = true;
+    try {
+      await this.readyCapture();
+    } catch (err) {
+      this.emit(EmitType.webrtcError, createWebRtcError(FailCode.CAMERA, err));
+    }
+  }
+  handleOffer(offerSdp) {
+    this.resetPeerConnection();
+    setRemoteDescriptionWithHandleOffer(this.peerConnection, offerSdp, (sdp2) => {
+      this.emit(EmitType.sendAnswer, sdp2);
+    }, (err) => this.emit(EmitType.webrtcError, err));
+  }
+  handleAnswer(answerSdp) {
+    setRemoteDescriptionWithHandleAnswer(this.peerConnection, answerSdp, (err) => this.emit(EmitType.webrtcError, err));
+  }
+  handleIceCandidate(candidate) {
+    addIceCandidate(this.peerConnection, candidate, (err) => this.emit(EmitType.webrtcError, err));
+  }
+  sendChannelData(type, data) {
+    try {
+      let channelData = "";
+      switch (type) {
+        case ChannelDataType.ClickData:
+          channelData = ChannelData.click(data);
+          break;
+        case ChannelDataType.ClipboardData:
+          channelData = ChannelData.clipboard(data);
+          break;
+        case ChannelDataType.ActionInput:
+          channelData = ChannelData.input(data);
+          break;
+        case ChannelDataType.ActionChinese:
+          channelData = ChannelData.chinese(data);
+          break;
+        case ChannelDataType.ActionRequestCloudDeviceInfo:
+          channelData = ChannelData.requestCloudDeviceInfo();
+          break;
+        case ChannelDataType.ActionClarity:
+          channelData = ChannelData.clarity(data);
+          break;
+      }
+      const buffer = new TextEncoder().encode(channelData).buffer;
+      this.dataChannel.send(buffer);
+    } catch (err) {
+      this.emit(EmitType.webrtcError, createWebRtcError(FailCode.DATACHANNEL_ERR, err));
+    }
+  }
+  closeConnection() {
+    if (this.statsTimer) {
+      clearInterval(this.statsTimer);
+      this.statsTimer = null;
+    }
+    if (!this.peerConnection) {
+      if (this.peerConnection.getSenders) {
+        this.peerConnection.getSenders().forEach((sender) => {
+          if (sender.track) {
+            sender.track.stop();
+          }
+        });
+      }
+      if (this.peerConnection.getReceivers) {
+        this.peerConnection.getReceivers().forEach((receiver) => {
+          if (receiver.track) {
+            receiver.track.stop();
+          }
+        });
+      }
+      if (this.peerConnection.getTransceivers) {
+        this.peerConnection.getTransceivers().forEach((transceiver) => {
+          var _a;
+          (_a = transceiver.stop) == null ? void 0 : _a.call(transceiver);
+        });
+      }
+      this.peerConnection.close();
+      this.removeAllListeners();
+      this.dataChannel = null;
+      this.peerConnection.onicecandidate = null;
+      this.peerConnection.ontrack = null;
+      this.peerConnection.ondatachannel = null;
+      this.peerConnection.onconnectionstatechange = null;
+      this.peerConnection.oniceconnectionstatechange = null;
+      this.peerConnection.onsignalingstatechange = null;
+      this.peerConnection.onnegotiationneeded = null;
+      this.peerConnection.onicegatheringstatechange = null;
+      this.peerConnection = null;
+    }
+  }
+  async readyCapture() {
+    this.resetPeerConnection();
+    try {
+      this.localStream = await navigator.mediaDevices.getUserMedia({ video: { width: 640, height: 480 }, audio: true });
+      const rotatedStream = await this.getRotatedStream(this.localStream);
+      rotatedStream.getTracks().forEach((track) => {
+        track.contentHint = "detail";
+        this.peerConnection.addTrack(track, rotatedStream);
+      });
+      this.peerConnection.getSenders().forEach((sender) => this.setVideoParams(sender));
+      createOffer(this.peerConnection, (sdp2) => {
+        this.emit(EmitType.sendOffer, sdp2);
+      }, (err) => this.emit(EmitType.webrtcError, err));
+    } catch (e) {
+      throw new Error(`mediaDevices error: ${e}`);
+    }
+  }
+  async getRotatedStream(localStream) {
+    const canvas = document.createElement("canvas");
+    const ctx = canvas.getContext("2d");
+    const videoTrack = localStream.getVideoTracks()[0];
+    const { width, height } = await new Promise((resolve) => {
+      const video2 = document.createElement("video");
+      video2.srcObject = new MediaStream([videoTrack]);
+      video2.onloadedmetadata = () => resolve({ width: video2.videoWidth, height: video2.videoHeight });
+    });
+    canvas.width = 640;
+    canvas.height = 480;
+    const video = document.createElement("video");
+    video.srcObject = localStream;
+    await video.play();
+    const drawFrame = () => {
+      ctx.clearRect(0, 0, canvas.width, canvas.height);
+      ctx.save();
+      ctx.translate(canvas.width / 2, canvas.height / 2);
+      ctx.rotate(Math.PI / 2);
+      ctx.drawImage(video, -width / 2, -height / 2, width, height);
+      ctx.restore();
+      requestAnimationFrame(drawFrame);
+    };
+    drawFrame();
+    return canvas.captureStream();
+  }
+  async setVideoParams(sender) {
+    const params = sender.getParameters();
+    params.degradationPreference = "maintain-resolution";
+    params.encodings.forEach((encoding) => {
+      encoding.maxBitrate = 1e6;
+      encoding.priority = "high";
+      encoding.scaleResolutionDownBy = 1;
+    });
+    await sender.setParameters(params);
+  }
+  stopPush() {
+    var _a;
+    if (!this.isPushingStream) return;
+    this.isPushingStream = false;
+    (_a = this.localStream) == null ? void 0 : _a.getTracks().forEach((track) => {
+      var _a2;
+      (_a2 = this.peerConnection) == null ? void 0 : _a2.getSenders().forEach((sender) => {
+        var _a3;
+        (_a3 = this.peerConnection) == null ? void 0 : _a3.removeTrack(sender);
+      });
+      track.stop();
+    });
+    this.localStream = null;
+    createOffer(this.peerConnection, (sdp2) => {
+      this.emit(EmitType.sendOffer, sdp2);
+    }, (err) => this.emit(EmitType.webrtcError, err));
+  }
+  resetPeerConnection() {
+    if (!this.peerConnection) {
+      this.peerConnection = createPeerConnection(this.config);
+      configPeerConnection(this.peerConnection, (candidate) => {
+        this.emit(EmitType.sendICEMessage, candidate);
+      }, (track) => {
+        console.error("send track====>", track, Date.now());
+        this.emit(EmitType.streamTrack, track);
+      }, (state) => {
+        this.emit(EmitType.iceConnectionState, state);
+      }, (err) => this.emit(EmitType.webrtcError, err));
+      this.checkStats();
+      this.configDataChannel();
+    }
+  }
+  configDataChannel() {
+    this.peerConnection.ondatachannel = (event) => {
+      this.dataChannel = event.channel;
+      this.dataChannel.onmessage = (event2) => this.handleDataChannelMessage(event2);
+      this.dataChannel.onerror = (error) => this.emit(EmitType.webrtcError, createWebRtcError(FailCode.DATACHANNEL_ERR, error));
+      this.sendChannelData(ChannelDataType.ActionRequestCloudDeviceInfo, "");
+    };
+  }
+  handleDataChannelMessage(event) {
+    const data = JSON.parse(event.data);
+    if (data.type === "ActionCommandEvent") {
+      const { action, value } = JSON.parse(data.data);
+      if (action === "ACTION_CONTROL_VIDEO") {
+        value === "ENABLE" ? this.startPush() : this.stopPush();
+      }
+    } else if (data.type === "ActionUpdateCloudStatus") {
+      const { rotation, screenWidth, screenHeight } = JSON.parse(data.data);
+      const direction = [StreamRotation.ROTATION_0, StreamRotation.ROTATION_180].includes(rotation) ? ContainerDirection.Vertical : ContainerDirection.Horizontal;
+      const cloudStatus = {
+        direction,
+        screenWidth,
+        screenHeight
+      };
+      this.emit(EmitType.cloudStatusChanged, cloudStatus);
+    }
+  }
+  checkStats() {
+    this.statsTimer = setInterval(() => this.processStats(), 1e3);
+  }
+  processStats() {
+    if (!this.peerConnection) {
+      return;
+    }
+    this.peerConnection.getStats(null).then((statsReport) => {
+      let videoFps = 0;
+      let totalDecodeTime = 0;
+      let roundTripTime = 0;
+      let packetsLost = 0;
+      let packetsReceived = 0;
+      let bytesReceived = 0;
+      let framesDecoded = 0;
+      let pliCount = 0;
+      let connectionType = "";
+      const currentTime = Date.now();
+      statsReport.forEach((report) => {
+        if (report.type === "inbound-rtp") {
+          bytesReceived += report.bytesReceived || 0;
+          packetsLost += report.packetsLost || 0;
+          packetsReceived += report.packetsReceived || 0;
+          if (report.kind === "video") {
+            videoFps = report.framesPerSecond || 0;
+            totalDecodeTime = report.totalDecodeTime || 0;
+            framesDecoded = report.framesDecoded || 0;
+            report.framesReceived || 0;
+            pliCount = (report.pliCount || 0) + (report.firCount || 0);
+          }
+        }
+        if (report.type === "candidate-pair" && report.state === "succeeded") {
+          roundTripTime = typeof report.currentRoundTripTime !== "undefined" ? report.currentRoundTripTime : report.responsesReceived > 0 ? report.totalRoundTripTime / report.responsesReceived : 0;
+          const local = statsReport.get(report.localCandidateId);
+          const remote = statsReport.get(report.remoteCandidateId);
+          if (local && remote) {
+            connectionType = this.getConnectionType(local, remote);
+          }
+        }
+      });
+      roundTripTime = Math.floor((roundTripTime || 0) * 1e3);
+      const deltaTime = currentTime - this.lastReportTime;
+      const bytesDiff = bytesReceived - this.lastBytesReceived;
+      const bytesPerSecond = deltaTime > 0 ? bytesDiff * 1e3 / deltaTime : 0;
+      const kilobytesPerSecond = bytesPerSecond / 1024;
+      const megabytesPerSecond = kilobytesPerSecond / 1024;
+      this.lastBytesReceived = bytesReceived;
+      this.lastReportTime = currentTime;
+      let lossRate = 0;
+      const lostPackets = packetsLost - this.lastPacketsLost;
+      const receivedPackets = packetsReceived - this.lastPacketsReceived;
+      if (lostPackets > 0 && receivedPackets > 0) {
+        lossRate = lostPackets / (lostPackets + receivedPackets);
+        this.maxLostRate = Math.max(this.maxLostRate || 0, lossRate);
+        this.lostPacketCount++;
+      }
+      this.lastPacketsLost = packetsLost;
+      this.lastPacketsReceived = packetsReceived;
+      const fps = typeof videoFps !== "undefined" ? videoFps : framesDecoded - this.lastSecondDecodedCount;
+      this.lastSecondDecodedCount = framesDecoded;
+      const bitrate = kilobytesPerSecond < 1024 ? `${Math.floor(kilobytesPerSecond)} KB/s` : `${Math.floor(megabytesPerSecond)} MB/s`;
+      const averageDecodeTime = framesDecoded > 0 ? Math.floor(1e4 * totalDecodeTime / framesDecoded) : 0;
+      const screenInfo = {
+        connectionType,
+        framesPerSecond: fps,
+        currentRoundTripTime: roundTripTime,
+        lostRate: Math.floor(lossRate * 100),
+        // percent
+        bitrate,
+        pliCount,
+        averageDecodeTime
+      };
+      this.emit(EmitType.statisticInfo, screenInfo);
+    }).catch((error) => {
+      this.emit(EmitType.webrtcError, createWebRtcError(FailCode.STREAM_STATE, error));
+    });
+  }
+  getConnectionType(local, remote) {
+    if (local.candidateType === "host" && remote.candidateType === "host") return "直连";
+    if (local.candidateType === "relay" || remote.candidateType === "relay") return "中继";
+    return "NAT";
+  }
+}
+class WebRTCSdk extends EventEmitter {
+  constructor(options) {
+    super();
+    __publicField(this, "config");
+    __publicField(this, "signalingClient");
+    __publicField(this, "webRTCClient");
+    /**
+     * 处理 signal 消息，根据不同消息类型分发到 webRTCClient 或直接触发 SDK 事件
+     * @param message 信令消息
+     */
+    __publicField(this, "handleSignaling", (message) => {
+      switch (message.type) {
+        case MessageType.Peers:
+          this.config.myId = message.myId;
+          break;
+        case MessageType.Offer:
+          if (message.senderId && message.sdp) {
+            this.config.targetId = message.senderId;
+            this.webRTCClient.handleOffer(message.sdp);
+          }
+          break;
+        case MessageType.Answer:
+          if (message.sdp) {
+            this.webRTCClient.handleAnswer(message.sdp);
+          }
+          break;
+        case MessageType.IceCandidates:
+          if (message.ice) {
+            try {
+              const candidateObj = JSON.parse(message.ice);
+              candidateObj.candidate = candidateObj.sdp;
+              this.webRTCClient.handleIceCandidate(new RTCIceCandidate(candidateObj));
+            } catch (error) {
+              this.emit("error", { type: "iceCandidate", error });
+            }
+          }
+          break;
+        case MessageType.SignOut:
+          if (message.myId === this.config.myId) {
+            this.webRTCClient.closeConnection();
+            this.signalingClient.close();
+            this.removeAllListeners();
+          }
+          break;
+        case MessageType.NotAvailable:
+          this.emit(EmitType.webrtcError, createWebRtcError(FailCode.NOT_AVAILABLE, ""));
+          break;
+        case MessageType.Ping:
+          this.sendPong();
+          break;
+      }
+    });
+    /** 发送 Offer 信令 */
+    __publicField(this, "sendOffer", (offerSdp) => {
+      if (offerSdp && offerSdp.length > 0) {
+        const message = {
+          type: SendType.Offer,
+          identity: SendType.Identity,
+          roomId: this.config.roomId,
+          senderId: this.config.myId,
+          targetId: this.config.targetId,
+          sdp: offerSdp
+        };
+        this.signalingClient.sendMessage(JSON.stringify(message));
+      }
+    });
+    /** 发送 Answer 信令 */
+    __publicField(this, "sendAnswer", (answerSdp) => {
+      if (answerSdp && answerSdp.length > 0) {
+        const message = {
+          type: SendType.Answer,
+          identity: SendType.Identity,
+          roomId: this.config.roomId,
+          senderId: this.config.myId,
+          targetId: this.config.targetId,
+          sdp: answerSdp
+        };
+        this.signalingClient.sendMessage(JSON.stringify(message));
+      }
+    });
+    /** 发送 ICE 候选信息 */
+    __publicField(this, "sendICEMessage", (ice) => {
+      if (ice && ice.length > 0) {
+        const message = {
+          type: SendType.IceCandidates,
+          identity: SendType.Identity,
+          roomId: this.config.roomId,
+          senderId: this.config.myId,
+          targetId: this.config.targetId,
+          ice
+        };
+        this.signalingClient.sendMessage(JSON.stringify(message));
+      }
+    });
+    this.config = new WebRTCConfig(options);
+    this.signalingClient = new SignalingClient(this.config);
+    this.webRTCClient = new WebRTCClient(this.config);
+    this.signalingClient.on(EmitType.signalMessage, (message) => this.handleSignaling(message));
+    this.signalingClient.on(EmitType.webrtcError, (err) => {
+      this.emit(EmitType.webrtcError, err);
+    });
+    this.webRTCClient.on(EmitType.sendOffer, (sdp2) => this.sendOffer(sdp2));
+    this.webRTCClient.on(EmitType.sendAnswer, (sdp2) => this.sendAnswer(sdp2));
+    this.webRTCClient.on(EmitType.sendICEMessage, (candidate) => this.sendICEMessage(candidate));
+    this.webRTCClient.on(EmitType.streamTrack, (track) => this.emit(EmitType.streamTrack, track));
+    this.webRTCClient.on(
+      EmitType.iceConnectionState,
+      (state) => this.emit(EmitType.iceConnectionState, state)
+    );
+    this.webRTCClient.on(
+      EmitType.cloudStatusChanged,
+      (info) => this.emit(EmitType.cloudStatusChanged, info)
+    );
+    this.webRTCClient.on(EmitType.webrtcError, (err) => {
+      this.emit(EmitType.webrtcError, err);
+    });
+    this.webRTCClient.on(EmitType.statisticInfo, (info) => {
+      this.emit(EmitType.statisticInfo, info);
+    });
+  }
+  /** 开始连接 signal 服务 */
+  startConnection() {
+    this.signalingClient.start();
+  }
+  /** 停止连接，并发送退出信令 */
+  stop() {
+    this.webRTCClient.closeConnection();
+    this.sendSignOut();
+    this.removeAllListeners();
+  }
+  /** 开始推流：触发媒体采集与轨道添加 */
+  async startPush() {
+    try {
+      await this.webRTCClient.readyCapture();
+    } catch (error) {
+      this.emit("error", { type: "camera", error });
+    }
+  }
+  /** 发送信道数据 */
+  sendChannelData(type, data) {
+    this.webRTCClient.sendChannelData(type, data);
+  }
+  sendPong() {
+    const message = {
+      type: SendType.Pong
+    };
+    const jsonMessage = JSON.stringify(message);
+    this.signalingClient.sendMessage(jsonMessage);
+  }
+  sendSignOut() {
+    const message = {
+      type: SendType.SignOut,
+      identity: SendType.Identity,
+      roomId: this.config.roomId,
+      myId: this.config.myId
+    };
+    this.signalingClient.sendMessage(JSON.stringify(message));
+  }
+}
+const META_SHIFT_ON = 1;
+const META_ALT_ON = 2;
+const META_CTRL_ON = 4096;
+const META_META_ON = 65536;
+const computeAndroidMetaState = (event) => {
+  let state = 0;
+  if (event.shiftKey) state |= META_SHIFT_ON;
+  if (event.altKey) state |= META_ALT_ON;
+  if (event.ctrlKey) state |= META_CTRL_ON;
+  if (event.metaKey) state |= META_META_ON;
+  return state;
+};
+const KeyCodeMap = {
+  // 数字键
+  "Digit1": 8,
+  "Digit2": 9,
+  "Digit3": 10,
+  "Digit4": 11,
+  "Digit5": 12,
+  "Digit6": 13,
+  "Digit7": 14,
+  "Digit8": 15,
+  "Digit9": 16,
+  "Digit0": 7,
+  // 符号键（主键盘区）
+  "Minus": 69,
+  "Equal": 70,
+  "Backquote": 68,
+  "BracketLeft": 71,
+  "BracketRight": 72,
+  "Backslash": 73,
+  "Semicolon": 74,
+  "Quote": 75,
+  "Comma": 55,
+  "Period": 56,
+  "Slash": 76,
+  // 功能键
+  "Escape": 111,
+  "Backspace": 67,
+  "Tab": 61,
+  "Enter": 66,
+  "Space": 62,
+  "CapsLock": 115,
+  // 修饰键
+  "ShiftLeft": 59,
+  "ShiftRight": 60,
+  "ControlLeft": 113,
+  "ControlRight": 114,
+  "AltLeft": 57,
+  "AltRight": 58,
+  "MetaLeft": 117,
+  "MetaRight": 118,
+  // 方向键
+  "ArrowUp": 19,
+  "ArrowDown": 20,
+  "ArrowLeft": 21,
+  "ArrowRight": 22,
+  // 字母键（物理位置映射）
+  "KeyA": 29,
+  "KeyB": 30,
+  "KeyC": 31,
+  "KeyD": 32,
+  "KeyE": 33,
+  "KeyF": 34,
+  "KeyG": 35,
+  "KeyH": 36,
+  "KeyI": 37,
+  "KeyJ": 38,
+  "KeyK": 39,
+  "KeyL": 40,
+  "KeyM": 41,
+  "KeyN": 42,
+  "KeyO": 43,
+  "KeyP": 44,
+  "KeyQ": 45,
+  "KeyR": 46,
+  "KeyS": 47,
+  "KeyT": 48,
+  "KeyU": 49,
+  "KeyV": 50,
+  "KeyW": 51,
+  "KeyX": 52,
+  "KeyY": 53,
+  "KeyZ": 54,
+  // 功能键扩展
+  "F1": 131,
+  "F2": 132,
+  "F3": 133,
+  "F4": 134,
+  "F5": 135,
+  "F6": 136,
+  "F7": 137,
+  "F8": 138,
+  "F9": 139,
+  "F10": 140,
+  "F11": 141,
+  "F12": 142,
+  // 数字小键盘
+  "Numpad0": 7,
+  "Numpad1": 8,
+  "Numpad2": 9,
+  "Numpad3": 10,
+  "Numpad4": 11,
+  "Numpad5": 12,
+  "Numpad6": 13,
+  "Numpad7": 14,
+  "Numpad8": 15,
+  "Numpad9": 16,
+  "NumpadAdd": 157,
+  "NumpadSubtract": 156,
+  "NumpadMultiply": 155,
+  "NumpadDivide": 154,
+  "NumpadDecimal": 158,
+  "NumpadEnter": 66,
+  // 其他特殊键
+  "Insert": 124,
+  "Delete": 112,
+  "Home": 122,
+  "End": 123,
+  "PageUp": 92,
+  "PageDown": 93,
+  "ScrollLock": 116,
+  "Pause": 121,
+  "ContextMenu": 117
+};
+const getKeyEventData = (event) => {
+  const keyCode = KeyCodeMap[event.code] ?? -1;
+  const metaState = computeAndroidMetaState(event);
+  return {
+    androidKeyCode: keyCode,
+    metaState
+  };
+};
+function transformCoordinate(viewWidth, viewHeight, cloudWidth, cloudHeight, viewAngle, streamAngle, inputX, inputY) {
+  let realShortWidth;
+  let short;
+  if (viewAngle === -90) {
+    short = viewHeight;
+    realShortWidth = cloudWidth * viewWidth / cloudHeight;
+  } else {
+    short = viewWidth;
+    realShortWidth = cloudWidth * viewHeight / cloudHeight;
+  }
+  const invalidValue = (short - realShortWidth) / 2;
+  const mid = short / 2;
+  const start = invalidValue;
+  const end = short - invalidValue;
+  const len = mid - invalidValue;
+  if (viewAngle === -90) {
+    if (inputY < invalidValue || inputY > viewHeight - invalidValue) {
+      return null;
+    }
+    const resultY = linearTransform(invalidValue, mid, start, end, len, inputY);
+    if (streamAngle === -90) {
+      return [inputX, resultY];
+    } else {
+      return [viewHeight - resultY, inputX];
+    }
+  } else {
+    if (inputX < invalidValue || inputX > viewWidth - invalidValue) {
+      return null;
+    }
+    const resultX = linearTransform(invalidValue, mid, start, end, len, inputX);
+    if (streamAngle === -90) {
+      const [rotX, rotY] = rotatePoint90(viewWidth, viewHeight, cloudWidth, cloudHeight, resultX, inputY);
+      return [rotX, rotY];
+    } else {
+      return [resultX, inputY];
+    }
+  }
+}
+function valueToPercentage(viewWidth, viewHeight, cloudWidth, cloudHeight, viewAngle, streamAngle, inputX, inputY) {
+  let xRatio;
+  let yRatio;
+  if (viewAngle === 0 && streamAngle === 0) {
+    xRatio = inputX / viewWidth;
+    yRatio = inputY / viewHeight;
+  } else if (viewAngle === -90 && streamAngle === 0) {
+    xRatio = inputX / viewHeight;
+    yRatio = inputY / viewWidth;
+  } else if (viewAngle === -90 && streamAngle === -90) {
+    xRatio = inputX / viewWidth * (cloudHeight / cloudWidth);
+    yRatio = inputY / viewHeight * (cloudWidth / cloudHeight);
+  } else {
+    xRatio = inputX / viewHeight * (cloudHeight / cloudWidth);
+    yRatio = inputY / viewWidth * (cloudWidth / cloudHeight);
+  }
+  return [xRatio, yRatio];
+}
+function linearTransform(invalidValue, mid, start, end, len, input) {
+  if (input >= start && input <= mid - 0.1) {
+    return (input - invalidValue) * mid / len;
+  } else if (input === mid) {
+    return mid;
+  } else if (input >= mid + 0.1 && input <= end) {
+    return mid + (input - mid) * mid / len;
+  } else {
+    return input;
+  }
+}
+function rotatePoint90(width, height, cloudWidth, cloudHeight, inputX, inputY) {
+  const offsetLongSide = height / 2;
+  const offsetShortSide = width / 2;
+  const x0 = inputX - offsetShortSide;
+  const y0 = inputY - offsetLongSide;
+  const xRotated = y0 + offsetLongSide;
+  const yRotated = -x0 + offsetShortSide;
+  return [xRotated, yRotated];
+}
+export {
+  ActionType,
+  ChannelDataType,
+  ContainerDirection,
+  EmitType,
+  InputData,
+  KeyEventData,
+  TouchData,
+  WebRTCSdk,
+  getKeyEventData,
+  transformCoordinate,
+  valueToPercentage
+};