@realsee/live 0.4.0-alpha.3 → 0.4.0-alpha.4

package/dist/realsee-live.umd.development.js

@@ -4,16 +4,16 @@
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.RealseeLive = {}));
 })(this, (function (exports) { 'use strict';
 
-  const EVENT_SYMBOL = Symbol('$$REALSEE_LIVE_EVENT$$');
-  function __generateEventIfNotExisted(instance) {
-      if (!instance[EVENT_SYMBOL]) {
-          instance[EVENT_SYMBOL] = {};
+  const EVENT_SYMBOL$1 = Symbol('$$REALSEE_LIVE_EVENT$$');
+  function __generateEventIfNotExisted$1(instance) {
+      if (!instance[EVENT_SYMBOL$1]) {
+          instance[EVENT_SYMBOL$1] = {};
       }
-      return instance[EVENT_SYMBOL];
+      return instance[EVENT_SYMBOL$1];
   }
-  function __removeEventIfNotExisted(instance) {
-      if (!instance[EVENT_SYMBOL]) {
-          delete instance[EVENT_SYMBOL];
+  function __removeEventIfNotExisted$1(instance) {
+      if (!instance[EVENT_SYMBOL$1]) {
+          delete instance[EVENT_SYMBOL$1];
       }
   }
   /**
@@ -27,13 +27,13 @@
    * }>()
    * ```
    */
-  class Subscribe {
+  class Subscribe$1 {
       /**
        * 判断是否注册了事件
        * @param name  事件类型
        */
       hasListener(name) {
-          const events = __generateEventIfNotExisted(this);
+          const events = __generateEventIfNotExisted$1(this);
           return events && events[name] && events[name].length > 0;
       }
       /**
@@ -46,7 +46,7 @@
        * @template C 回调函数函数上下文
        */
       on(name, callback, once) {
-          const events = __generateEventIfNotExisted(this);
+          const events = __generateEventIfNotExisted$1(this);
           if (!events[name])
               events[name] = [];
           events[name].push([callback, once || false]);
@@ -74,10 +74,10 @@
        */
       off(name, callback) {
           if (name === undefined) {
-              __removeEventIfNotExisted(this);
+              __removeEventIfNotExisted$1(this);
               return;
           }
-          const events = __generateEventIfNotExisted(this);
+          const events = __generateEventIfNotExisted$1(this);
           if (!events[name])
               events[name] = [];
           if (callback === undefined) {
@@ -102,7 +102,7 @@
        */
       emit(name, ...data) {
           let canceled = false;
-          const events = __generateEventIfNotExisted(this);
+          const events = __generateEventIfNotExisted$1(this);
           const event = events[name] || [];
           for (let one of event.slice()) {
               const [callback, once = false] = one;
@@ -119,7 +119,7 @@
   /**
    * rtc 基础抽象类
    */
-  class CoreRTC extends Subscribe {
+  class CoreRTC extends Subscribe$1 {
   }
 
   var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
@@ -158,29 +158,34 @@
       RTCType["RealseeBrowserRTC"] = "RealseeBrowserRTC";
       RTCType["RealseeVRWebViewRTC"] = "RealseeVRWebViewRTC";
       RTCType["RealseeBrowserChimeRTC"] = "RealseeBrowserChimeRTC";
-  })(exports.RTCType || (exports.RTCType = {}));
+  })(exports.RTCType || (exports.RTCType = {}));
+  exports.BuiltInRTCType = void 0;
+  (function (BuiltInRTCType) {
+      BuiltInRTCType["RealseeXTRTC"] = "trtc";
+      BuiltInRTCType["RealseeXChimeRTC"] = "chime";
+  })(exports.BuiltInRTCType || (exports.BuiltInRTCType = {}));
 
   // uuid
-  function S4() {
+  function S4$1() {
       return (((1 + Math.random()) * 0x10000) | 0).toString(16).substring(1);
   }
   /**
    * 基于伪随机数生成 **uuid**。
    */
-  function uuid() {
+  function uuid$1() {
       // then to call it, plus stitch in '4' in the third group
-      return (S4() +
-          S4() +
+      return (S4$1() +
+          S4$1() +
           '-' +
-          S4() +
+          S4$1() +
           '-4' +
-          S4().substr(0, 3) +
+          S4$1().substr(0, 3) +
           '-' +
-          S4() +
+          S4$1() +
           '-' +
-          S4() +
-          S4() +
-          S4()).toLowerCase();
+          S4$1() +
+          S4$1() +
+          S4$1()).toLowerCase();
   }
 
   class BrowserRTC extends CoreRTC {
@@ -265,7 +270,7 @@
           this._initParentDom();
       }
       _initParentDom() {
-          this.$dom.id = `rs-rtc-${uuid()}`;
+          this.$dom.id = `rs-rtc-${uuid$1()}`;
           this.$dom.style.display = 'none';
           document.body.appendChild(this.$dom);
       }
@@ -48210,8 +48215,8 @@
            * 对audio标签初始化
            */
           this._initDom = () => {
-              this.$audio.id = `rs-rtc-${uuid()}`;
-              this.$dom.id = `rs-rtc-${uuid()}`;
+              this.$audio.id = `rs-rtc-${uuid$1()}`;
+              this.$dom.id = `rs-rtc-${uuid$1()}`;
               this.$dom.appendChild(this.$audio);
               document.body.appendChild(this.$dom);
           };
@@ -48774,12 +48779,1741 @@
       return exports.WebSocketCloseError.Err_unknown;
   }
 
+  const cache = {};
+  /**
+   * 创建一个唯一的函数名（在当前页面会话中保障其唯一性即可）。
+   * @param extra 可以额外自定义部分字符串。
+   * @returns
+   */
+  function registerGlobalValue(scheme, callback, once = true) {
+      if (!cache[scheme]) {
+          const uuid = '$jsBridgeFn_' + Date.now().toString(16).toUpperCase() + '_' + Math.ceil(Math.random() * 10000).toString(16).toUpperCase();
+          cache[scheme] = {
+              uuid,
+              queue: [{ once, callback }],
+          };
+      }
+      else {
+          cache[scheme].queue.push({ once, callback });
+      }
+      Object.assign(window, {
+          [cache[scheme].uuid]: (data) => {
+              cache[scheme].queue = cache[scheme].queue.reduce((accu, curr) => {
+                  const { once, callback } = curr;
+                  if (!once) {
+                      accu.push(curr);
+                  }
+                  callback(data);
+                  return accu;
+              }, []);
+          }
+      });
+      return cache[scheme].uuid;
+  }
+
+  class BaseController {
+      checkReady(timeout) {
+          return Promise.resolve([false, null]);
+      }
+      callAndBackfeed(scheme) {
+          return Promise.resolve([false, null]);
+      }
+      callAndListen(scheme, callback) {
+          return Promise.resolve([false, null]);
+      }
+  }
+
+  const HYBRID_BRIDGE_NAME = 'HybridBridgeLJ';
+  const $window$1 = window;
+  /**
+   * Android WebView 控件。
+   */
+  class WebViewController extends BaseController {
+      constructor() {
+          super();
+          Promise.resolve().then(async () => {
+              try {
+                  await this.checkBridgeReady();
+              }
+              catch (error) {
+                  console.warn(error);
+              }
+          });
+      }
+      /**
+       * 检查 HybridBridgeLJ 是否ready
+       * @param timeout 超时时间
+       * @returns
+       */
+      checkBridgeReady(timeout = 6000) {
+          if (this.hybridBridge)
+              return true;
+          const start = performance.now();
+          return new Promise((resolve, reject) => {
+              const check = () => {
+                  if (this.hybridBridge)
+                      return resolve(true);
+                  if ($window$1.HybridBridgeLJ) {
+                      const hybridBridge = $window$1[HYBRID_BRIDGE_NAME];
+                      hybridBridge === null || hybridBridge === void 0 ? void 0 : hybridBridge.getStaticData(registerGlobalValue('HYBRID_BRIDGE_NAME', (data) => {
+                          this.deviceInfo = JSON.parse(data);
+                          this.hybridBridge = hybridBridge;
+                          return resolve(true);
+                      }));
+                  }
+                  if (performance.now() - start > (timeout || 6000)) {
+                      // console.warn('HybridBridge 初始化超时~')
+                      return reject(new Error('HybridBridge 初始化超时~'));
+                  }
+                  // 逐帧监测
+                  requestAnimationFrame(check);
+              };
+              // 开启监测
+              check();
+          });
+      }
+      async checkReady(timeout = 6000) {
+          const res = [null, null];
+          if (this.hybridBridge) {
+              res[0] = true;
+              return res;
+          }
+          try {
+              res[0] = await this.checkBridgeReady(timeout);
+          }
+          catch (error) {
+              res[0] = false;
+              res[1] = error;
+          }
+          return res;
+      }
+      get ready() {
+          return !!this.hybridBridge;
+      }
+      get scheme() {
+          var _a;
+          return ((_a = this.deviceInfo) === null || _a === void 0 ? void 0 : _a.scheme) || '';
+      }
+      createSchemeLink(schemeUrl) {
+          if (schemeUrl.startsWith(this.scheme)) {
+              return schemeUrl;
+          }
+          return this.scheme + '://' + schemeUrl;
+      }
+      async callAndBackfeed(scheme) {
+          const res = [false, null];
+          const [ready, readyError] = await this.checkReady();
+          if (!ready) {
+              res[0] = false;
+              res[1] = readyError;
+              return res;
+          }
+          return await new Promise(async (resolve) => {
+              const actionUrl = this.createSchemeLink(scheme);
+              const msg = JSON.stringify({
+                  actionUrl,
+                  functionName: registerGlobalValue(this.createSchemeLink(scheme), (data) => {
+                      const d = JSON.parse(data);
+                      res[0] = (() => {
+                          if (d === 1)
+                              return true;
+                          if (d === 0)
+                              return false;
+                          return d;
+                      })();
+                      resolve(res);
+                  }),
+              });
+              this.hybridBridge.callAndBackfeed(msg);
+          });
+      }
+      async callAndListen(scheme, callback) {
+          const res = [false, null];
+          const [ready, readyError] = await this.checkReady();
+          if (!ready) {
+              res[0] = false;
+              res[1] = readyError;
+              return res;
+          }
+          return await new Promise(async (resolve) => {
+              const actionUrl = this.createSchemeLink(scheme);
+              const _callback = (data) => {
+                  const d = JSON.parse(data);
+                  const callbackParam = (() => {
+                      if (d === 1)
+                          return true;
+                      if (d === 0)
+                          return false;
+                      return d;
+                  })();
+                  callback(callbackParam);
+                  res[0] = () => {
+                      // 清理掉当前的回调引用
+                      const callbacks = cache[actionUrl];
+                      if (!callbacks)
+                          return;
+                      const idx = callbacks.queue.findIndex((func) => func.callback === _callback);
+                      if (idx !== -1) {
+                          callbacks.queue.splice(idx, 1);
+                      }
+                  };
+                  resolve(res);
+              };
+              const msg = JSON.stringify({
+                  actionUrl,
+                  functionName: registerGlobalValue(actionUrl, _callback, false),
+              });
+              this.hybridBridge.callAndListen(msg);
+          });
+      }
+  }
+
+  var CallTypeEnum;
+  (function (CallTypeEnum) {
+      CallTypeEnum["callAndBackfeed"] = "callAndBack";
+      CallTypeEnum["callAndListen"] = "callAndListen";
+  })(CallTypeEnum || (CallTypeEnum = {}));
+  const $window = window;
+  /**
+   *
+   * 将原本 JSBridgeApp 中的逻辑均聚合至此 Controller 实现，
+   * 目的是规避太多的引用对象被暴露（防止因引用对象被'篡改'造成未知异常）。
+   *
+   */
+  class WKWebViewController {
+      constructor() {
+          this.checkBridgeReady();
+      }
+      checkBridgeReady(timeout = 6000) {
+          if (this.worker)
+              return true;
+          const start = performance.now();
+          return new Promise((resolve, reject) => {
+              const check = () => {
+                  if (this.worker)
+                      return resolve(true);
+                  if ($window.webkit && $window.webkit.messageHandlers && $window.webkit.messageHandlers.realsee) {
+                      const worker = $window.webkit.messageHandlers.realsee;
+                      worker.postMessage(JSON.stringify({
+                          type: 'getStaticData',
+                          param: JSON.stringify({
+                              functionName: registerGlobalValue('HYBRID_BRIDGE_NAME', (data) => {
+                                  this.deviceInfo = JSON.parse(data);
+                                  this.worker = worker;
+                                  return resolve(true);
+                              })
+                          })
+                      }));
+                      return;
+                  }
+                  if (performance.now() - start > (timeout || 6000)) {
+                      // console.warn('HybridBridge 初始化超时~')
+                      return reject(new Error('HybridBridge 初始化超时~'));
+                  }
+                  // 逐帧监测
+                  requestAnimationFrame(check);
+              };
+              // 开启监测
+              check();
+          });
+      }
+      async checkReady(timeout = 6000) {
+          const res = [null, null];
+          if (this.worker) {
+              res[0] = true;
+              return res;
+          }
+          try {
+              res[0] = await this.checkBridgeReady(timeout);
+          }
+          catch (error) {
+              res[0] = false;
+              res[1] = error;
+          }
+          return res;
+      }
+      get ready() {
+          return !!this.worker;
+      }
+      get scheme() {
+          var _a;
+          return ((_a = this.deviceInfo) === null || _a === void 0 ? void 0 : _a.scheme) || '';
+      }
+      createSchemeLink(schemeUrl) {
+          if (schemeUrl.startsWith(this.scheme)) {
+              return schemeUrl;
+          }
+          return this.scheme + '://' + schemeUrl;
+      }
+      async callAndBackfeed(scheme) {
+          const res = [false, null];
+          const [ready, readyError] = await this.checkReady();
+          if (!ready) {
+              res[0] = false;
+              res[1] = readyError;
+              return res;
+          }
+          return await new Promise(async (resolve) => {
+              const actionUrl = this.createSchemeLink(scheme);
+              const msg = JSON.stringify({
+                  actionUrl,
+                  functionName: registerGlobalValue(this.createSchemeLink(scheme), (data) => {
+                      const d = JSON.parse(data);
+                      res[0] = (() => {
+                          if (d === 1)
+                              return true;
+                          if (d === 0)
+                              return false;
+                          return d;
+                      })();
+                      resolve(res);
+                  })
+              });
+              this.worker.postMessage(JSON.stringify({
+                  type: 'callAndBackfeed',
+                  param: msg
+              }));
+          });
+      }
+      async callAndListen(scheme, callback) {
+          const res = [false, null];
+          const [ready, readyError] = await this.checkReady();
+          if (!ready) {
+              res[0] = false;
+              res[1] = readyError;
+              return res;
+          }
+          return await new Promise(async (resolve) => {
+              const actionUrl = this.createSchemeLink(scheme);
+              const _callback = (data) => {
+                  const d = JSON.parse(data);
+                  const callbackParam = (() => {
+                      if (d === 1)
+                          return true;
+                      if (d === 0)
+                          return false;
+                      return d;
+                  })();
+                  callback(callbackParam);
+                  res[0] = () => {
+                      // 清理掉当前的回调引用
+                      const callbacks = cache[actionUrl];
+                      if (!callbacks)
+                          return;
+                      const idx = callbacks.queue.findIndex((func) => func.callback === _callback);
+                      if (idx !== -1) {
+                          callbacks.queue.splice(idx, 1);
+                      }
+                  };
+                  resolve(res);
+              };
+              const msg = JSON.stringify({
+                  actionUrl,
+                  functionName: registerGlobalValue(actionUrl, _callback, false)
+              });
+              this.worker.postMessage(JSON.stringify({
+                  type: 'callAndListen',
+                  param: msg,
+              }));
+          });
+      }
+  }
+
+  // uuid
+  function S4() {
+      return (((1 + Math.random()) * 0x10000) | 0).toString(16).substring(1);
+  }
+  /**
+   * 随机生成一个uuid值
+   */
+  function uuid() {
+      // then to call it, plus stitch in '4' in the third group
+      return (S4() + S4() + '-' + S4() + '-4' + S4().substr(0, 3) +
+          '-' + S4() + '-' + S4() + S4() + S4()).toLowerCase();
+  }
+
+  /**
+   * 事件消息
+   */
+  var WeappBridgeMessage;
+  (function (WeappBridgeMessage) {
+      WeappBridgeMessage["isReady"] = "Are You OK?";
+      WeappBridgeMessage["ready"] = "I`m OK!";
+      WeappBridgeMessage["ping"] = "ping";
+      WeappBridgeMessage["pong"] = "pong";
+      WeappBridgeMessage["alive"] = "I`m alive!";
+  })(WeappBridgeMessage || (WeappBridgeMessage = {}));
+
+  /**
+   * ws的状态
+   * 参考https://developer.mozilla.org/en-US/docs/Web/API/WebSocket
+   */
+  var WebSocketState;
+  (function (WebSocketState) {
+      WebSocketState[WebSocketState["CONNECTING"] = 0] = "CONNECTING";
+      WebSocketState[WebSocketState["OPEN"] = 1] = "OPEN";
+      WebSocketState[WebSocketState["CLOSING"] = 2] = "CLOSING";
+      WebSocketState[WebSocketState["CLOSED"] = 3] = "CLOSED";
+  })(WebSocketState || (WebSocketState = {}));
+
+  /**
+   * ws 关闭的原因
+   */
+  const WebSocketCloseOptions = {
+      /**
+       * 重连关闭
+       */
+      reconnect: { code: 1000, reason: 'close websocket when reconnecting' },
+      /**
+       * 主动关闭
+       */
+      normalClosure: { code: 1000, reason: 'normal closure' },
+      /**
+       * 强制关闭
+       */
+      forceClosure: { code: 1000, reason: 'force closure' },
+      /**
+       * 切换到后台，被微信杀掉，需要重连连接
+       */
+      interrupted: { code: 1000, reason: 'interrupted' },
+      /**
+       * 服务端拒绝连接
+       */
+      streamEndEncountered: { code: 1000, reason: 'stream end encountered' },
+      /**
+       * 丢失心跳
+       * @deprecated
+       */
+      lostHeartbeat: { code: 1000, reason: 'lost heartbeat' },
+  };
+
+  const EVENT_SYMBOL = '$$REALSEE_JSBRIDGE_EVENT$$';
+  function __generateEventIfNotExisted(instance) {
+      if (!instance[EVENT_SYMBOL]) {
+          instance[EVENT_SYMBOL] = {};
+      }
+      return instance[EVENT_SYMBOL];
+  }
+  function __removeEventIfNotExisted(instance) {
+      if (!instance[EVENT_SYMBOL]) {
+          delete instance[EVENT_SYMBOL];
+      }
+  }
+  /**
+   * 监听者模式
+   * @template T 预设的监听回调类型
+   * @example
+   * ```
+   * new Subscribe<{
+   * "foo": [arg1: number, arg2: string],
+   * "bar": [arg: boolean],
+   * }>()
+   * ```
+   */
+  class Subscribe {
+      /**
+       * 判断是否注册了事件
+       * @param name  事件类型
+       */
+      hasListener(name) {
+          const events = __generateEventIfNotExisted(this);
+          return events && events[name] && events[name].length > 0;
+      }
+      /**
+       * 注册事件
+       * @param  name    事件类型
+       * @param  callback 事件回调函数
+       * @param  once     是否只执行一次
+       * @returns 解除事件
+       * @template K 预设的监听事件名称
+       * @template C 回调函数函数上下文
+       */
+      on(name, callback, once) {
+          const events = __generateEventIfNotExisted(this);
+          if (!events[name])
+              events[name] = [];
+          events[name].push([callback, once || false]);
+          return () => this.off(name, callback);
+      }
+      /**
+       * 注册事件(是否只执行一次)
+       * @param  name     事件类型
+       * @param  callback 事件回调函数
+       * @returns 解除事件
+       * @template K 预设的监听事件名称
+       * @template C 回调函数函数上下文
+       */
+      once(name, callback) {
+          return this.on(name, callback, true);
+      }
+      /**
+       * 解除事件
+       *
+       * 如果 name 不传的话解除对应所有事件
+       * 如果 name, callback 不传的话解除所有name的所有事件
+       * @param  name     事件类型
+       * @param  callback 事件回调函数
+       * @template K 预设的监听事件名称
+       */
+      off(name, callback) {
+          if (name === undefined) {
+              __removeEventIfNotExisted(this);
+              return;
+          }
+          const events = __generateEventIfNotExisted(this);
+          if (!events[name])
+              events[name] = [];
+          if (callback === undefined) {
+              events[name].length = 0;
+              return;
+          }
+          let index = 0;
+          for (; index < events[name].length; index++) {
+              if (events[name][index][0] === callback)
+                  break;
+          }
+          if (index < events[name].length) {
+              events[name].splice(index, 1);
+          }
+      }
+      /**
+       * 触发事件
+       * @param  name  事件类型
+       * @param  data  触发事件的数据
+       * @returns canceled 是否被触发取消
+       * @template K 预设的监听事件名称
+       */
+      emit(name, ...data) {
+          let canceled = false;
+          const events = __generateEventIfNotExisted(this);
+          const event = events[name] || [];
+          for (const one of event.slice()) {
+              const [callback, once = false] = one;
+              const result = callback(...data);
+              if (once)
+                  this.off(name, callback);
+              if (result === false)
+                  canceled = true;
+          }
+          return canceled;
+      }
+  }
+
+  /**
+   * ws的事件
+   */
+  var WebSocketEvent;
+  (function (WebSocketEvent) {
+      WebSocketEvent["open"] = "open";
+      WebSocketEvent["close"] = "close";
+      WebSocketEvent["error"] = "error";
+      WebSocketEvent["message"] = "message";
+  })(WebSocketEvent || (WebSocketEvent = {}));
+
+  class Ws4Webview extends Subscribe {
+      constructor() {
+          super(...arguments);
+          this._state = null;
+          /**
+           * @description 注册ws接通事件回调
+           * @param listener 事件回调函数
+           * @param once 是否只执行一次
+           * @returns
+           */
+          this.onOpen = (listener, once) => once ? this.once(WebSocketEvent.open, listener) : this.on(WebSocketEvent.open, listener);
+          /**
+           * @description 注册一次ws接通事件回调
+           * @param listener 事件回调函数
+           */
+          this.onceOpen = (listener) => this.onOpen(listener, true);
+          /**
+           * @description 移除ws接通事件回调
+           * @param listener 事件回调函数
+           * @returns
+           */
+          this.offOpen = (listener) => this.hasListener(WebSocketEvent.open) && this.off(WebSocketEvent.open, listener);
+          /**
+           * @description 注册ws消息事件回调
+           * @param listener 事件回调函数
+           * @param once 是否只执行一次
+           * @returns
+           */
+          this.onMessage = (listener, once) => once ? this.once(WebSocketEvent.message, listener) : this.on(WebSocketEvent.message, listener);
+          /**
+           * @description 注册一次ws消息事件回调
+           * @param listener 事件回调函数
+           */
+          this.onceMessage = (listener) => this.onMessage(listener, true);
+          /**
+           * @description 移除ws接通事件回调
+           * @param listener 事件回调函数
+           * @returns
+           */
+          this.offMessage = (listener) => this.hasListener(WebSocketEvent.message) && this.off(WebSocketEvent.message, listener);
+          /**
+           * @description 注册ws错误事件回调
+           * @param listener 事件回调函数
+           * @param once 是否只执行一次
+           * @returns
+           */
+          this.onError = (listener, once) => once ? this.once(WebSocketEvent.error, listener) : this.on(WebSocketEvent.error, listener);
+          /**
+           * @description 注册一次ws消息事件回调
+           * @param listener 事件回调函数
+           */
+          this.onceError = (listener) => this.onError(listener, true);
+          /**
+           * @description 移除ws接通事件回调
+           * @param listener 事件回调函数
+           * @returns
+           */
+          this.offError = (listener) => this.hasListener(WebSocketEvent.error) && this.off(WebSocketEvent.error, listener);
+          /**
+           * @description 注册ws错误事件回调
+           * @param listener 事件回调函数
+           * @param once 是否只执行一次
+           * @returns
+           */
+          this.onClose = (listener, once) => once ? this.once(WebSocketEvent.close, listener) : this.on(WebSocketEvent.close, listener);
+          /**
+           * @description 注册一次ws消息事件回调
+           * @param listener 事件回调函数
+           */
+          this.onceClose = (listener) => this.onClose(listener, true);
+          /**
+           * @description 移除ws接通事件回调
+           * @param listener 事件回调函数
+           * @returns
+           */
+          this.offClose = (listener) => this.hasListener(WebSocketEvent.close) && this.off(WebSocketEvent.close, listener);
+      }
+      get readyState() {
+          return this._state;
+      }
+      /**
+       * 连接ws
+       * @param options
+       */
+      connect(options) {
+          if (this._state === WebSocketState.CONNECTING || this._state === WebSocketState.OPEN)
+              return Promise.reject("\u5DF2\u5B58\u5728\u4E00\u4E2A\u8FDE\u63A5\u4E2D\u6216\u6253\u5F00\u72B6\u6001\u7684websocket\u5B9E\u4F8B" /* ErrorMessage.WsAlreadyExists */);
+          return new Promise((resolve, reject) => {
+              const { url } = options;
+              if (!url)
+                  throw new Error("\u975E\u6CD5\u7684websocket\u94FE\u63A5" /* ErrorMessage.WsUrlInvalid */);
+              this._wsOptions = options;
+              this._state = WebSocketState.CONNECTING;
+              this._wsTask = new WebSocket(url);
+              this.registerEventHandler();
+              this.handleConnected();
+              this.onceOpen(() => resolve(true));
+              this.onceError((err) => reject(err));
+          });
+      }
+      /**
+       * 重连websocket
+       * @returns
+       */
+      async reconnect() {
+          this.close(WebSocketCloseOptions.reconnect);
+          if (this._wsOptions)
+              this.connect(this._wsOptions);
+      }
+      /**
+       * @description 发送消息
+       * @param data 消息体
+       */
+      send(data) {
+          try {
+              if (this._wsTask && this.readyState === WebSocketState.OPEN) {
+                  this._wsTask.send(data);
+              }
+              else if (this._wsTask && this.readyState === WebSocketState.CONNECTING) {
+                  this.once(WebSocketEvent.open, () => { var _a; return (_a = this._wsTask) === null || _a === void 0 ? void 0 : _a.send(data); });
+              }
+              else {
+                  this.once(WebSocketEvent.open, () => this.send(data));
+                  this.reconnect();
+              }
+          }
+          catch (e) {
+              this.once(WebSocketEvent.open, () => this.send(data));
+              this.reconnect();
+          }
+      }
+      /**
+       * @description 手动关闭ws
+       * @param options 关闭ws的配置参数
+       */
+      close(options) {
+          var _a;
+          this._state = WebSocketState.CLOSING;
+          (_a = this._wsTask) === null || _a === void 0 ? void 0 : _a.close(options.code, options.reason);
+      }
+      /**
+       * 处理连接后的事件绑定
+       */
+      handleConnected() {
+          this.onceOpen(() => (this._state = WebSocketState.OPEN));
+          this.onClose(() => (this._state = WebSocketState.CLOSED));
+      }
+      /**
+       * 注册websocket事件
+       */
+      registerEventHandler() {
+          var _a, _b, _c, _d;
+          (_a = this._wsTask) === null || _a === void 0 ? void 0 : _a.addEventListener(WebSocketEvent.open, (ev) => this.emit(WebSocketEvent.open, ev));
+          (_b = this._wsTask) === null || _b === void 0 ? void 0 : _b.addEventListener(WebSocketEvent.message, (result) => {
+              let data = result.data;
+              try {
+                  if (typeof result.data === 'string') {
+                      data = JSON.parse(result.data);
+                  }
+              }
+              catch (e) {
+                  /** 不可序列化的数据不用处理 */
+              }
+              this.emit(WebSocketEvent.message, data);
+          });
+          (_c = this._wsTask) === null || _c === void 0 ? void 0 : _c.addEventListener(WebSocketEvent.close, (ev) => this.emit(WebSocketEvent.close, ev));
+          (_d = this._wsTask) === null || _d === void 0 ? void 0 : _d.addEventListener(WebSocketEvent.error, (ev) => this.emit(WebSocketEvent.error, ev));
+      }
+  }
+  var Ws4Webview$1 = Ws4Webview;
+
+  const endpoint = 'wss://ws.realsee.com';
+  var defaultWsEndpoint = endpoint;
+
+  /**
+   * 拼接ws链接
+   * @param tpl
+   * @param params
+   * @returns
+   */
+  const generateWssUrl = (tpl, params) => {
+      const url = Object.keys(params).reduce((res, curr) => res.replace(`{{${curr}}}`, `${params[curr]}`), tpl);
+      return encodeURI(url);
+  };
+  var generateWssUrl$1 = generateWssUrl;
+
+  const isValidKey = (key, object) => key in object;
+  var isValidKey$1 = isValidKey;
+
+  /**
+   * 解析参数
+   * @param query
+   * @returns
+   */
+  const parseQuery = (query = '') => query
+      .replace('?', '')
+      .split('&')
+      .map((qs) => {
+      const [k, v] = qs.split('=');
+      return { [k]: decodeURIComponent(v) };
+  })
+      .reduce((result, curr) => ({ ...result, ...curr }), {});
+  var parseQuery$1 = parseQuery;
+
+  const ws = (() => new Ws4Webview$1())();
+  class HybridBridge {
+      constructor() {
+          /**
+           * @deprecated 兼容旧逻辑
+           */
+          this._rsWeappBridgeMethodAdapter = {};
+          this._forceClose = false;
+          /**
+           * 进行jsbridge的初始化，即打通ws通道
+           * @param timeout 超时计时
+           * @returns
+           */
+          this.initialize = async (timeout = 6000) => {
+              const res = [false, null];
+              const { wssid, wstsp, wssig, wsmnt = defaultWsEndpoint, } = parseQuery$1(globalThis.location.search);
+              if (!(wssid && wstsp && wssig && wsmnt)) {
+                  res[1] = new Error('HybridBridge 参数缺失，初始化失败~');
+                  return res;
+              }
+              const url = generateWssUrl$1('{{origin}}/{{endpoint}}/{{uuid}}/{{member}}/{{ak}}/{{ts}}/{{sign}}', {
+                  origin: wsmnt,
+                  endpoint: 'proxy',
+                  uuid: wssid,
+                  member: 'webview',
+                  ak: 'vr_live_miniapp',
+                  ts: wstsp,
+                  sign: wssig,
+              });
+              try {
+                  const result = await ws.connect({ url });
+                  if (result) {
+                      this.initBuiltInHandlers();
+                      res[0] = await this.waitReady(timeout);
+                  }
+                  else {
+                      res[1] = new Error('HybridBridge ws未连接，初始化失败~');
+                  }
+              }
+              catch (e) {
+                  res[1] = e;
+              }
+              return res;
+          };
+          this.getStaticData = (callbackFunctionName) => {
+              this.callAndBackfeed(JSON.stringify({
+                  actionUrl: 'common/staticData',
+                  functionName: callbackFunctionName,
+              }));
+          };
+          /**
+           * 处理一次性执行的方法
+           * @param msg JSON.stringify({ actionUrl: string, functionName: string })
+           */
+          this.callAndBackfeed = (msg) => {
+              const { actionUrl = '', functionName = '' } = JSON.parse(msg);
+              if (!actionUrl)
+                  throw new Error('callAndBackfeed actionUrl is empty!');
+              if (!functionName)
+                  throw new Error('callAndBackfeed functionName is empty!');
+              const callback = (result) => {
+                  if (typeof globalThis[functionName] === 'function') {
+                      globalThis[functionName](result);
+                  }
+              };
+              this._callAndBackfeed(actionUrl, callback);
+          };
+          /**
+           * 处理监听
+           * @param msg JSON.stringify({ actionUrl: string, functionName: string })
+           */
+          this.callAndListen = (msg) => {
+              const { actionUrl, functionName } = JSON.parse(msg);
+              if (!actionUrl)
+                  throw new Error('callAndListen actionUrl is empty!');
+              if (!functionName)
+                  throw new Error('callAndListen functionName is empty!');
+              const callback = (result) => {
+                  if (typeof globalThis[functionName] === 'function') {
+                      globalThis[functionName](result);
+                  }
+              };
+              try {
+                  this._callAndListen(actionUrl, callback);
+              }
+              catch (e) {
+                  console.warn(e);
+                  callback(false);
+              }
+          };
+      }
+      get isReady() {
+          return ws.readyState === WebSocketState.OPEN;
+      }
+      /**
+       * 内建的处理函数
+       */
+      initBuiltInHandlers() {
+          this._registerLifecycleHandler();
+          this._registerHeartbeatHandler();
+          this._registerMessageHandler();
+          this._registerBridgeRequestHandler();
+          this._registerReadyHandler();
+      }
+      /**
+       * 注册生命周期回调
+       */
+      _registerLifecycleHandler() {
+          ws.onOpen(() => console.log('RsWeappBridge open'));
+          ws.onClose((res) => {
+              console.log('RsWeappBridge close');
+              if (res.code === 1000) {
+                  switch ((res.reason + '').toLowerCase()) {
+                      case WebSocketCloseOptions.lostHeartbeat.reason: {
+                          // 心跳丢失
+                          ws.reconnect();
+                          break;
+                      }
+                      // case WebSocketCloseOptions.normalClosure.reason: // 主动关闭
+                      case WebSocketCloseOptions.interrupted.reason: // 切换到后台，被微信杀掉，需要重连连接
+                      case WebSocketCloseOptions.streamEndEncountered.reason: // 服务端拒绝连接
+                      default: {
+                          if (!this._forceClose) {
+                              ws.reconnect();
+                          }
+                          break;
+                      }
+                  }
+              }
+              if (res.code !== 1000 && !this._forceClose) {
+                  ws.reconnect();
+              }
+              if (this._forceClose)
+                  this._forceClose = false;
+          });
+          ws.onError((err) => console.error(err));
+      }
+      /**
+       * 注册心跳的回调
+       * @deprecated 兼容老的容器SDK
+       */
+      _registerHeartbeatHandler() {
+          // 收到ping时回复pong
+          this._receivedMessage(WeappBridgeMessage.ping, () => ws.send(WeappBridgeMessage.pong));
+          // 收到pong时回复ping
+          this._receivedMessage(WeappBridgeMessage.pong, () => ws.send(WeappBridgeMessage.ping));
+      }
+      /**
+       * 当收到某消息时
+       * @param targetMessage 目标消息
+       * @param handler 回调
+       * @param once 是否一次性处理
+       */
+      _receivedMessage(targetMessage, handler, once) {
+          const msgHandler = (msg) => {
+              if (msg === targetMessage) {
+                  handler();
+                  if (once) {
+                      ws.offMessage(msgHandler);
+                  }
+              }
+          };
+          ws.onMessage(msgHandler);
+      }
+      /**
+       * 强制关闭ws
+       * @param options
+       */
+      forceClose(options) {
+          this._forceClose = true;
+          ws.close(options);
+      }
+      /**
+       * 注册准备就绪的回调
+       */
+      _registerReadyHandler() {
+          // 收到就绪询问时回复已就绪
+          this._receivedMessage(WeappBridgeMessage.isReady, () => ws.send(WeappBridgeMessage.ready));
+      }
+      /**
+       * 发送消息
+       */
+      send(data) {
+          ws.send(data);
+      }
+      /**
+       * 等待响应
+       * @param timeout 超时计时
+       * @returns
+       */
+      waitReady(timeout = 6000) {
+          return new Promise((resolve, reject) => {
+              this._receivedMessage(WeappBridgeMessage.ready, () => resolve(true));
+              this.send(WeappBridgeMessage.isReady);
+              setTimeout(() => reject('HybridBridge 初始化超时~'), timeout);
+          });
+      }
+      /**
+       * 注册消息投递回调
+       * @deprecated 兼容老方法
+       */
+      _registerMessageHandler() {
+          ws.onMessage((message) => {
+              if (typeof message === 'object') {
+                  const { id, command, data } = message;
+                  if (command === 'message' &&
+                      typeof this._rsWeappBridgeMethodAdapter.bindMessage === 'function') {
+                      this._rsWeappBridgeMethodAdapter.bindMessage({ id, data });
+                  }
+              }
+          });
+      }
+      /**
+       * 注册bridge方法回调
+       * @deprecated 兼容老方法
+       */
+      _registerBridgeRequestHandler() {
+          ws.onMessage(async (request) => {
+              if (typeof request === 'object') {
+                  const { id, method, args, command } = request;
+                  if (command === 'request') {
+                      if (method) {
+                          let result = null;
+                          let error = null;
+                          let _method = null;
+                          if (typeof this._rsWeappBridgeMethodAdapter[method] === 'function') {
+                              // 优先读 _rsWeappBridgeMethodAdapter 上注册的方法
+                              _method = this._rsWeappBridgeMethodAdapter[method];
+                          }
+                          else if (globalThis && isValidKey$1(method, globalThis)) {
+                              // 再读 globalThis 下的方法
+                              _method = globalThis[method];
+                          }
+                          if (typeof _method === 'function') {
+                              try {
+                                  result = await _method(args);
+                              }
+                              catch (e) {
+                                  error = e.message || e;
+                              }
+                          }
+                          else {
+                              error = 'Method not implemented.';
+                          }
+                          this.send(JSON.stringify({
+                              id,
+                              method,
+                              result,
+                              error,
+                              command: 'response',
+                          }));
+                      }
+                  }
+              }
+          });
+      }
+      /**
+       * 处理 callAndBackfeed
+       * @param actionUrl
+       * @param backfeed
+       */
+      _callAndBackfeed(actionUrl, backfeed) {
+          const reqId = uuid();
+          const data = JSON.stringify({
+              id: reqId,
+              actionUrl,
+              command: 'rsSchemeRequest',
+              type: 'callAndBackfeed',
+          });
+          let timer = null;
+          const callback = (message) => {
+              const { id, result, errmsg, command } = message;
+              if (command === 'rsSchemeResponse' && id === reqId) {
+                  ws.offMessage(callback);
+                  if (timer)
+                      clearTimeout(timer);
+                  if (errmsg) {
+                      console.warn(errmsg);
+                      backfeed(0);
+                  }
+                  else {
+                      backfeed(result);
+                  }
+              }
+          };
+          ws.onMessage(callback);
+          this.send(data);
+          // 30s超时处理
+          timer = globalThis.setTimeout(() => {
+              console.warn('callAndBackfeed timeout');
+              backfeed(0);
+          }, 30000);
+      }
+      /**
+       * 处理 _callAndListen
+       * @param actionUrl
+       * @param fn
+       */
+      _callAndListen(actionUrl, fn) {
+          const reqId = uuid();
+          const data = JSON.stringify({
+              id: reqId,
+              actionUrl,
+              command: 'rsSchemeRequest',
+              type: 'callAndListen',
+          });
+          const callback = (message) => {
+              const { id, result, errmsg, command } = message;
+              if (command === 'rsSchemeResponse' && id === reqId) {
+                  if (errmsg) {
+                      console.warn(errmsg);
+                      fn(false);
+                  }
+                  else {
+                      fn(result);
+                  }
+              }
+          };
+          ws.onMessage(callback);
+          this.send(data);
+      }
+      /**
+       * 执行bridge上的方法
+       * @param method 方法名
+       * @param args 传递的参数
+       * @returns
+       */
+      async invoke(method, args) {
+          return new Promise((success, fail) => {
+              const reqId = uuid();
+              const data = JSON.stringify({
+                  id: reqId,
+                  method,
+                  args,
+                  command: 'request',
+              });
+              let timer = null;
+              const callback = (message) => {
+                  const { id, result, error, command } = message;
+                  if (command === 'response' &&
+                      id === reqId &&
+                      message.method === method) {
+                      ws.offMessage(callback);
+                      if (timer)
+                          clearTimeout(timer);
+                      if (error) {
+                          fail(error);
+                      }
+                      else {
+                          success(result);
+                      }
+                  }
+              };
+              ws.onMessage(callback);
+              this.send(data);
+              // 30s超时处理
+              timer = setTimeout(() => fail('method invoke timeout'), 30000);
+          });
+      }
+  }
+
+  /**
+   * Android WebView 控件。
+   */
+  class WxMiniprogramController extends BaseController {
+      constructor() {
+          super();
+          this.initializing = false;
+          Promise.resolve().then(async () => {
+              try {
+                  await this.checkBridgeReady();
+              }
+              catch (error) {
+                  console.warn(error);
+              }
+          });
+      }
+      checkBridgeReady(timeout = 6000) {
+          if (this.ready)
+              return true;
+          return new Promise(async (resolve, reject) => {
+              if (this.ready)
+                  return resolve(true);
+              if (this.initializing) {
+                  // 正在初始化中的时候
+                  const check = () => {
+                      if (this.ready)
+                          return resolve(true);
+                      requestAnimationFrame(check);
+                  };
+                  check();
+              }
+              else {
+                  this.initializing = true;
+                  const hybridBridge = new HybridBridge();
+                  const [res, error] = await hybridBridge.initialize(timeout);
+                  if (!res || error) {
+                      throw error || new Error('HybridBridge 初始化失败~');
+                  }
+                  hybridBridge === null || hybridBridge === void 0 ? void 0 : hybridBridge.getStaticData(registerGlobalValue('HYBRID_BRIDGE_NAME', (data) => {
+                      this.deviceInfo = (() => {
+                          try {
+                              return JSON.parse(data);
+                          }
+                          catch (e) {
+                              return data;
+                          }
+                      })();
+                      this.hybridBridge = hybridBridge;
+                      this.initializing = false;
+                      return resolve(true);
+                  }));
+              }
+          });
+      }
+      async checkReady(timeout = 6000) {
+          const res = [null, null];
+          if (this.ready) {
+              res[0] = true;
+              return res;
+          }
+          try {
+              res[0] = await this.checkBridgeReady(timeout);
+          }
+          catch (error) {
+              res[0] = false;
+              res[1] = error;
+          }
+          return res;
+      }
+      get ready() {
+          var _a;
+          return !!((_a = this.hybridBridge) === null || _a === void 0 ? void 0 : _a.isReady);
+      }
+      get scheme() {
+          var _a;
+          return ((_a = this.deviceInfo) === null || _a === void 0 ? void 0 : _a.scheme) || '';
+      }
+      createSchemeLink(schemeUrl) {
+          if (schemeUrl.startsWith(this.scheme)) {
+              return schemeUrl;
+          }
+          return this.scheme + '://' + schemeUrl;
+      }
+      async callAndBackfeed(scheme) {
+          const res = [false, null];
+          const [ready, readyError] = await this.checkReady();
+          if (!ready) {
+              res[0] = false;
+              res[1] = readyError;
+              return res;
+          }
+          return await new Promise(async (resolve) => {
+              const actionUrl = this.createSchemeLink(scheme);
+              const msg = JSON.stringify({
+                  actionUrl,
+                  functionName: registerGlobalValue(this.createSchemeLink(scheme), (data) => {
+                      let d = data;
+                      try {
+                          d = JSON.parse(data);
+                      }
+                      catch (e) {
+                          /** no-care */
+                      }
+                      res[0] = (() => {
+                          if (d === 1)
+                              return true;
+                          if (d === 0)
+                              return false;
+                          return d;
+                      })();
+                      resolve(res);
+                  }),
+              });
+              this.hybridBridge.callAndBackfeed(msg);
+          });
+      }
+      async callAndListen(scheme, callback) {
+          const res = [false, null];
+          const [ready, readyError] = await this.checkReady();
+          if (!ready) {
+              res[0] = false;
+              res[1] = readyError;
+              return res;
+          }
+          return await new Promise(async (resolve) => {
+              const actionUrl = this.createSchemeLink(scheme);
+              const _callback = (data) => {
+                  let d = data;
+                  try {
+                      d = JSON.parse(data);
+                  }
+                  catch (e) {
+                      /** no-care */
+                  }
+                  const callbackParam = (() => {
+                      if (d === 1)
+                          return true;
+                      if (d === 0)
+                          return false;
+                      return d;
+                  })();
+                  callback(callbackParam);
+                  res[0] = () => {
+                      // 清理掉当前的回调引用
+                      const callbacks = cache[actionUrl];
+                      if (!callbacks)
+                          return;
+                      const idx = callbacks.queue.findIndex((func) => func.callback === _callback);
+                      if (idx !== -1) {
+                          callbacks.queue.splice(idx, 1);
+                      }
+                  };
+                  resolve(res);
+              };
+              const msg = JSON.stringify({
+                  actionUrl,
+                  functionName: registerGlobalValue(actionUrl, _callback, false),
+              });
+              this.hybridBridge.callAndListen(msg);
+          });
+      }
+      async invoke(method, data) {
+          var _a, _b;
+          const [ready, readyError] = await this.checkReady();
+          if (!ready) {
+              throw readyError;
+          }
+          else {
+              return (await ((_b = (_a = this.hybridBridge).invoke) === null || _b === void 0 ? void 0 : _b.call(_a, method, data)));
+          }
+      }
+  }
+
+  /**
+   * WebView 类型枚举。
+   */
+  var WebViewTypeEnum;
+  (function (WebViewTypeEnum) {
+      /**
+       * WebKit Android
+       */
+      WebViewTypeEnum["WebView"] = "WebKit";
+      /**
+       * WKWebview iOS
+       */
+      WebViewTypeEnum["WKWebview"] = "WKWebview";
+      /**
+       * UIWebview iOS
+       *
+       * @deprecated 性能因素被抛弃
+       */
+      WebViewTypeEnum["UIWebview"] = "UIWebview";
+      /**
+       * Browser
+       *
+       * @description 浏览器
+       *
+       */
+      WebViewTypeEnum["Browser"] = "Browser";
+      /**
+       * WeChatMPWebView
+       */
+      WebViewTypeEnum["WeChatMPWebView"] = "WxMiniProgramWebView";
+      /**
+       * Unsupported
+       * @description 未支持的容器
+       */
+      WebViewTypeEnum["Unsupported"] = "Unsupported";
+  })(WebViewTypeEnum || (WebViewTypeEnum = {}));
+
+  /**
+   * jsBridge 基础类
+   */
+  class JSBridgeCore extends Subscribe {
+      constructor() {
+          super(...arguments);
+          this.webViewType = WebViewTypeEnum.Unsupported;
+      }
+  }
+
+  const userAgent$1 = globalThis.navigator.userAgent;
+  const isAndroid$1 = /android/gi.test(userAgent$1);
+  const isIOS$1 = /iPhone|iPad\s+OS/gi.test(userAgent$1);
+  const isWxMiniProgram$1 = /MicroMessenger/gi.test(userAgent$1) && /miniProgram/gi.test(userAgent$1);
+  const isRealseeVRWebview$1 = /realsee/gi.test(userAgent$1);
+
+  const defaultOptions$1 = {
+      timeout: 6000,
+  };
+  /**
+   * App 客户端（iOS [WKWebView](https://developer.apple.com/documentation/webkit/wkwebview) 或 Android [WebView](https://developer.android.google.cn/guide/webapps/webview)）JSBridge。
+   */
+  class JSBridgeApp extends JSBridgeCore {
+      constructor(options = {}) {
+          super();
+          this.options = Object.assign(defaultOptions$1, options);
+          if (!isRealseeVRWebview$1) {
+              console.warn('未知容器：此版本 `jsBridge` 不支持当前 WebView 容器 ... ');
+          }
+          this.webViewType = (() => {
+              if (isAndroid$1)
+                  return WebViewTypeEnum.WebView;
+              if (isIOS$1)
+                  return WebViewTypeEnum.WKWebview;
+              return WebViewTypeEnum.Browser;
+          })();
+          this._controller = (() => {
+              if (isAndroid$1)
+                  return new WebViewController();
+              if (isIOS$1)
+                  return new WKWebViewController();
+              return new BaseController();
+          })();
+          this.callAndListen('common/webViewState', (webviewState) => {
+              this.emit('webViewStateChange', webviewState);
+          });
+          this.callAndListen('common/webViewError', (errorInfo) => {
+              this.emit('error', errorInfo);
+          });
+      }
+      async ready() {
+          return await this._controller.checkReady(this.options.timeout);
+      }
+      async callAndBackfeed(schemeUrl) {
+          return await this._controller.callAndBackfeed(schemeUrl);
+      }
+      async callAndListen(schemeUrl, callback) {
+          var _a;
+          return await ((_a = this._controller) === null || _a === void 0 ? void 0 : _a.callAndListen(schemeUrl, callback));
+      }
+      async setLeftTopBackButton(enable) {
+          if (this.webViewType === WebViewTypeEnum.WebView) {
+              return [true, null];
+          }
+          return await this.callAndBackfeed(`common/setLeftTopBackButton?enable=${enable ? 1 : 0}`);
+      }
+      async getBangsHeight() {
+          return await this.callAndBackfeed('common/getBangsHeight');
+      }
+      async shock(duration = 4) {
+          return await this.callAndBackfeed(`common/shock?duration=${duration}`);
+      }
+      async minimize() {
+          return await this.callAndBackfeed(`common/minimize`);
+      }
+      async loadProgress(progress) {
+          progress = progress < 0 ? 0 : progress > 100 ? 100 : progress;
+          return await this.callAndBackfeed(`common/loadProgress?progress=${progress}`);
+      }
+      async closeLoading() {
+          return await this.callAndBackfeed(`common/closeLoading`);
+      }
+      async setOrientation(orientation) {
+          return await this.callAndBackfeed(`common/setOrientation?orientation=${orientation}`);
+      }
+      async keepScreenLight(enable) {
+          return await this.callAndBackfeed(`common/keepScreenLight?enable=${enable ? 1 : 0}`);
+      }
+      async closeWebView() {
+          return await this.callAndBackfeed(`common/closeWebView`);
+      }
+      async openWebView(url, way) {
+          return await this.callAndBackfeed(`common/openWebView?way=${way}&url=${encodeURIComponent(url)}`);
+      }
+      async saveImage2Album(base64) {
+          return await this.callAndBackfeed(`common/saveImage2Album?base64=${base64}`);
+      }
+      async actionShare(shareConfig) {
+          return await this.callAndBackfeed(`common/actionShare?json=${JSON.stringify(shareConfig)}`);
+      }
+      async getDeviceInfo() {
+          return await this.callAndBackfeed(`common/getDeviceInfo`);
+      }
+      async getUserInfo() {
+          return await this.callAndBackfeed(`common/getUserInfo`);
+      }
+      async getWebViewState() {
+          return await this.callAndBackfeed(`common/getWebViewState`);
+      }
+      async login() {
+          const res = await this.callAndBackfeed(`common/login`);
+          if (res[0]) {
+              return await this.getUserInfo();
+          }
+          return res;
+      }
+      async logout() {
+          return await this.callAndBackfeed(`common/logout`);
+      }
+      async detectMicro() {
+          return await this.callAndBackfeed(`common/detectMicro`);
+      }
+      async preload(urls) {
+          urls = urls.map((url) => {
+              if (url.startsWith('//')) {
+                  return 'https:' + url;
+              }
+              return url;
+          });
+          return await this.callAndBackfeed(`common/preload?urls=${JSON.stringify(urls)}`);
+      }
+      createCacheProxyUrl(urls) {
+          urls = Array.isArray(urls) ? urls : [urls];
+          const userAgent = window.navigator.userAgent;
+          // 不支持缓存代理
+          if (!/supportCache/i.test(userAgent)) {
+              return urls;
+          }
+          const proxyCache = (url) => {
+              if (this.webViewType === WebViewTypeEnum.WKWebview) {
+                  return url.replace(/https*:/, '').replace(/\/\//, 'realseeproxycache://');
+              }
+              else if (this.webViewType === WebViewTypeEnum.WebView) {
+                  return url + (url.indexOf('?') !== -1 ? '&' : '?') + 'realseeproxycache=1';
+              }
+              return url;
+          };
+          return urls.map(proxyCache);
+      }
+  }
+
+  var OpenWebViewEnum;
+  (function (OpenWebViewEnum) {
+      /**
+       * 在开启的 `VRWebView` 栈中追加一个 `WebView`。
+       */
+      OpenWebViewEnum["Append"] = "Append";
+      /**
+       * 强制 先关闭当前的 `VRWebiView` 然后开启新的 `VRWebView`。
+       */
+      OpenWebViewEnum["Replace"] = "Replace";
+      /**
+       * 删除所有的 `VRWebView`，仅保留本次新开启的 `VRWebView`。
+       */
+      OpenWebViewEnum["Single"] = "Single";
+  })(OpenWebViewEnum || (OpenWebViewEnum = {}));
+
+  /**
+   * 浏览器端的jsbridge
+   */
+  class JSBridgeBrowser extends JSBridgeCore {
+      constructor() {
+          super(...arguments);
+          this.webViewType = WebViewTypeEnum.Browser;
+      }
+      ready() {
+          return Promise.resolve([true, null]);
+      }
+      callAndBackfeed(schemeUrl) {
+          return Promise.resolve([false, null]);
+      }
+      callAndListen(schemeUrl, callback) {
+          return Promise.resolve([() => void 0, null]);
+      }
+      loadProgress(progress) {
+          return Promise.resolve([true, null]);
+      }
+      closeLoading() {
+          return Promise.resolve([true, null]);
+      }
+      getDeviceInfo() {
+          return Promise.resolve([false, null]);
+      }
+      getWebViewState() {
+          return Promise.resolve([false, null]);
+      }
+      setLeftTopBackButton(enable) {
+          return Promise.resolve([false, null]);
+      }
+      login() {
+          return Promise.resolve([false, null]);
+      }
+      logout() {
+          return Promise.resolve([false, null]);
+      }
+      getUserInfo() {
+          return Promise.resolve([false, null]);
+      }
+      openWebView(url, way) {
+          switch (way) {
+              case OpenWebViewEnum.Replace:
+              case OpenWebViewEnum.Single: {
+                  setTimeout(() => globalThis.location.replace(url), 200);
+                  break;
+              }
+              case OpenWebViewEnum.Append:
+              default: {
+                  setTimeout(() => (globalThis.location.href = url), 200);
+                  break;
+              }
+          }
+          return Promise.resolve([true, null]);
+      }
+      closeWebView() {
+          globalThis.close();
+          return Promise.resolve([true, null]);
+      }
+      getBangsHeight() {
+          return Promise.resolve([0, null]);
+      }
+      setOrientation(orientation) {
+          return Promise.resolve([false, null]);
+      }
+      keepScreenLight(enable) {
+          return Promise.resolve([false, null]);
+      }
+      shock(duration) {
+          return Promise.resolve([false, null]);
+      }
+      minimize() {
+          return Promise.resolve([false, null]);
+      }
+      saveImage2Album(base64) {
+          return Promise.resolve([false, null]);
+      }
+      detectMicro() {
+          return new Promise((resolve) => {
+              const rule = { audio: true, video: false };
+              try {
+                  globalThis.navigator.mediaDevices
+                      .getUserMedia(rule)
+                      .then(() => resolve([true, null]))
+                      .catch((e) => resolve([false, e]));
+              }
+              catch (e) {
+                  console.error(e);
+                  resolve([false, e]);
+              }
+          });
+      }
+      actionShare(shareConfig) {
+          return Promise.resolve([false, null]);
+      }
+      preload(urls) {
+          return Promise.resolve([false, null]);
+      }
+      createCacheProxyUrl(urls) {
+          return [];
+      }
+  }
+
+  const defaultOptions = {
+      timeout: 6000,
+  };
+  /**
+   * 小程序 [web-view](https://developers.weixin.qq.com/miniprogram/dev/component/web-view.html) JSBridge。
+   */
+  class JSBridgeMiniprogram extends JSBridgeCore {
+      constructor(options = {}) {
+          super();
+          this._controller = new WxMiniprogramController();
+          this.options = Object.assign(defaultOptions, options);
+          if (!isWxMiniProgram$1) {
+              console.warn('未知容器：此版本 `jsBridge` 不支持当前 WebView 容器 ... ');
+          }
+          this.webViewType = WebViewTypeEnum.WeChatMPWebView;
+          this.callAndListen('common/webViewState', (webviewState) => {
+              this.emit('webViewStateChange', webviewState);
+          });
+          this.callAndListen('common/webViewError', (errorInfo) => {
+              this.emit('error', errorInfo);
+          });
+      }
+      async ready() {
+          return await this._controller.checkReady(this.options.timeout);
+      }
+      async callAndBackfeed(schemeUrl) {
+          return await this._controller.callAndBackfeed(schemeUrl);
+      }
+      async callAndListen(schemeUrl, callback) {
+          return await this._controller.callAndListen(schemeUrl, callback);
+      }
+      async setLeftTopBackButton(enable) {
+          if (this.webViewType === WebViewTypeEnum.WebView) {
+              return [true, null];
+          }
+          return await this.callAndBackfeed(`common/setLeftTopBackButton?enable=${enable ? 1 : 0}`);
+      }
+      async getBangsHeight() {
+          return await this.callAndBackfeed('common/getBangsHeight');
+      }
+      async shock(duration = 4) {
+          return await this.callAndBackfeed(`common/shock?duration=${duration}`);
+      }
+      async minimize() {
+          return await this.callAndBackfeed(`common/minimize`);
+      }
+      async loadProgress(progress) {
+          progress = progress < 0 ? 0 : progress > 100 ? 100 : progress;
+          return await this.callAndBackfeed(`common/loadProgress?progress=${progress}`);
+      }
+      async closeLoading() {
+          return await this.callAndBackfeed(`common/closeLoading`);
+      }
+      async setOrientation(orientation) {
+          return await this.callAndBackfeed(`common/setOrientation?orientation=${orientation}`);
+      }
+      async keepScreenLight(enable) {
+          return await this.callAndBackfeed(`common/keepScreenLight?enable=${enable ? 1 : 0}`);
+      }
+      async closeWebView() {
+          return await this.callAndBackfeed(`common/closeWebView`);
+      }
+      async openWebView(url, way) {
+          return await this.callAndBackfeed(`common/openWebView?way=${way}&url=${encodeURIComponent(url)}`);
+      }
+      async saveImage2Album(base64) {
+          return await this.callAndBackfeed(`common/saveImage2Album?base64=${base64}`);
+      }
+      async actionShare(shareConfig) {
+          var _a, _b, _c;
+          const config = {
+              path: (_a = shareConfig.miniprogram) === null || _a === void 0 ? void 0 : _a[0].path,
+              title: (_b = shareConfig.miniprogram) === null || _b === void 0 ? void 0 : _b[0].title,
+              imageUrl: (_c = shareConfig.miniprogram) === null || _c === void 0 ? void 0 : _c[0].hdImageData,
+          };
+          return await this.callAndBackfeed(`common/actionShare?json=${JSON.stringify(config)}`);
+      }
+      async getDeviceInfo() {
+          return await this.callAndBackfeed(`common/getDeviceInfo`);
+      }
+      async getUserInfo() {
+          return await this.callAndBackfeed(`common/getUserInfo`);
+      }
+      async getWebViewState() {
+          return await this.callAndBackfeed(`common/getWebViewState`);
+      }
+      async login() {
+          const res = await this.callAndBackfeed(`common/login`);
+          if (res[0]) {
+              return await this.getUserInfo();
+          }
+          return res;
+      }
+      async logout() {
+          return await this.callAndBackfeed(`common/logout`);
+      }
+      async detectMicro() {
+          return await this.callAndBackfeed(`common/detectMicro`);
+      }
+      async preload(urls) {
+          urls = urls.map((url) => {
+              if (url.startsWith('//')) {
+                  return 'https:' + url;
+              }
+              return url;
+          });
+          return await this.callAndBackfeed(`common/preload?urls=${JSON.stringify(urls)}`);
+      }
+      createCacheProxyUrl(urls) {
+          urls = Array.isArray(urls) ? urls : [urls];
+          const userAgent = window.navigator.userAgent;
+          // 不支持缓存代理
+          if (!/supportCache/i.test(userAgent)) {
+              return urls;
+          }
+          const proxyCache = (url) => {
+              if (this.webViewType === WebViewTypeEnum.WKWebview) {
+                  return url.replace(/https*:/, '').replace(/\/\//, 'realseeproxycache://');
+              }
+              else if (this.webViewType === WebViewTypeEnum.WebView) {
+                  return url + (url.indexOf('?') !== -1 ? '&' : '?') + 'realseeproxycache=1';
+              }
+              return url;
+          };
+          return urls.map(proxyCache);
+      }
+      async invokeNativeApi(method, data) {
+          return await this._controller.invoke(method, data);
+      }
+  }
+
+  /**
+   * 平台相关的jsBridge类，根据平台自动加载不同的jsBridge实例
+   */
+  // @ts-ignore
+  class JSBridge extends JSBridgeCore {
+      constructor(options = {}) {
+          super();
+          if (isRealseeVRWebview$1 && (isAndroid$1 || isIOS$1))
+              return new JSBridgeApp(options);
+          if (isWxMiniProgram$1)
+              return new JSBridgeMiniprogram(options);
+          return new JSBridgeBrowser();
+      }
+  }
+
   function appendUri(uri, query) {
       const hasQuery = uri.indexOf('?') !== -1;
       const newQuery = Object.keys(query).reduce((accu, curr, idx) => `${accu}${(idx === 0 && !hasQuery) ? '?' : '&'}${curr}=${query[curr]}`, '');
       return uri + newQuery;
   }
 
+  const userAgent = globalThis.navigator.userAgent;
+  const isAndroid = /android/gi.test(userAgent);
+  const isIOS = /iPhone|iPad\s+OS/gi.test(userAgent);
+  const isWxMiniProgram = /MicroMessenger/gi.test(userAgent) && /miniProgram/gi.test(userAgent);
+  const isRealseeVRWebview = /realsee/gi.test(userAgent);
+
   /**
    * 判断是否是真实的对象类型
    * @param value
@@ -49140,13 +50874,13 @@
               : [];
           if (toUserIds)
               data['to_user_ids'] = toUserIds;
-          return { command, front_request_id: uuid(), data };
+          return { command, front_request_id: uuid$1(), data };
       };
-      class LiveTpl extends Subscribe {
+      class LiveTpl extends Subscribe$1 {
           constructor() {
-              var _a;
+              var _a, _b, _c;
               super();
-              this.keyframes = new Subscribe();
+              this.keyframes = new Subscribe$1();
               // 没有传rtc实例时
               if (!options.rtc) {
                   // 取指定的内部rtc类型
@@ -49187,6 +50921,34 @@
                           }
                       }
                   }
+                  // 都不满足时取内置
+                  if (options.useBuiltInRTC) {
+                      if (!options.getVoiceSign) {
+                          throw new Error('GetVoiceSign method must be passed when using built-in RTC instances');
+                      }
+                      const getVoiceSign = (_b = options.getVoiceSign) !== null && _b !== void 0 ? _b : unimplementedGetVoiceSign;
+                      const jsBridge = ((_c = options.jsBridge) !== null && _c !== void 0 ? _c : options.useBuiltInJsBridge)
+                          ? new JSBridge()
+                          : null;
+                      if (!jsBridge) {
+                          throw new Error('jsBridge instance must be passed when using built-in RTC instances');
+                      }
+                      options.jsBridge = jsBridge;
+                      // vrwebview 默认
+                      if ((isRealseeVRWebview && (isAndroid || isIOS)) || isWxMiniProgram) {
+                          liveController.options.rtc = new VRWebViewRTC({
+                              jsBridge,
+                              getVoiceSign,
+                          });
+                      }
+                      else {
+                          // 其它终端使用
+                          liveController.options.rtc =
+                              options.builtInRTCType === exports.BuiltInRTCType.RealseeXChimeRTC
+                                  ? new BrowserRTC4Chime({ getVoiceSign })
+                                  : new BrowserRTC({ getVoiceSign });
+                      }
+                  }
               }
               if (!liveController.options.rtc) {
                   console.warn('unused rtc');
@@ -49234,6 +50996,9 @@
           get $RTC() {
               return liveController.options.rtc;
           }
+          get jsBridge() {
+              return liveController.options.jsBridge;
+          }
           async setSelfInfo(userInfo) {
               if (this.readyState !== exports.WebSocketState.OPEN) {
                   return new Error('The connection is not open and ready to communicate.');