@realsee/live 0.4.0-alpha.2 → 0.4.0-alpha.5

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);
       }
@@ -10658,7 +10663,7 @@
            : part2 < 128 ? 9 : 10;
   };
 
-  var require$$0$5 = aspromise;
+  var require$$0$6 = aspromise;
 
   var require$$1$3 = base64_1;
 
@@ -10678,7 +10683,7 @@
   var util = exports;
 
   // used to return a Promise where callback is omitted
-  util.asPromise = require$$0$5;
+  util.asPromise = require$$0$6;
 
   // converts to / from base64 encoded strings
   util.base64 = require$$1$3;
@@ -11549,13 +11554,13 @@
       BufferWriter$1 = BufferWriter_;
   };
 
-  var require$$0$4 = writer;
+  var require$$0$5 = writer;
 
   var writer_buffer = BufferWriter;
 
   // extends Writer
 
-  (BufferWriter.prototype = Object.create(require$$0$4.prototype)).constructor = BufferWriter;
+  (BufferWriter.prototype = Object.create(require$$0$5.prototype)).constructor = BufferWriter;
 
 
 
@@ -11568,7 +11573,7 @@
    * @constructor
    */
   function BufferWriter() {
-      require$$0$4.call(this);
+      require$$0$5.call(this);
   }
 
   /**
@@ -12210,7 +12215,7 @@
       return this;
   };
 
-  var require$$0$3 = service;
+  var require$$0$4 = service;
 
   var rpc_1 = createCommonjsModule(function (module, exports) {
 
@@ -12247,7 +12252,7 @@
    * @returns {undefined}
    */
 
-  rpc.Service = require$$0$3;
+  rpc.Service = require$$0$4;
   });
 
   var roots = {};
@@ -12272,7 +12277,7 @@
   protobuf.build = "minimal";
 
   // Serialization
-  protobuf.Writer       = require$$0$4;
+  protobuf.Writer       = require$$0$5;
   protobuf.BufferWriter = require$$1$2;
   protobuf.Reader       = require$$2;
   protobuf.BufferReader = require$$3;
@@ -12298,9 +12303,9 @@
   configure();
   });
 
-  var require$$0$2 = indexMinimal;
+  var require$$0$3 = indexMinimal;
 
-  var minimal = require$$0$2;
+  var minimal = require$$0$3;
 
   var $protobuf = minimal;
 
@@ -31104,7 +31109,7 @@
     //Z_NULL:                 null // Use -1 or null inline, depending on var type
   };
 
-  var require$$0$1 = trees;
+  var require$$0$2 = trees;
 
   var adler32 = adler32_1;
 
@@ -31133,7 +31138,7 @@
   //   misrepresented as being the original software.
   // 3. This notice may not be removed or altered from any source distribution.
 
-  const { _tr_init, _tr_stored_block, _tr_flush_block, _tr_tally, _tr_align } = require$$0$1;
+  const { _tr_init, _tr_stored_block, _tr_flush_block, _tr_tally, _tr_align } = require$$0$2;
 
 
 
@@ -36365,11 +36370,11 @@
   	constants: constants
   };
 
-  var require$$0 = deflate_1$1;
+  var require$$0$1 = deflate_1$1;
 
   var require$$1$1 = inflate_1$1;
 
-  const { Deflate, deflate, deflateRaw, gzip } = require$$0;
+  const { Deflate, deflate, deflateRaw, gzip } = require$$0$1;
 
   const { Inflate, inflate, inflateRaw, ungzip } = require$$1$1;
 
@@ -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,17 @@
               : [];
           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();
+              const jsBridge = ((_a = options.jsBridge) !== null && _a !== void 0 ? _a : options.useBuiltInJsBridge)
+                  ? new JSBridge()
+                  : undefined;
+              liveController.options.jsBridge = jsBridge;
               // 没有传rtc实例时
               if (!options.rtc) {
                   // 取指定的内部rtc类型
@@ -49154,15 +50892,15 @@
                       if (!options.getVoiceSign) {
                           throw new Error('GetVoiceSign method must be passed when using built-in RTC instances');
                       }
-                      const getVoiceSign = (_a = options.getVoiceSign) !== null && _a !== void 0 ? _a : unimplementedGetVoiceSign;
+                      const getVoiceSign = (_b = options.getVoiceSign) !== null && _b !== void 0 ? _b : unimplementedGetVoiceSign;
                       switch (options.rtcType) {
                           case exports.RTCType.RealseeVRWebViewRTC: {
                               // 内置的 VRWebViewRTC
-                              if (!options.jsBridge) {
+                              if (!jsBridge) {
                                   throw new Error('JsBridge instance must be passed when using built-in VRWebViewRTC instances');
                               }
                               liveController.options.rtc = new VRWebViewRTC({
-                                  jsBridge: options.jsBridge,
+                                  jsBridge,
                                   getVoiceSign,
                               });
                               break;
@@ -49187,6 +50925,30 @@
                           }
                       }
                   }
+                  // 都不满足时取内置
+                  if (options.useBuiltInRTC) {
+                      if (!options.getVoiceSign) {
+                          throw new Error('GetVoiceSign method must be passed when using built-in RTC instances');
+                      }
+                      const getVoiceSign = (_c = options.getVoiceSign) !== null && _c !== void 0 ? _c : unimplementedGetVoiceSign;
+                      if (!jsBridge) {
+                          throw new Error('jsBridge instance must be passed when using built-in RTC instances');
+                      }
+                      // 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.');
@@ -49474,8 +51239,98 @@
       return live;
   }
 
-  /**
-   * @license React
+  /*
+  object-assign
+  (c) Sindre Sorhus
+  @license MIT
+  */
+  /* eslint-disable no-unused-vars */
+  var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+  var hasOwnProperty = Object.prototype.hasOwnProperty;
+  var propIsEnumerable = Object.prototype.propertyIsEnumerable;
+
+  function toObject(val) {
+  	if (val === null || val === undefined) {
+  		throw new TypeError('Object.assign cannot be called with null or undefined');
+  	}
+
+  	return Object(val);
+  }
+
+  function shouldUseNative() {
+  	try {
+  		if (!Object.assign) {
+  			return false;
+  		}
+
+  		// Detect buggy property enumeration order in older V8 versions.
+
+  		// https://bugs.chromium.org/p/v8/issues/detail?id=4118
+  		var test1 = new String('abc');  // eslint-disable-line no-new-wrappers
+  		test1[5] = 'de';
+  		if (Object.getOwnPropertyNames(test1)[0] === '5') {
+  			return false;
+  		}
+
+  		// https://bugs.chromium.org/p/v8/issues/detail?id=3056
+  		var test2 = {};
+  		for (var i = 0; i < 10; i++) {
+  			test2['_' + String.fromCharCode(i)] = i;
+  		}
+  		var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
+  			return test2[n];
+  		});
+  		if (order2.join('') !== '0123456789') {
+  			return false;
+  		}
+
+  		// https://bugs.chromium.org/p/v8/issues/detail?id=3056
+  		var test3 = {};
+  		'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
+  			test3[letter] = letter;
+  		});
+  		if (Object.keys(Object.assign({}, test3)).join('') !==
+  				'abcdefghijklmnopqrst') {
+  			return false;
+  		}
+
+  		return true;
+  	} catch (err) {
+  		// We don't expect any of the above to throw, but better to be safe.
+  		return false;
+  	}
+  }
+
+  var objectAssign = shouldUseNative() ? Object.assign : function (target, source) {
+  	var from;
+  	var to = toObject(target);
+  	var symbols;
+
+  	for (var s = 1; s < arguments.length; s++) {
+  		from = Object(arguments[s]);
+
+  		for (var key in from) {
+  			if (hasOwnProperty.call(from, key)) {
+  				to[key] = from[key];
+  			}
+  		}
+
+  		if (getOwnPropertySymbols) {
+  			symbols = getOwnPropertySymbols(from);
+  			for (var i = 0; i < symbols.length; i++) {
+  				if (propIsEnumerable.call(from, symbols[i])) {
+  					to[symbols[i]] = from[symbols[i]];
+  				}
+  			}
+  		}
+  	}
+
+  	return to;
+  };
+
+  var require$$0 = objectAssign;
+
+  /** @license React v17.0.2
    * react.development.js
    *
    * Copyright (c) Facebook, Inc. and its affiliates.
@@ -49489,44 +51344,59 @@
   {
     (function() {
 
-  /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
-  if (
-    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
-    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart ===
-      'function'
-  ) {
-    __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
-  }
-            var ReactVersion = '18.1.0';
-
-  // -----------------------------------------------------------------------------
-
-  var enableScopeAPI = false; // Experimental Create Event Handle API.
-  var enableCacheElement = false;
-  var enableTransitionTracing = false; // No known bugs, but needs performance testing
+  var _assign = require$$0;
 
-  var enableLegacyHidden = false; // Enables unstable_avoidThisFallback feature in Fiber
-  // stuff. Intended to enable React core members to more easily debug scheduling
-  // issues in DEV builds.
-
-  var enableDebugTracing = false; // Track which Fiber(s) schedule render work.
+  // TODO: this is special because it gets imported during build.
+  var ReactVersion = '17.0.2';
 
   // ATTENTION
-
-  var REACT_ELEMENT_TYPE =  Symbol.for('react.element');
-  var REACT_PORTAL_TYPE =  Symbol.for('react.portal');
-  var REACT_FRAGMENT_TYPE =  Symbol.for('react.fragment');
-  var REACT_STRICT_MODE_TYPE =  Symbol.for('react.strict_mode');
-  var REACT_PROFILER_TYPE =  Symbol.for('react.profiler');
-  var REACT_PROVIDER_TYPE =  Symbol.for('react.provider');
-  var REACT_CONTEXT_TYPE =  Symbol.for('react.context');
-  var REACT_FORWARD_REF_TYPE =  Symbol.for('react.forward_ref');
-  var REACT_SUSPENSE_TYPE =  Symbol.for('react.suspense');
-  var REACT_SUSPENSE_LIST_TYPE =  Symbol.for('react.suspense_list');
-  var REACT_MEMO_TYPE =  Symbol.for('react.memo');
-  var REACT_LAZY_TYPE =  Symbol.for('react.lazy');
-  var REACT_OFFSCREEN_TYPE =  Symbol.for('react.offscreen');
-  var MAYBE_ITERATOR_SYMBOL =  Symbol.iterator;
+  // When adding new symbols to this file,
+  // Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+  // The Symbol used to tag the ReactElement-like types. If there is no native Symbol
+  // nor polyfill, then a plain number is used for performance.
+  var REACT_ELEMENT_TYPE = 0xeac7;
+  var REACT_PORTAL_TYPE = 0xeaca;
+  exports.Fragment = 0xeacb;
+  exports.StrictMode = 0xeacc;
+  exports.Profiler = 0xead2;
+  var REACT_PROVIDER_TYPE = 0xeacd;
+  var REACT_CONTEXT_TYPE = 0xeace;
+  var REACT_FORWARD_REF_TYPE = 0xead0;
+  exports.Suspense = 0xead1;
+  var REACT_SUSPENSE_LIST_TYPE = 0xead8;
+  var REACT_MEMO_TYPE = 0xead3;
+  var REACT_LAZY_TYPE = 0xead4;
+  var REACT_BLOCK_TYPE = 0xead9;
+  var REACT_SERVER_BLOCK_TYPE = 0xeada;
+  var REACT_FUNDAMENTAL_TYPE = 0xead5;
+  var REACT_DEBUG_TRACING_MODE_TYPE = 0xeae1;
+  var REACT_LEGACY_HIDDEN_TYPE = 0xeae3;
+
+  if (typeof Symbol === 'function' && Symbol.for) {
+    var symbolFor = Symbol.for;
+    REACT_ELEMENT_TYPE = symbolFor('react.element');
+    REACT_PORTAL_TYPE = symbolFor('react.portal');
+    exports.Fragment = symbolFor('react.fragment');
+    exports.StrictMode = symbolFor('react.strict_mode');
+    exports.Profiler = symbolFor('react.profiler');
+    REACT_PROVIDER_TYPE = symbolFor('react.provider');
+    REACT_CONTEXT_TYPE = symbolFor('react.context');
+    REACT_FORWARD_REF_TYPE = symbolFor('react.forward_ref');
+    exports.Suspense = symbolFor('react.suspense');
+    REACT_SUSPENSE_LIST_TYPE = symbolFor('react.suspense_list');
+    REACT_MEMO_TYPE = symbolFor('react.memo');
+    REACT_LAZY_TYPE = symbolFor('react.lazy');
+    REACT_BLOCK_TYPE = symbolFor('react.block');
+    REACT_SERVER_BLOCK_TYPE = symbolFor('react.server.block');
+    REACT_FUNDAMENTAL_TYPE = symbolFor('react.fundamental');
+    symbolFor('react.scope');
+    symbolFor('react.opaque.id');
+    REACT_DEBUG_TRACING_MODE_TYPE = symbolFor('react.debug_trace_mode');
+    symbolFor('react.offscreen');
+    REACT_LEGACY_HIDDEN_TYPE = symbolFor('react.legacy_hidden');
+  }
+
+  var MAYBE_ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;
   var FAUX_ITERATOR_SYMBOL = '@@iterator';
   function getIteratorFn(maybeIterable) {
     if (maybeIterable === null || typeof maybeIterable !== 'object') {
@@ -49558,14 +51428,7 @@
    * should suspend for if it needs to.
    */
   var ReactCurrentBatchConfig = {
-    transition: null
-  };
-
-  var ReactCurrentActQueue = {
-    current: null,
-    // Used to reproduce behavior of `batchedUpdates` in legacy mode.
-    isBatchingLegacy: false,
-    didScheduleLegacyUpdate: false
+    transition: 0
   };
 
   /**
@@ -49618,15 +51481,24 @@
     };
   }
 
+  /**
+   * Used by act() to track whether you're inside an act() scope.
+   */
+  var IsSomeRendererActing = {
+    current: false
+  };
+
   var ReactSharedInternals = {
     ReactCurrentDispatcher: ReactCurrentDispatcher,
     ReactCurrentBatchConfig: ReactCurrentBatchConfig,
-    ReactCurrentOwner: ReactCurrentOwner
+    ReactCurrentOwner: ReactCurrentOwner,
+    IsSomeRendererActing: IsSomeRendererActing,
+    // Used by renderers to avoid bundling object-assign twice in UMD bundles:
+    assign: _assign
   };
 
   {
     ReactSharedInternals.ReactDebugCurrentFrame = ReactDebugCurrentFrame;
-    ReactSharedInternals.ReactCurrentActQueue = ReactCurrentActQueue;
   }
 
   // by calls to these methods by a Babel plugin.
@@ -49636,24 +51508,20 @@
 
   function warn(format) {
     {
-      {
-        for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-          args[_key - 1] = arguments[_key];
-        }
-
-        printWarning('warn', format, args);
+      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        args[_key - 1] = arguments[_key];
       }
+
+      printWarning('warn', format, args);
     }
   }
   function error(format) {
     {
-      {
-        for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
-          args[_key2 - 1] = arguments[_key2];
-        }
-
-        printWarning('error', format, args);
+      for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+        args[_key2 - 1] = arguments[_key2];
       }
+
+      printWarning('error', format, args);
     }
   }
 
@@ -49667,11 +51535,10 @@
       if (stack !== '') {
         format += '%s';
         args = args.concat([stack]);
-      } // eslint-disable-next-line react-internal/safe-string-coercion
-
+      }
 
       var argsWithFormat = args.map(function (item) {
-        return String(item);
+        return '' + item;
       }); // Careful: RN currently depends on this prefix
 
       argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it
@@ -49769,8 +51636,6 @@
     }
   };
 
-  var assign = Object.assign;
-
   var emptyObject = {};
 
   {
@@ -49819,8 +51684,10 @@
    */
 
   Component.prototype.setState = function (partialState, callback) {
-    if (typeof partialState !== 'object' && typeof partialState !== 'function' && partialState != null) {
-      throw new Error('setState(...): takes an object of state variables to update or a ' + 'function which returns an object of state variables.');
+    if (!(typeof partialState === 'object' || typeof partialState === 'function' || partialState == null)) {
+      {
+        throw Error( "setState(...): takes an object of state variables to update or a function which returns an object of state variables." );
+      }
     }
 
     this.updater.enqueueSetState(this, partialState, callback, 'setState');
@@ -49892,7 +51759,8 @@
   var pureComponentPrototype = PureComponent.prototype = new ComponentDummy();
   pureComponentPrototype.constructor = PureComponent; // Avoid an extra prototype jump for these methods.
 
-  assign(pureComponentPrototype, Component.prototype);
+  _assign(pureComponentPrototype, Component.prototype);
+
   pureComponentPrototype.isPureReactComponent = true;
 
   // an immutable object with a single mutable value
@@ -49908,96 +51776,16 @@
     return refObject;
   }
 
-  var isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
-
-  function isArray(a) {
-    return isArrayImpl(a);
-  }
-
-  /*
-   * The `'' + value` pattern (used in in perf-sensitive code) throws for Symbol
-   * and Temporal.* types. See https://github.com/facebook/react/pull/22064.
-   *
-   * The functions in this module will throw an easier-to-understand,
-   * easier-to-debug exception with a clear errors message message explaining the
-   * problem. (Instead of a confusing exception thrown inside the implementation
-   * of the `value` object).
-   */
-  // $FlowFixMe only called in DEV, so void return is not possible.
-  function typeName(value) {
-    {
-      // toStringTag is needed for namespaced types like Temporal.Instant
-      var hasToStringTag = typeof Symbol === 'function' && Symbol.toStringTag;
-      var type = hasToStringTag && value[Symbol.toStringTag] || value.constructor.name || 'Object';
-      return type;
-    }
-  } // $FlowFixMe only called in DEV, so void return is not possible.
-
-
-  function willCoercionThrow(value) {
-    {
-      try {
-        return false;
-      } catch (e) {
-        return true;
-      }
-    }
-  }
-
-  function testStringCoercion(value) {
-    // If you ended up here by following an exception call stack, here's what's
-    // happened: you supplied an object or symbol value to React (as a prop, key,
-    // DOM attribute, CSS property, string ref, etc.) and when React tried to
-    // coerce it to a string using `'' + value`, an exception was thrown.
-    //
-    // The most common types that will cause this exception are `Symbol` instances
-    // and Temporal objects like `Temporal.Instant`. But any object that has a
-    // `valueOf` or `[Symbol.toPrimitive]` method that throws will also cause this
-    // exception. (Library authors do this to prevent users from using built-in
-    // numeric operators like `+` or comparison operators like `>=` because custom
-    // methods are needed to perform accurate arithmetic or comparison.)
-    //
-    // To fix the problem, coerce this object or symbol value to a string before
-    // passing it to React. The most reliable way is usually `String(value)`.
-    //
-    // To find which value is throwing, check the browser or debugger console.
-    // Before this exception was thrown, there should be `console.error` output
-    // that shows the type (Symbol, Temporal.PlainDate, etc.) that caused the
-    // problem and how that type was used: key, atrribute, input value prop, etc.
-    // In most cases, this console output also shows the component and its
-    // ancestor components where the exception happened.
-    //
-    // eslint-disable-next-line react-internal/safe-string-coercion
-    return '' + value;
-  }
-  function checkKeyStringCoercion(value) {
-    {
-      if (willCoercionThrow()) {
-        error('The provided key is an unsupported type %s.' + ' This value must be coerced to a string before before using it here.', typeName(value));
-
-        return testStringCoercion(value); // throw (to help callers find troubleshooting comments)
-      }
-    }
-  }
-
   function getWrappedName(outerType, innerType, wrapperName) {
-    var displayName = outerType.displayName;
-
-    if (displayName) {
-      return displayName;
-    }
-
     var functionName = innerType.displayName || innerType.name || '';
-    return functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName;
-  } // Keep in sync with react-reconciler/getComponentNameFromFiber
-
+    return outerType.displayName || (functionName !== '' ? wrapperName + "(" + functionName + ")" : wrapperName);
+  }
 
   function getContextName(type) {
     return type.displayName || 'Context';
-  } // Note that the reconciler package should generally prefer to use getComponentNameFromFiber() instead.
-
+  }
 
-  function getComponentNameFromType(type) {
+  function getComponentName(type) {
     if (type == null) {
       // Host root, text node or just invalid type.
       return null;
@@ -50005,7 +51793,7 @@
 
     {
       if (typeof type.tag === 'number') {
-        error('Received an unexpected object in getComponentNameFromType(). ' + 'This is likely a bug in React. Please file an issue.');
+        error('Received an unexpected object in getComponentName(). ' + 'This is likely a bug in React. Please file an issue.');
       }
     }
 
@@ -50018,24 +51806,23 @@
     }
 
     switch (type) {
-      case REACT_FRAGMENT_TYPE:
+      case exports.Fragment:
         return 'Fragment';
 
       case REACT_PORTAL_TYPE:
         return 'Portal';
 
-      case REACT_PROFILER_TYPE:
+      case exports.Profiler:
         return 'Profiler';
 
-      case REACT_STRICT_MODE_TYPE:
+      case exports.StrictMode:
         return 'StrictMode';
 
-      case REACT_SUSPENSE_TYPE:
+      case exports.Suspense:
         return 'Suspense';
 
       case REACT_SUSPENSE_LIST_TYPE:
         return 'SuspenseList';
-
     }
 
     if (typeof type === 'object') {
@@ -50052,13 +51839,10 @@
           return getWrappedName(type, type.render, 'ForwardRef');
 
         case REACT_MEMO_TYPE:
-          var outerName = type.displayName || null;
+          return getComponentName(type.type);
 
-          if (outerName !== null) {
-            return outerName;
-          }
-
-          return getComponentNameFromType(type.type) || 'Memo';
+        case REACT_BLOCK_TYPE:
+          return getComponentName(type._render);
 
         case REACT_LAZY_TYPE:
           {
@@ -50067,13 +51851,11 @@
             var init = lazyComponent._init;
 
             try {
-              return getComponentNameFromType(init(payload));
+              return getComponentName(init(payload));
             } catch (x) {
               return null;
             }
           }
-
-        // eslint-disable-next-line no-fallthrough
       }
     }
 
@@ -50081,7 +51863,6 @@
   }
 
   var hasOwnProperty = Object.prototype.hasOwnProperty;
-
   var RESERVED_PROPS = {
     key: true,
     ref: true,
@@ -50161,7 +51942,7 @@
   function warnIfStringRefCannotBeAutoConverted(config) {
     {
       if (typeof config.ref === 'string' && ReactCurrentOwner.current && config.__self && ReactCurrentOwner.current.stateNode !== config.__self) {
-        var componentName = getComponentNameFromType(ReactCurrentOwner.current.type);
+        var componentName = getComponentName(ReactCurrentOwner.current.type);
 
         if (!didWarnAboutStringRefs[componentName]) {
           error('Component "%s" contains the string ref "%s". ' + 'Support for string refs will be removed in a future major release. ' + 'This case cannot be automatically converted to an arrow function. ' + 'We ask you to manually fix this case by using useRef() or createRef() instead. ' + 'Learn more about using refs safely here: ' + 'https://reactjs.org/link/strict-mode-string-ref', componentName, config.ref);
@@ -50270,10 +52051,6 @@
       }
 
       if (hasValidKey(config)) {
-        {
-          checkKeyStringCoercion(config.key);
-        }
-
         key = '' + config.key;
       }
 
@@ -50346,13 +52123,16 @@
    */
 
   function cloneElement(element, config, children) {
-    if (element === null || element === undefined) {
-      throw new Error("React.cloneElement(...): The argument must be a React element, but you passed " + element + ".");
+    if (!!(element === null || element === undefined)) {
+      {
+        throw Error( "React.cloneElement(...): The argument must be a React element, but you passed " + element + "." );
+      }
     }
 
     var propName; // Original props are copied
 
-    var props = assign({}, element.props); // Reserved names are extracted
+    var props = _assign({}, element.props); // Reserved names are extracted
+
 
     var key = element.key;
     var ref = element.ref; // Self is preserved since the owner is preserved.
@@ -50373,10 +52153,6 @@
       }
 
       if (hasValidKey(config)) {
-        {
-          checkKeyStringCoercion(config.key);
-        }
-
         key = '' + config.key;
       } // Remaining properties override existing props
 
@@ -50475,10 +52251,6 @@
     // that we don't block potential future ES APIs.
     if (typeof element === 'object' && element !== null && element.key != null) {
       // Explicit key
-      {
-        checkKeyStringCoercion(element.key);
-      }
-
       return escape('' + element.key);
     } // Implicit key determined by the index in the set
 
@@ -50522,7 +52294,7 @@
 
       var childKey = nameSoFar === '' ? SEPARATOR + getElementKey(_child, 0) : nameSoFar;
 
-      if (isArray(mappedChild)) {
+      if (Array.isArray(mappedChild)) {
         var escapedChildKey = '';
 
         if (childKey != null) {
@@ -50534,20 +52306,10 @@
         });
       } else if (mappedChild != null) {
         if (isValidElement(mappedChild)) {
-          {
-            // The `if` statement here prevents auto-disabling of the safe
-            // coercion ESLint rule, so we must manually disable it below.
-            // $FlowFixMe Flow incorrectly thinks React.Portal doesn't have a key
-            if (mappedChild.key && (!_child || _child.key !== mappedChild.key)) {
-              checkKeyStringCoercion(mappedChild.key);
-            }
-          }
-
           mappedChild = cloneAndReplaceKey(mappedChild, // Keep both the (mapped) and old keys if they differ, just as
           // traverseAllChildren used to do for objects as children
           escapedPrefix + ( // $FlowFixMe Flow incorrectly thinks React.Portal doesn't have a key
           mappedChild.key && (!_child || _child.key !== mappedChild.key) ? // $FlowFixMe Flow incorrectly thinks existing element's key can be a number
-          // eslint-disable-next-line react-internal/safe-string-coercion
           escapeUserProvidedKey('' + mappedChild.key) + '/' : '') + childKey);
         }
 
@@ -50563,7 +52325,7 @@
 
     var nextNamePrefix = nameSoFar === '' ? SEPARATOR : nameSoFar + SUBSEPARATOR;
 
-    if (isArray(children)) {
+    if (Array.isArray(children)) {
       for (var i = 0; i < children.length; i++) {
         child = children[i];
         nextName = nextNamePrefix + getElementKey(child, i);
@@ -50596,9 +52358,13 @@
           subtreeCount += mapIntoArray(child, array, escapedPrefix, nextName, callback);
         }
       } else if (type === 'object') {
-        // eslint-disable-next-line react-internal/safe-string-coercion
-        var childrenString = String(children);
-        throw new Error("Objects are not valid as a React child (found: " + (childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString) + "). " + 'If you meant to render a collection of children, use an array ' + 'instead.');
+        var childrenString = '' + children;
+
+        {
+          {
+            throw Error( "Objects are not valid as a React child (found: " + (childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString) + "). If you meant to render a collection of children, use an array instead." );
+          }
+        }
       }
     }
 
@@ -50697,17 +52463,28 @@
 
   function onlyChild(children) {
     if (!isValidElement(children)) {
-      throw new Error('React.Children.only expected to receive a single React element child.');
+      {
+        throw Error( "React.Children.only expected to receive a single React element child." );
+      }
     }
 
     return children;
   }
 
-  function createContext(defaultValue) {
-    // TODO: Second argument used to be an optional `calculateChangedBits`
-    // function. Warn to reserve for future use?
+  function createContext(defaultValue, calculateChangedBits) {
+    if (calculateChangedBits === undefined) {
+      calculateChangedBits = null;
+    } else {
+      {
+        if (calculateChangedBits !== null && typeof calculateChangedBits !== 'function') {
+          error('createContext: Expected the optional second argument to be a ' + 'function. Instead received: %s', calculateChangedBits);
+        }
+      }
+    }
+
     var context = {
       $$typeof: REACT_CONTEXT_TYPE,
+      _calculateChangedBits: calculateChangedBits,
       // As a workaround to support multiple concurrent renderers, we categorize
       // some renderers as primary and others as secondary. We only expect
       // there to be two concurrent renderers at most: React Native (primary) and
@@ -50720,10 +52497,7 @@
       _threadCount: 0,
       // These are circular
       Provider: null,
-      Consumer: null,
-      // Add these to use same hidden class in VM as ServerContext
-      _defaultValue: null,
-      _globalName: null
+      Consumer: null
     };
     context.Provider = {
       $$typeof: REACT_PROVIDER_TYPE,
@@ -50739,7 +52513,8 @@
       // warn for the incorrect usage of Context as a Consumer.
       var Consumer = {
         $$typeof: REACT_CONTEXT_TYPE,
-        _context: context
+        _context: context,
+        _calculateChangedBits: context._calculateChangedBits
       }; // $FlowFixMe: Flow complains about not setting a value, which is intentional here
 
       Object.defineProperties(Consumer, {
@@ -50826,54 +52601,38 @@
     if (payload._status === Uninitialized) {
       var ctor = payload._result;
       var thenable = ctor(); // Transition to the next state.
-      // This might throw either because it's missing or throws. If so, we treat it
-      // as still uninitialized and try again next time. Which is the same as what
-      // happens if the ctor or any wrappers processing the ctor throws. This might
-      // end up fixing it if the resolution was a concurrency bug.
 
+      var pending = payload;
+      pending._status = Pending;
+      pending._result = thenable;
       thenable.then(function (moduleObject) {
-        if (payload._status === Pending || payload._status === Uninitialized) {
-          // Transition to the next state.
+        if (payload._status === Pending) {
+          var defaultExport = moduleObject.default;
+
+          {
+            if (defaultExport === undefined) {
+              error('lazy: Expected the result of a dynamic import() call. ' + 'Instead received: %s\n\nYour code should look like: \n  ' + // Break up imports to avoid accidentally parsing them as dependencies.
+              'const MyComponent = lazy(() => imp' + "ort('./MyComponent'))", moduleObject);
+            }
+          } // Transition to the next state.
+
+
           var resolved = payload;
           resolved._status = Resolved;
-          resolved._result = moduleObject;
+          resolved._result = defaultExport;
         }
       }, function (error) {
-        if (payload._status === Pending || payload._status === Uninitialized) {
+        if (payload._status === Pending) {
           // Transition to the next state.
           var rejected = payload;
           rejected._status = Rejected;
           rejected._result = error;
         }
       });
-
-      if (payload._status === Uninitialized) {
-        // In case, we're still uninitialized, then we're waiting for the thenable
-        // to resolve. Set it as pending in the meantime.
-        var pending = payload;
-        pending._status = Pending;
-        pending._result = thenable;
-      }
     }
 
     if (payload._status === Resolved) {
-      var moduleObject = payload._result;
-
-      {
-        if (moduleObject === undefined) {
-          error('lazy: Expected the result of a dynamic imp' + 'ort() call. ' + 'Instead received: %s\n\nYour code should look like: \n  ' + // Break up imports to avoid accidentally parsing them as dependencies.
-          'const MyComponent = lazy(() => imp' + "ort('./MyComponent'))\n\n" + 'Did you accidentally put curly braces around the import?', moduleObject);
-        }
-      }
-
-      {
-        if (!('default' in moduleObject)) {
-          error('lazy: Expected the result of a dynamic imp' + 'ort() call. ' + 'Instead received: %s\n\nYour code should look like: \n  ' + // Break up imports to avoid accidentally parsing them as dependencies.
-          'const MyComponent = lazy(() => imp' + "ort('./MyComponent'))", moduleObject);
-        }
-      }
-
-      return moduleObject.default;
+      return payload._result;
     } else {
       throw payload._result;
     }
@@ -50882,7 +52641,7 @@
   function lazy(ctor) {
     var payload = {
       // We use these fields to store the result.
-      _status: Uninitialized,
+      _status: -1,
       _result: ctor
     };
     var lazyType = {
@@ -50968,15 +52727,9 @@
           return ownName;
         },
         set: function (name) {
-          ownName = name; // The inner component shouldn't inherit this display name in most cases,
-          // because the component may be used elsewhere.
-          // But it's nice for anonymous functions to inherit the name,
-          // so that our component-stack generation logic will display their frames.
-          // An anonymous function generally suggests a pattern like:
-          //   React.forwardRef((props, ref) => {...});
-          // This kind of inner function is not used elsewhere so the side effect is okay.
-
-          if (!render.name && !render.displayName) {
+          ownName = name;
+
+          if (render.displayName == null) {
             render.displayName = name;
           }
         }
@@ -50986,11 +52739,9 @@
     return elementType;
   }
 
-  var REACT_MODULE_REFERENCE;
+  // Filter certain DOM attributes (e.g. src, href) if their values are empty strings.
 
-  {
-    REACT_MODULE_REFERENCE = Symbol.for('react.module.reference');
-  }
+  var enableScopeAPI = false; // Experimental Create Event Handle API.
 
   function isValidElementType(type) {
     if (typeof type === 'string' || typeof type === 'function') {
@@ -50998,16 +52749,12 @@
     } // Note: typeof might be other than 'symbol' or 'number' (e.g. if it's a polyfill).
 
 
-    if (type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || enableDebugTracing  || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || enableLegacyHidden  || type === REACT_OFFSCREEN_TYPE || enableScopeAPI  || enableCacheElement  || enableTransitionTracing ) {
+    if (type === exports.Fragment || type === exports.Profiler || type === REACT_DEBUG_TRACING_MODE_TYPE || type === exports.StrictMode || type === exports.Suspense || type === REACT_SUSPENSE_LIST_TYPE || type === REACT_LEGACY_HIDDEN_TYPE || enableScopeAPI ) {
       return true;
     }
 
     if (typeof type === 'object' && type !== null) {
-      if (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || // This needs to include all possible module reference object
-      // types supported by any Flight configuration anywhere since
-      // we don't know which Flight build this will end up being used
-      // with.
-      type.$$typeof === REACT_MODULE_REFERENCE || type.getModuleId !== undefined) {
+      if (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_BLOCK_TYPE || type[0] === REACT_SERVER_BLOCK_TYPE) {
         return true;
       }
     }
@@ -51037,15 +52784,9 @@
           return ownName;
         },
         set: function (name) {
-          ownName = name; // The inner component shouldn't inherit this display name in most cases,
-          // because the component may be used elsewhere.
-          // But it's nice for anonymous functions to inherit the name,
-          // so that our component-stack generation logic will display their frames.
-          // An anonymous function generally suggests a pattern like:
-          //   React.memo((props) => {...});
-          // This kind of inner function is not used elsewhere so the side effect is okay.
-
-          if (!type.name && !type.displayName) {
+          ownName = name;
+
+          if (type.displayName == null) {
             type.displayName = name;
           }
         }
@@ -51058,22 +52799,24 @@
   function resolveDispatcher() {
     var dispatcher = ReactCurrentDispatcher.current;
 
-    {
-      if (dispatcher === null) {
-        error('Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for' + ' one of the following reasons:\n' + '1. You might have mismatching versions of React and the renderer (such as React DOM)\n' + '2. You might be breaking the Rules of Hooks\n' + '3. You might have more than one copy of React in the same app\n' + 'See https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.');
+    if (!(dispatcher !== null)) {
+      {
+        throw Error( "Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:\n1. You might have mismatching versions of React and the renderer (such as React DOM)\n2. You might be breaking the Rules of Hooks\n3. You might have more than one copy of React in the same app\nSee https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem." );
       }
-    } // Will result in a null access error if accessed outside render phase. We
-    // intentionally don't throw our own error because this is in a hot path.
-    // Also helps ensure this is inlined.
-
+    }
 
     return dispatcher;
   }
-  function useContext(Context) {
+
+  function useContext(Context, unstable_observedBits) {
     var dispatcher = resolveDispatcher();
 
     {
-      // TODO: add a more generic warning for invalid values.
+      if (unstable_observedBits !== undefined) {
+        error('useContext() second argument is reserved for future ' + 'use in React. Passing it is not supported. ' + 'You passed: %s.%s', unstable_observedBits, typeof unstable_observedBits === 'number' && Array.isArray(arguments[2]) ? '\n\nDid you call array.map(useContext)? ' + 'Calling Hooks inside a loop is not supported. ' + 'Learn more at https://reactjs.org/link/rules-of-hooks' : '');
+      } // TODO: add a more generic warning for invalid values.
+
+
       if (Context._context !== undefined) {
         var realContext = Context._context; // Don't deduplicate because this legitimately causes bugs
         // and nobody should be using this in existing code.
@@ -51086,7 +52829,7 @@
       }
     }
 
-    return dispatcher.useContext(Context);
+    return dispatcher.useContext(Context, unstable_observedBits);
   }
   function useState(initialState) {
     var dispatcher = resolveDispatcher();
@@ -51104,10 +52847,6 @@
     var dispatcher = resolveDispatcher();
     return dispatcher.useEffect(create, deps);
   }
-  function useInsertionEffect(create, deps) {
-    var dispatcher = resolveDispatcher();
-    return dispatcher.useInsertionEffect(create, deps);
-  }
   function useLayoutEffect(create, deps) {
     var dispatcher = resolveDispatcher();
     return dispatcher.useLayoutEffect(create, deps);
@@ -51130,22 +52869,6 @@
       return dispatcher.useDebugValue(value, formatterFn);
     }
   }
-  function useTransition() {
-    var dispatcher = resolveDispatcher();
-    return dispatcher.useTransition();
-  }
-  function useDeferredValue(value) {
-    var dispatcher = resolveDispatcher();
-    return dispatcher.useDeferredValue(value);
-  }
-  function useId() {
-    var dispatcher = resolveDispatcher();
-    return dispatcher.useId();
-  }
-  function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
-    var dispatcher = resolveDispatcher();
-    return dispatcher.useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
-  }
 
   // Helpers to patch console.logs to avoid logging during side-effect free
   // replaying on render function. This currently only patches the object
@@ -51210,25 +52933,25 @@
         }; // $FlowFixMe Flow thinks console is immutable.
 
         Object.defineProperties(console, {
-          log: assign({}, props, {
+          log: _assign({}, props, {
             value: prevLog
           }),
-          info: assign({}, props, {
+          info: _assign({}, props, {
             value: prevInfo
           }),
-          warn: assign({}, props, {
+          warn: _assign({}, props, {
             value: prevWarn
           }),
-          error: assign({}, props, {
+          error: _assign({}, props, {
             value: prevError
           }),
-          group: assign({}, props, {
+          group: _assign({}, props, {
             value: prevGroup
           }),
-          groupCollapsed: assign({}, props, {
+          groupCollapsed: _assign({}, props, {
             value: prevGroupCollapsed
           }),
-          groupEnd: assign({}, props, {
+          groupEnd: _assign({}, props, {
             value: prevGroupEnd
           })
         });
@@ -51269,7 +52992,7 @@
 
   function describeNativeComponentFrame(fn, construct) {
     // If something asked for a stack inside a fake render, it should get ignored.
-    if ( !fn || reentry) {
+    if (!fn || reentry) {
       return '';
     }
 
@@ -51378,14 +53101,7 @@
 
                 if (c < 0 || sampleLines[s] !== controlLines[c]) {
                   // V8 adds a "new" prefix for native classes. Let's remove it to make it prettier.
-                  var _frame = '\n' + sampleLines[s].replace(' at new ', ' at '); // If our component frame is labeled "<anonymous>"
-                  // but we have a user-provided "displayName"
-                  // splice it in to make the stack more readable.
-
-
-                  if (fn.displayName && _frame.includes('<anonymous>')) {
-                    _frame = _frame.replace('<anonymous>', fn.displayName);
-                  }
+                  var _frame = '\n' + sampleLines[s].replace(' at new ', ' at ');
 
                   {
                     if (typeof fn === 'function') {
@@ -51454,7 +53170,7 @@
     }
 
     switch (type) {
-      case REACT_SUSPENSE_TYPE:
+      case exports.Suspense:
         return describeBuiltInComponentFrame('Suspense');
 
       case REACT_SUSPENSE_LIST_TYPE:
@@ -51470,6 +53186,9 @@
           // Memo may contain any component type so we recursively resolve it.
           return describeUnknownElementTypeFrameInDEV(type.type);
 
+        case REACT_BLOCK_TYPE:
+          return describeFunctionComponentFrame(type._render);
+
         case REACT_LAZY_TYPE:
           {
             var lazyComponent = type;
@@ -51504,7 +53223,7 @@
   function checkPropTypes(typeSpecs, values, location, componentName, element) {
     {
       // $FlowFixMe This is okay but Flow doesn't know it.
-      var has = Function.call.bind(hasOwnProperty);
+      var has = Function.call.bind(Object.prototype.hasOwnProperty);
 
       for (var typeSpecName in typeSpecs) {
         if (has(typeSpecs, typeSpecName)) {
@@ -51516,7 +53235,6 @@
             // This is intentionally an invariant that gets caught. It's the same
             // behavior as without this statement except with a better message.
             if (typeof typeSpecs[typeSpecName] !== 'function') {
-              // eslint-disable-next-line react-internal/prod-error-codes
               var err = Error((componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' + 'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.' + 'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.');
               err.name = 'Invariant Violation';
               throw err;
@@ -51569,7 +53287,7 @@
 
   function getDeclarationErrorAddendum() {
     if (ReactCurrentOwner.current) {
-      var name = getComponentNameFromType(ReactCurrentOwner.current.type);
+      var name = getComponentName(ReactCurrentOwner.current.type);
 
       if (name) {
         return '\n\nCheck the render method of `' + name + '`.';
@@ -51651,7 +53369,7 @@
 
     if (element && element._owner && element._owner !== ReactCurrentOwner.current) {
       // Give the component that originally created this child.
-      childOwner = " It was passed a child from " + getComponentNameFromType(element._owner.type) + ".";
+      childOwner = " It was passed a child from " + getComponentName(element._owner.type) + ".";
     }
 
     {
@@ -51678,7 +53396,7 @@
       return;
     }
 
-    if (isArray(node)) {
+    if (Array.isArray(node)) {
       for (var i = 0; i < node.length; i++) {
         var child = node[i];
 
@@ -51740,12 +53458,12 @@
 
       if (propTypes) {
         // Intentionally inside to avoid triggering lazy initializers:
-        var name = getComponentNameFromType(type);
+        var name = getComponentName(type);
         checkPropTypes(propTypes, element.props, 'prop', name, element);
       } else if (type.PropTypes !== undefined && !propTypesMisspellWarningShown) {
         propTypesMisspellWarningShown = true; // Intentionally inside to avoid triggering lazy initializers:
 
-        var _name = getComponentNameFromType(type);
+        var _name = getComponentName(type);
 
         error('Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?', _name || 'Unknown');
       }
@@ -51810,10 +53528,10 @@
 
       if (type === null) {
         typeString = 'null';
-      } else if (isArray(type)) {
+      } else if (Array.isArray(type)) {
         typeString = 'array';
       } else if (type !== undefined && type.$$typeof === REACT_ELEMENT_TYPE) {
-        typeString = "<" + (getComponentNameFromType(type.type) || 'Unknown') + " />";
+        typeString = "<" + (getComponentName(type.type) || 'Unknown') + " />";
         info = ' Did you accidentally export a JSX literal instead of a component?';
       } else {
         typeString = typeof type;
@@ -51842,7 +53560,7 @@
       }
     }
 
-    if (type === REACT_FRAGMENT_TYPE) {
+    if (type === exports.Fragment) {
       validateFragmentProps(element);
     } else {
       validatePropTypes(element);
@@ -51889,263 +53607,12 @@
     return newElement;
   }
 
-  function startTransition(scope, options) {
-    var prevTransition = ReactCurrentBatchConfig.transition;
-    ReactCurrentBatchConfig.transition = {};
-    var currentTransition = ReactCurrentBatchConfig.transition;
-
-    {
-      ReactCurrentBatchConfig.transition._updatedFibers = new Set();
-    }
+  {
 
     try {
-      scope();
-    } finally {
-      ReactCurrentBatchConfig.transition = prevTransition;
-
-      {
-        if (prevTransition === null && currentTransition._updatedFibers) {
-          var updatedFibersCount = currentTransition._updatedFibers.size;
-
-          if (updatedFibersCount > 10) {
-            warn('Detected a large number of updates inside startTransition. ' + 'If this is due to a subscription please re-write it to use React provided hooks. ' + 'Otherwise concurrent mode guarantees are off the table.');
-          }
-
-          currentTransition._updatedFibers.clear();
-        }
-      }
-    }
-  }
-
-  var didWarnAboutMessageChannel = false;
-  var enqueueTaskImpl = null;
-  function enqueueTask(task) {
-    if (enqueueTaskImpl === null) {
-      try {
-        // read require off the module object to get around the bundlers.
-        // we don't want them to detect a require and bundle a Node polyfill.
-        var requireString = ('require' + Math.random()).slice(0, 7);
-        var nodeRequire = module && module[requireString]; // assuming we're in node, let's try to get node's
-        // version of setImmediate, bypassing fake timers if any.
-
-        enqueueTaskImpl = nodeRequire.call(module, 'timers').setImmediate;
-      } catch (_err) {
-        // we're in a browser
-        // we can't use regular timers because they may still be faked
-        // so we try MessageChannel+postMessage instead
-        enqueueTaskImpl = function (callback) {
-          {
-            if (didWarnAboutMessageChannel === false) {
-              didWarnAboutMessageChannel = true;
-
-              if (typeof MessageChannel === 'undefined') {
-                error('This browser does not have a MessageChannel implementation, ' + 'so enqueuing tasks via await act(async () => ...) will fail. ' + 'Please file an issue at https://github.com/facebook/react/issues ' + 'if you encounter this warning.');
-              }
-            }
-          }
-
-          var channel = new MessageChannel();
-          channel.port1.onmessage = callback;
-          channel.port2.postMessage(undefined);
-        };
-      }
-    }
-
-    return enqueueTaskImpl(task);
-  }
-
-  var actScopeDepth = 0;
-  var didWarnNoAwaitAct = false;
-  function act(callback) {
-    {
-      // `act` calls can be nested, so we track the depth. This represents the
-      // number of `act` scopes on the stack.
-      var prevActScopeDepth = actScopeDepth;
-      actScopeDepth++;
-
-      if (ReactCurrentActQueue.current === null) {
-        // This is the outermost `act` scope. Initialize the queue. The reconciler
-        // will detect the queue and use it instead of Scheduler.
-        ReactCurrentActQueue.current = [];
-      }
-
-      var prevIsBatchingLegacy = ReactCurrentActQueue.isBatchingLegacy;
-      var result;
-
-      try {
-        // Used to reproduce behavior of `batchedUpdates` in legacy mode. Only
-        // set to `true` while the given callback is executed, not for updates
-        // triggered during an async event, because this is how the legacy
-        // implementation of `act` behaved.
-        ReactCurrentActQueue.isBatchingLegacy = true;
-        result = callback(); // Replicate behavior of original `act` implementation in legacy mode,
-        // which flushed updates immediately after the scope function exits, even
-        // if it's an async function.
-
-        if (!prevIsBatchingLegacy && ReactCurrentActQueue.didScheduleLegacyUpdate) {
-          var queue = ReactCurrentActQueue.current;
-
-          if (queue !== null) {
-            ReactCurrentActQueue.didScheduleLegacyUpdate = false;
-            flushActQueue(queue);
-          }
-        }
-      } catch (error) {
-        popActScope(prevActScopeDepth);
-        throw error;
-      } finally {
-        ReactCurrentActQueue.isBatchingLegacy = prevIsBatchingLegacy;
-      }
-
-      if (result !== null && typeof result === 'object' && typeof result.then === 'function') {
-        var thenableResult = result; // The callback is an async function (i.e. returned a promise). Wait
-        // for it to resolve before exiting the current scope.
-
-        var wasAwaited = false;
-        var thenable = {
-          then: function (resolve, reject) {
-            wasAwaited = true;
-            thenableResult.then(function (returnValue) {
-              popActScope(prevActScopeDepth);
-
-              if (actScopeDepth === 0) {
-                // We've exited the outermost act scope. Recursively flush the
-                // queue until there's no remaining work.
-                recursivelyFlushAsyncActWork(returnValue, resolve, reject);
-              } else {
-                resolve(returnValue);
-              }
-            }, function (error) {
-              // The callback threw an error.
-              popActScope(prevActScopeDepth);
-              reject(error);
-            });
-          }
-        };
-
-        {
-          if (!didWarnNoAwaitAct && typeof Promise !== 'undefined') {
-            // eslint-disable-next-line no-undef
-            Promise.resolve().then(function () {}).then(function () {
-              if (!wasAwaited) {
-                didWarnNoAwaitAct = true;
-
-                error('You called act(async () => ...) without await. ' + 'This could lead to unexpected testing behaviour, ' + 'interleaving multiple act calls and mixing their ' + 'scopes. ' + 'You should - await act(async () => ...);');
-              }
-            });
-          }
-        }
-
-        return thenable;
-      } else {
-        var returnValue = result; // The callback is not an async function. Exit the current scope
-        // immediately, without awaiting.
-
-        popActScope(prevActScopeDepth);
-
-        if (actScopeDepth === 0) {
-          // Exiting the outermost act scope. Flush the queue.
-          var _queue = ReactCurrentActQueue.current;
-
-          if (_queue !== null) {
-            flushActQueue(_queue);
-            ReactCurrentActQueue.current = null;
-          } // Return a thenable. If the user awaits it, we'll flush again in
-          // case additional work was scheduled by a microtask.
-
-
-          var _thenable = {
-            then: function (resolve, reject) {
-              // Confirm we haven't re-entered another `act` scope, in case
-              // the user does something weird like await the thenable
-              // multiple times.
-              if (ReactCurrentActQueue.current === null) {
-                // Recursively flush the queue until there's no remaining work.
-                ReactCurrentActQueue.current = [];
-                recursivelyFlushAsyncActWork(returnValue, resolve, reject);
-              } else {
-                resolve(returnValue);
-              }
-            }
-          };
-          return _thenable;
-        } else {
-          // Since we're inside a nested `act` scope, the returned thenable
-          // immediately resolves. The outer scope will flush the queue.
-          var _thenable2 = {
-            then: function (resolve, reject) {
-              resolve(returnValue);
-            }
-          };
-          return _thenable2;
-        }
-      }
-    }
-  }
-
-  function popActScope(prevActScopeDepth) {
-    {
-      if (prevActScopeDepth !== actScopeDepth - 1) {
-        error('You seem to have overlapping act() calls, this is not supported. ' + 'Be sure to await previous act() calls before making a new one. ');
-      }
-
-      actScopeDepth = prevActScopeDepth;
-    }
-  }
-
-  function recursivelyFlushAsyncActWork(returnValue, resolve, reject) {
-    {
-      var queue = ReactCurrentActQueue.current;
-
-      if (queue !== null) {
-        try {
-          flushActQueue(queue);
-          enqueueTask(function () {
-            if (queue.length === 0) {
-              // No additional work was scheduled. Finish.
-              ReactCurrentActQueue.current = null;
-              resolve(returnValue);
-            } else {
-              // Keep flushing work until there's none left.
-              recursivelyFlushAsyncActWork(returnValue, resolve, reject);
-            }
-          });
-        } catch (error) {
-          reject(error);
-        }
-      } else {
-        resolve(returnValue);
-      }
-    }
-  }
-
-  var isFlushing = false;
-
-  function flushActQueue(queue) {
-    {
-      if (!isFlushing) {
-        // Prevent re-entrance.
-        isFlushing = true;
-        var i = 0;
-
-        try {
-          for (; i < queue.length; i++) {
-            var callback = queue[i];
-
-            do {
-              callback = callback(true);
-            } while (callback !== null);
-          }
-
-          queue.length = 0;
-        } catch (error) {
-          // If something throws, leave the remaining callbacks on the queue.
-          queue = queue.slice(i + 1);
-          throw error;
-        } finally {
-          isFlushing = false;
-        }
-      }
+      Object.freeze({});
+      /* eslint-enable no-new */
+    } catch (e) {
     }
   }
 
@@ -52162,11 +53629,7 @@
 
   exports.Children = Children;
   exports.Component = Component;
-  exports.Fragment = REACT_FRAGMENT_TYPE;
-  exports.Profiler = REACT_PROFILER_TYPE;
   exports.PureComponent = PureComponent;
-  exports.StrictMode = REACT_STRICT_MODE_TYPE;
-  exports.Suspense = REACT_SUSPENSE_TYPE;
   exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = ReactSharedInternals;
   exports.cloneElement = cloneElement$1;
   exports.createContext = createContext;
@@ -52177,33 +53640,17 @@
   exports.isValidElement = isValidElement;
   exports.lazy = lazy;
   exports.memo = memo;
-  exports.startTransition = startTransition;
-  exports.unstable_act = act;
   exports.useCallback = useCallback;
   exports.useContext = useContext;
   exports.useDebugValue = useDebugValue;
-  exports.useDeferredValue = useDeferredValue;
   exports.useEffect = useEffect;
-  exports.useId = useId;
   exports.useImperativeHandle = useImperativeHandle;
-  exports.useInsertionEffect = useInsertionEffect;
   exports.useLayoutEffect = useLayoutEffect;
   exports.useMemo = useMemo;
   exports.useReducer = useReducer;
   exports.useRef = useRef;
   exports.useState = useState;
-  exports.useSyncExternalStore = useSyncExternalStore;
-  exports.useTransition = useTransition;
   exports.version = ReactVersion;
-            /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
-  if (
-    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
-    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop ===
-      'function'
-  ) {
-    __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
-  }
-          
     })();
   }
   });
@@ -52225,6 +53672,7 @@
   function createLiveReact(options) {
       const LiveContext = React.createContext(null);
       const live = createLive(options);
+      const jsBridge = live.jsBridge;
       function LiveProvider(props) {
           return (React.createElement(LiveContext.Provider, { value: props.live || live }, props.children));
       }
@@ -52420,6 +53868,7 @@
       }
       return {
           live,
+          jsBridge,
           LiveProvider,
           unsafe__useLiveInstance,
           unsafe__useRTCInstance,