@realsee/live 0.3.0-alpha.3 → 0.4.0-alpha.2

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

@@ -0,0 +1,4630 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var amazonChimeSdkJs = require('amazon-chime-sdk-js');
+var TRTC = require('trtc-js-sdk');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var TRTC__default = /*#__PURE__*/_interopDefaultLegacy(TRTC);
+
+const EVENT_SYMBOL = Symbol('$$REALSEE_LIVE_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 (let 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;
+    }
+}
+
+/**
+ * rtc 基础抽象类
+ */
+class CoreRTC extends Subscribe {
+}
+
+/**
+ * rtc 类型
+ */
+exports.RTCType = void 0;
+(function (RTCType) {
+    RTCType["RealseeBrowserRTC"] = "RealseeBrowserRTC";
+    RTCType["RealseeVRWebViewRTC"] = "RealseeVRWebViewRTC";
+    RTCType["RealseeBrowserChimeRTC"] = "RealseeBrowserChimeRTC";
+})(exports.RTCType || (exports.RTCType = {}));
+
+// 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();
+}
+
+class BrowserRTC extends CoreRTC {
+    constructor(options) {
+        super();
+        this.type = exports.RTCType.RealseeBrowserRTC;
+        this.joined = false;
+        this.micro = false;
+        this.voiceId = '';
+        this._getVoiceSign = () => {
+            throw new Error('方法 getVoiceSign 未实现');
+        };
+        this.$dom = document.createElement('div');
+        this._trtc = {
+            client: null,
+            stream: null,
+        };
+        this.join = async (options) => {
+            var _a;
+            this.emit('joinWillStart');
+            const createClientOptions = await this._getVoiceSign({
+                voiceId: options.voiceId,
+                roomId: options.roomId,
+                userId: options.userId,
+            });
+            // 1.  创建client
+            this._trtc.client = TRTC__default["default"].createClient({
+                mode: 'rtc',
+                ...createClientOptions,
+            });
+            (_a = this._trtc.client) === null || _a === void 0 ? void 0 : _a.enableAudioVolumeEvaluation();
+            // 2. 订阅事件
+            this._registerRtcEvent();
+            // 3. 加入语音房间
+            let result = await new Promise((resolve) => {
+                var _a;
+                (_a = this._trtc.client) === null || _a === void 0 ? void 0 : _a.join({ roomId: Number(options.voiceId) }).then(() => resolve(true)).catch(() => resolve(false));
+            });
+            this.joined = result;
+            if (!result)
+                return false; // 进房失败
+            // 4. 创建本地流
+            this._trtc.stream = TRTC__default["default"].createStream({
+                userId: createClientOptions.userId,
+                audio: true,
+                video: false,
+            });
+            // 5. 初始化本地流
+            result = await new Promise((resolve) => {
+                var _a;
+                (_a = this._trtc.stream) === null || _a === void 0 ? void 0 : _a.initialize().then(() => resolve(true)).catch(() => resolve(false));
+            });
+            // 6. 发布本地流
+            result = await new Promise((resolve) => {
+                var _a;
+                (_a = this._trtc.client) === null || _a === void 0 ? void 0 : _a.publish(this._trtc.stream).then(() => resolve(true)).catch(() => resolve(false));
+            });
+            this.joined = result;
+            if (this.joined)
+                this.emit('joined');
+            return result;
+        };
+        this._handleStreamAdded = (event) => {
+            var _a;
+            const remoteStream = event.stream;
+            console.log('远端流增加: ' + remoteStream.getId());
+            //订阅远端流
+            (_a = this._trtc.client) === null || _a === void 0 ? void 0 : _a.subscribe(remoteStream);
+        };
+        this._handleStreamSubscribed = (event) => {
+            const remoteStream = event.stream;
+            console.log('远端流订阅成功：' + remoteStream.getId());
+            const playId = remoteStream.getId();
+            const domId = `rs-rtc-remote_stream-${playId}`;
+            const dom = document.createElement('div');
+            dom.id = domId;
+            this.$dom.appendChild(dom);
+            // 播放远端流
+            remoteStream.play(domId);
+        };
+        this._getVoiceSign = options.getVoiceSign;
+        this._initParentDom();
+    }
+    _initParentDom() {
+        this.$dom.id = `rs-rtc-${uuid()}`;
+        this.$dom.style.display = 'none';
+        document.body.appendChild(this.$dom);
+    }
+    quit() {
+        return new Promise(async (resolve) => {
+            var _a, _b;
+            this.joined = false;
+            if (this._trtc.stream) {
+                await ((_a = this._trtc.client) === null || _a === void 0 ? void 0 : _a.unpublish(this._trtc.stream));
+                this._trtc.stream.stop();
+                this._trtc.stream.close();
+                this._trtc.stream = null;
+            }
+            (_b = this._trtc.client) === null || _b === void 0 ? void 0 : _b.leave().then(() => (this._trtc.client = null)).then(() => resolve(true)).catch(() => resolve(false));
+        });
+    }
+    detectMicro() {
+        return new Promise((resolve) => {
+            const rule = { audio: true, video: false };
+            try {
+                navigator.mediaDevices
+                    .getUserMedia(rule)
+                    .then(() => resolve(true))
+                    .catch(() => resolve(false));
+            }
+            catch (e) {
+                console.error(e);
+                resolve(false);
+            }
+        });
+    }
+    toggleMicro(flag) {
+        var _a, _b, _c, _d;
+        return Promise.resolve((flag
+            ? (_b = (_a = this._trtc) === null || _a === void 0 ? void 0 : _a.stream) === null || _b === void 0 ? void 0 : _b.unmuteAudio()
+            : (_d = (_c = this._trtc) === null || _c === void 0 ? void 0 : _c.stream) === null || _d === void 0 ? void 0 : _d.muteAudio()) || false);
+    }
+    shock() {
+        throw new Error('Method not implemented.');
+    }
+    _registerRtcEvent() {
+        var _a, _b, _c, _d;
+        (_a = this._trtc.client) === null || _a === void 0 ? void 0 : _a.on('stream-added', this._handleStreamAdded);
+        (_b = this._trtc.client) === null || _b === void 0 ? void 0 : _b.on('stream-subscribed', this._handleStreamSubscribed);
+        (_c = this._trtc.client) === null || _c === void 0 ? void 0 : _c.on('audio-volume', (event) => this.emit('userVolumes', [
+            { userId: event.userId, audioVolume: event.audioVolume },
+        ]));
+        (_d = this._trtc.client) === null || _d === void 0 ? void 0 : _d.on('error', (event) => this.emit('error', event));
+    }
+}
+
+/**
+ * amazon-chime-sdk-js 适配的rtc实现
+ */
+class BrowserRTC4Chime extends CoreRTC {
+    constructor(options) {
+        super();
+        this.type = exports.RTCType.RealseeBrowserChimeRTC;
+        this.joined = false;
+        this.micro = false;
+        this.voiceId = '';
+        this.userId = '';
+        this.deviceChangeObserver = {};
+        this.audioVideoObserver = {};
+        this._getVoiceSign = () => {
+            throw new Error('方法 getVoiceSign 未实现');
+        };
+        this.$dom = document.createElement('div');
+        this.$audio = document.createElement('audio');
+        /**
+         * 对audio标签初始化
+         */
+        this._initDom = () => {
+            this.$audio.id = `rs-rtc-${uuid()}`;
+            this.$dom.id = `rs-rtc-${uuid()}`;
+            this.$dom.appendChild(this.$audio);
+            document.body.appendChild(this.$dom);
+        };
+        /**
+         * 初始化事件监听器
+         */
+        this.initObservers = () => {
+            // 输入输出设备变化的监听器
+            this.deviceChangeObserver = {
+                audioInputsChanged: (freshAudioInputDeviceList) => {
+                    // An array of MediaDeviceInfo objects
+                    freshAudioInputDeviceList === null || freshAudioInputDeviceList === void 0 ? void 0 : freshAudioInputDeviceList.forEach((mediaDeviceInfo) => {
+                        this.logger.info(`Device ID: ${mediaDeviceInfo.deviceId} Microphone: ${mediaDeviceInfo.label}`);
+                    });
+                },
+                audioOutputsChanged: (freshAudioOutputDeviceList) => {
+                    this.logger.info(`Audio outputs updated: ${freshAudioOutputDeviceList}`);
+                },
+                videoInputsChanged: (freshVideoInputDeviceList) => {
+                    this.logger.info(`Video inputs updated: ${freshVideoInputDeviceList}`);
+                },
+                audioInputMuteStateChanged: (device, muted) => {
+                    this.logger.info(`Device ${device.toString()}  ${muted ? 'is muted in hardware' : 'is not muted'}`);
+                },
+            };
+            // 流变化监听器
+            this.audioVideoObserver = {
+                audioVideoDidStart: () => {
+                    this.logger.info('Started');
+                },
+                audioVideoDidStop: (sessionStatus) => {
+                    // See the "Stopping a session" section for details.
+                    this.logger.info(`Stopped with a session status code: ${sessionStatus.statusCode()}`);
+                },
+                audioVideoDidStartConnecting: (reconnecting) => {
+                    if (reconnecting) {
+                        // e.g. the WiFi connection is dropped.
+                        this.logger.info('Attempting to reconnect');
+                    }
+                },
+            };
+        };
+        /**
+         * 注册rtc事件
+         */
+        this._registerRtcEvent = () => {
+            var _a, _b, _c, _d, _e, _f;
+            const presentAttendeeId = ((_c = (_b = (_a = this.meetingSession) === null || _a === void 0 ? void 0 : _a.configuration) === null || _b === void 0 ? void 0 : _b.credentials) === null || _c === void 0 ? void 0 : _c.attendeeId) || '';
+            if (presentAttendeeId) {
+                // 处理音量变化
+                const roster = new Map();
+                const getUserVolumes = () => {
+                    const result = [];
+                    roster.forEach((v, k) => {
+                        result.push({
+                            userId: v.userId,
+                            volume: v.muted || v.signalStrength === 0 || !Boolean(v.volume)
+                                ? 0
+                                : v.volume,
+                        });
+                    });
+                    return result;
+                };
+                (_d = this.meetingSession) === null || _d === void 0 ? void 0 : _d.audioVideo.realtimeSubscribeToAttendeeIdPresence((presentAttendeeId, present, externalUserId) => {
+                    var _a;
+                    if (!present) {
+                        roster.delete(presentAttendeeId);
+                        this.emit('userVolumes', getUserVolumes());
+                        return;
+                    }
+                    (_a = this.meetingSession) === null || _a === void 0 ? void 0 : _a.audioVideo.realtimeSubscribeToVolumeIndicator(presentAttendeeId, (attendeeId, volume, muted, signalStrength) => {
+                        const baseAttendeeId = new amazonChimeSdkJs.DefaultModality(attendeeId).base();
+                        if (baseAttendeeId !== attendeeId) {
+                            // Optional: Do not include the content attendee (attendee-id#content) in the roster.
+                            // See the "Screen and content share" section for details.
+                            return;
+                        }
+                        roster.set(attendeeId, {
+                            userId: externalUserId || attendeeId,
+                            volume,
+                            muted,
+                            signalStrength,
+                        });
+                        this.emit('userVolumes', getUserVolumes());
+                    });
+                });
+                // 弱网
+                (_e = this.meetingSession) === null || _e === void 0 ? void 0 : _e.audioVideo.realtimeSubscribeToVolumeIndicator(presentAttendeeId, (attendeeId, volume, muted, signalStrength) => {
+                    const baseAttendeeId = new amazonChimeSdkJs.DefaultModality(attendeeId).base();
+                    if (baseAttendeeId === attendeeId) {
+                        if (signalStrength !== null && signalStrength !== 1) {
+                            this.emit('weakNetwork');
+                        }
+                    }
+                });
+                // 报错
+                (_f = this.meetingSession) === null || _f === void 0 ? void 0 : _f.audioVideo.realtimeSubscribeToFatalError((error) => this.emit('error', error));
+            }
+        };
+        // 挂载签名钩子
+        this._getVoiceSign = options.getVoiceSign;
+        this._initDom();
+        this.logger = new amazonChimeSdkJs.ConsoleLogger('WebRTCLogger', options.logLevel || amazonChimeSdkJs.LogLevel.OFF);
+        this.deviceController = new amazonChimeSdkJs.DefaultDeviceController(this.logger);
+        this.initObservers();
+    }
+    /**
+     * 加入语音会议
+     * @param options
+     * @returns
+     */
+    async join(options) {
+        return new Promise(async (success, fail) => {
+            var _a;
+            this.emit('joinWillStart');
+            try {
+                // 取签名
+                const { sdkAppId, userId, roomId, userSig } = await this._getVoiceSign({
+                    ...options,
+                    roomId: options.roomId || 0,
+                });
+                this.userId = userId;
+                const { attendence, vendor_wrapper, } = JSON.parse(decodeURIComponent(userSig));
+                // 初始化配置
+                const configuration = new amazonChimeSdkJs.MeetingSessionConfiguration({
+                    Meeting: vendor_wrapper,
+                }, {
+                    Attendee: {
+                        ExternalUserId: attendence.external_user_id,
+                        AttendeeId: attendence.attendee_id,
+                        JoinToken: attendence.join_token,
+                    },
+                });
+                // 初始化会议会话
+                this.meetingSession = new amazonChimeSdkJs.DefaultMeetingSession(configuration, this.logger, this.deviceController);
+                // 注册事件
+                this._registerRtcEvent();
+                // 绑定监听器
+                this.meetingSession.audioVideo.addDeviceChangeObserver(this.deviceChangeObserver);
+                this.meetingSession.audioVideo.addObserver(this.audioVideoObserver);
+                // 绑定播放器
+                this.meetingSession.audioVideo.bindAudioElement(this.$audio);
+                const observer = {
+                    audioVideoDidStart: () => {
+                        var _a;
+                        (_a = this.meetingSession) === null || _a === void 0 ? void 0 : _a.audioVideo.realtimeMuteLocalAudio();
+                        this.joined = true;
+                        this.emit('joined');
+                        success(true);
+                    },
+                    audioVideoDidStop: () => {
+                        this.joined = false;
+                        success(false);
+                    },
+                };
+                this.meetingSession.audioVideo.addObserver(observer);
+                // 选择语音输入设备
+                const audioInputDevices = await this.deviceController.listAudioInputDevices(true);
+                const defaultAudioInput = audioInputDevices.find((device) => device.deviceId === 'default');
+                const otherAudioInput = audioInputDevices.find((device) => device.deviceId !== '');
+                this.audioInput = defaultAudioInput || otherAudioInput;
+                await this.meetingSession.audioVideo.chooseVideoInputDevice(null);
+                await this.meetingSession.audioVideo.chooseAudioInputDevice(((_a = this.audioInput) === null || _a === void 0 ? void 0 : _a.deviceId) || 'default');
+                this.meetingSession.audioVideo.start();
+            }
+            catch (e) {
+                this.emit('error', e);
+                this.logger.error(e.message);
+                success(false);
+            }
+        });
+    }
+    quit() {
+        return new Promise((success, fail) => {
+            var _a, _b;
+            this.joined = false;
+            const observer = {
+                audioVideoDidStop: (sessionStatus) => {
+                    const sessionStatusCode = sessionStatus.statusCode();
+                    if (sessionStatusCode === amazonChimeSdkJs.MeetingSessionStatusCode.Left) {
+                        /*
+                          - You called meetingSession.audioVideo.stop().
+                          - When closing a browser window or page, Chime SDK attempts to leave the session.
+                        */
+                        this.logger.info('You left the session');
+                        success(true);
+                    }
+                    else {
+                        this.logger.info(`Stopped with a session status code: ${sessionStatusCode}`);
+                        success(true);
+                    }
+                },
+            };
+            (_a = this.meetingSession) === null || _a === void 0 ? void 0 : _a.audioVideo.addObserver(observer);
+            (_b = this.meetingSession) === null || _b === void 0 ? void 0 : _b.audioVideo.stop();
+        });
+    }
+    async detectMicro() {
+        return new Promise((resolve) => {
+            const rule = { audio: true, video: false };
+            try {
+                navigator.mediaDevices
+                    .getUserMedia(rule)
+                    .then(() => resolve(true))
+                    .catch(() => resolve(false));
+            }
+            catch (e) {
+                this.logger.error(e.message);
+                resolve(false);
+            }
+        });
+    }
+    async toggleMicro(flag) {
+        var _a, _b, _c;
+        if (flag) {
+            (_a = this.meetingSession) === null || _a === void 0 ? void 0 : _a.audioVideo.realtimeUnmuteLocalAudio();
+        }
+        else {
+            (_b = this.meetingSession) === null || _b === void 0 ? void 0 : _b.audioVideo.realtimeMuteLocalAudio();
+        }
+        const muted = (_c = this.meetingSession) === null || _c === void 0 ? void 0 : _c.audioVideo.realtimeIsLocalAudioMuted();
+        if (muted !== undefined) {
+            return flag !== muted;
+        }
+        else {
+            return false;
+        }
+    }
+    shock() {
+        throw new Error('Method not implemented.');
+    }
+}
+
+/**
+ * rtc加入返回值code枚举
+ */
+exports.RTCJoinedInfoCodeEnum = void 0;
+(function (RTCJoinedInfoCodeEnum) {
+    /**
+     * 成功
+     */
+    RTCJoinedInfoCodeEnum[RTCJoinedInfoCodeEnum["Success"] = 0] = "Success";
+    /**
+     * 失败
+     */
+    RTCJoinedInfoCodeEnum[RTCJoinedInfoCodeEnum["Failure"] = 1] = "Failure";
+    /**
+     * 重复加入
+     */
+    RTCJoinedInfoCodeEnum[RTCJoinedInfoCodeEnum["ReJoin"] = 2] = "ReJoin";
+    /**
+     * 无麦克风权限
+     */
+    RTCJoinedInfoCodeEnum[RTCJoinedInfoCodeEnum["NoMicroPermission"] = 3] = "NoMicroPermission";
+})(exports.RTCJoinedInfoCodeEnum || (exports.RTCJoinedInfoCodeEnum = {}));
+
+class VRWebViewRTC extends CoreRTC {
+    constructor({ jsBridge, getVoiceSign }) {
+        super();
+        this.type = exports.RTCType.RealseeVRWebViewRTC;
+        this.joined = false;
+        this.micro = false;
+        this.voiceId = '';
+        this.options = { jsBridge, getVoiceSign };
+        this.jsBridge.callAndListen('live/userVolumes', (userVolumes) => {
+            this.emit('userVolumes', userVolumes);
+        });
+        this.jsBridge.callAndListen('live/weakNetwork', (weakNetwork) => {
+            if (weakNetwork)
+                this.emit('weakNetwork');
+        });
+    }
+    get jsBridge() {
+        return this.options.jsBridge;
+    }
+    async join(options) {
+        this.emit('joinWillStart');
+        const { sdkAppId, userId, userSig } = await this.options.getVoiceSign(options);
+        this.type = options.type;
+        const [res, error] = await this.jsBridge.callAndBackfeed(`live/join?sdkAppID=${sdkAppId}&userID=${userId}&roomID=${Number(options.voiceId)}&userSig=${userSig}`);
+        if (!res) {
+            this.emit('error', error ? error : new Error('加入房间失败：未知异常。'));
+            this.joined = false;
+        }
+        else {
+            if (res.code === exports.RTCJoinedInfoCodeEnum.Success) {
+                this.emit('joined');
+                this.joined = true;
+            }
+            else {
+                this.emit('error', res);
+                this.joined = false;
+            }
+        }
+        return this.joined;
+    }
+    async quit() {
+        const [res, error] = await this.jsBridge.callAndBackfeed('live/quit');
+        if (res === null) {
+            this.emit('error', error ? error : new Error('退出房间失败：未知异常。'));
+        }
+        this.joined = false;
+        return !!res;
+    }
+    async detectMicro() {
+        const [res, error] = await this.jsBridge.detectMicro();
+        if (res === null) {
+            this.emit('error', error ? error : new Error('麦克风监测异常！'));
+            return false;
+        }
+        return res;
+    }
+    async toggleMicro(flag) {
+        const [res, error] = await this.jsBridge.callAndBackfeed(`live/toggleMicro?flag=${!!flag ? 1 : 0}`);
+        if (res === null) {
+            this.emit('error', error ? error : new Error('麦克风监测异常！'));
+            return false;
+        }
+        this.micro = res;
+        return res;
+    }
+    shock() {
+        this.jsBridge.shock(1);
+    }
+}
+
+/**
+ * WebSocket 通信指令
+ * - 下行：服务端推送数据
+ * - 上行：客户端上报数据
+ */
+exports.Command = void 0;
+(function (Command) {
+    /* 当前用户信息：下行 */
+    Command["SelfUserInfo"] = "SELF_USER_INFO";
+    /* 房间信息：下行 */
+    Command["RoomInfo"] = "ROOM_INFO";
+    /* RTC信息：下行 */
+    Command["RTCInfo"] = "RTC_INFO";
+    /* 用户列表：下行 */
+    Command["UserList"] = "USER_LIST";
+    /* 内置消息：下行、上行 */
+    Command["BuiltinMsg"] = "BUILTIN_MSG";
+    /* 自定义广播事件消息：下行、上行 */
+    Command["CustomEvent"] = "CUSTOM_EVENT";
+    /* 帧数据同步：下行、上行 */
+    Command["KeyframeSync"] = "KEYFRAME_SYNC";
+    /* 被踢出房间：下行 */
+    Command["UserKickOut"] = "USER_KICK_OUT";
+})(exports.Command || (exports.Command = {}));
+/**
+ * 内置事件类型。
+ */
+exports.BuiltinEventType = void 0;
+(function (BuiltinEventType) {
+    /**
+     * 变更用户状态。
+     */
+    BuiltinEventType["UserChange"] = "user_change";
+    /**
+     * 变更房间状态。
+     */
+    BuiltinEventType["RoomChange"] = "room_change";
+})(exports.BuiltinEventType || (exports.BuiltinEventType = {}));
+/**
+ * 内置事件行为类型。
+ */
+exports.BuiltinActionType = void 0;
+(function (BuiltinActionType) {
+    /**
+     * 修改麦克风状态。
+     */
+    BuiltinActionType["UserMicroStatus"] = "change_micro_status";
+    /**
+     * 同步当前用户状态：客户端麦克风状态已经修改成功，通知服务端
+     */
+    BuiltinActionType["UserMicroStatusSync"] = "sync_micro_status";
+    /**
+     * 调整某些用户的权限。
+     */
+    BuiltinActionType["UserPermission"] = "change_permission";
+    /**
+     * 用户状态发生改变。
+     */
+    BuiltinActionType["UserStatus"] = "change_status";
+    /**
+     * 更新用户信息。
+     */
+    BuiltinActionType["UserInfo"] = "change_info";
+    /**
+     * 关闭房间。
+     */
+    BuiltinActionType["RoomClose"] = "close";
+})(exports.BuiltinActionType || (exports.BuiltinActionType = {}));
+/**
+ * 麦克风状态。
+ */
+exports.MicroStatus = void 0;
+(function (MicroStatus) {
+    MicroStatus["OPEN"] = "OPEN";
+    MicroStatus["CLOSE"] = "CLOSE";
+})(exports.MicroStatus || (exports.MicroStatus = {}));
+/**
+ * 解析下后端数据格式。
+ * @param jsonTxt - JSON序列化后的文本。
+ * @returns false 标识解析失败；解析成功返回 {@link LiveMsg} 实例。
+ */
+function parseLiveMsg(jsonTxt) {
+    try {
+        const msg = JSON.parse(jsonTxt);
+        const resMsg = {
+            code: msg.code,
+            message: msg.message,
+            command: msg.command,
+            roomCode: msg.room_code,
+            appID: msg.app_id,
+            requestId: msg.request_id,
+            frontRequestId: msg.front_request_id,
+            triggerUserID: msg.trigger_user_id,
+            data: msg.data || {},
+        };
+        const undefinedKeys = Object.keys(resMsg).filter((key) => resMsg[key] === undefined);
+        if (undefinedKeys.length > 0) {
+            console.warn(`推送数据格式异常：${undefinedKeys.join(" ")} 值不存在！`);
+        }
+        return resMsg;
+    }
+    catch (error) {
+        // notcare? 过滤掉所有不符合规范的数据
+        return false;
+    }
+}
+
+/**
+ * 用户当前状态枚举。
+ */
+exports.UserStatus = void 0;
+(function (UserStatus) {
+    /**
+     * 正常
+     */
+    UserStatus[UserStatus["Normal"] = 0] = "Normal";
+    /**
+     * 被移除
+     */
+    UserStatus[UserStatus["Removed"] = 1] = "Removed";
+    /**
+     * 被替换
+     */
+    UserStatus[UserStatus["Replaced"] = 2] = "Replaced";
+})(exports.UserStatus || (exports.UserStatus = {}));
+exports.MemUserStatus = void 0;
+(function (MemUserStatus) {
+    MemUserStatus["WAIT_ENTER"] = "WAIT_ENTER";
+    MemUserStatus["ONLINE"] = "ONLINE";
+    MemUserStatus["LEAVE"] = "LEAVE";
+    MemUserStatus["KICK_OUT"] = "KICK_OUT";
+    MemUserStatus["BE_REPLACE"] = "BE_REPLACE";
+    MemUserStatus["EXCEPTION"] = "EXCEPTION";
+})(exports.MemUserStatus || (exports.MemUserStatus = {}));
+
+/**
+ * WebSocket 连接状态枚举
+ */
+exports.WebSocketState = void 0;
+(function (WebSocketState) {
+    /**
+     * 尚未初始化
+     */
+    WebSocketState[WebSocketState["NOTINITIALIZED"] = -1] = "NOTINITIALIZED";
+    /**
+     * 正在链接中
+     */
+    WebSocketState[WebSocketState["CONNECTING"] = 0] = "CONNECTING";
+    /**
+     * 已经链接并且可以通讯
+     */
+    WebSocketState[WebSocketState["OPEN"] = 1] = "OPEN";
+    /**
+     * 连接正在关闭
+     */
+    WebSocketState[WebSocketState["CLOSING"] = 2] = "CLOSING";
+    /**
+     * 连接已关闭或者没有链接成功
+     */
+    WebSocketState[WebSocketState["CLOSED"] = 3] = "CLOSED";
+})(exports.WebSocketState || (exports.WebSocketState = {}));
+exports.WebSocketErrorType = void 0;
+(function (WebSocketErrorType) {
+    WebSocketErrorType["Error"] = "Error";
+    WebSocketErrorType["Close"] = "Close";
+    WebSocketErrorType["MicroAuth"] = "MicroAuth";
+    WebSocketErrorType["DuplicateConnect"] = "DuplicateConnect";
+    WebSocketErrorType["IllegalURL"] = "IllegalURL";
+    WebSocketErrorType["Unknown"] = "Unknown";
+    WebSocketErrorType["IllegalArgs"] = "IllegalArgs";
+})(exports.WebSocketErrorType || (exports.WebSocketErrorType = {}));
+/**
+ * WebSocket 异常关闭枚举：https://developer.mozilla.org/zh-CN/docs/Web/API/CloseEvent。
+ */
+exports.WebSocketCloseError = void 0;
+(function (WebSocketCloseError) {
+    /**
+     * 终端离开, 可能因为服务端错误, 也可能因为浏览器正从打开连接的页面跳转离开。
+     */
+    WebSocketCloseError["Err_1001"] = "CLOSE_GOING_AWAY";
+    /**
+     * 由于协议错误而中断连接。
+     */
+    WebSocketCloseError["Err_1002"] = "CLOSE_PROTOCOL_ERROR";
+    /**
+     * 由于接收到不允许的数据类型而断开连接 (如仅接收文本数据的终端接收到了二进制数据)。
+     */
+    WebSocketCloseError["Err_1003"] = "CLOSE_UNSUPPORTED";
+    /**
+     * 安全因素或WebSocket连接次数达到上限。
+     */
+    WebSocketCloseError["Err_1006"] = "CLOSE_ABNORMAL";
+    /**
+     * 由于收到了格式不符的数据而断开连接 (如文本消息中包含了非 UTF-8 数据)。
+     */
+    WebSocketCloseError["Err_1007"] = "Unsupported Data";
+    /**
+     * 由于收到不符合约定的数据而断开连接。
+     */
+    WebSocketCloseError["Err_1008"] = "Policy Violation";
+    /**
+     * 由于收到过大的数据帧而断开连接。
+     */
+    WebSocketCloseError["Err_1009"] = "CLOSE_TOO_LARGE";
+    /**
+     * 未知错误。
+     */
+    WebSocketCloseError["Err_unknown"] = "unknown";
+})(exports.WebSocketCloseError || (exports.WebSocketCloseError = {}));
+function parseWSClsErr(code) {
+    switch (code) {
+        case 1001: {
+            return exports.WebSocketCloseError.Err_1001;
+        }
+        case 1002: {
+            return exports.WebSocketCloseError.Err_1002;
+        }
+        case 1003: {
+            return exports.WebSocketCloseError.Err_1003;
+        }
+        case 1006: {
+            return exports.WebSocketCloseError.Err_1006;
+        }
+        case 1007: {
+            return exports.WebSocketCloseError.Err_1007;
+        }
+        case 1008: {
+            return exports.WebSocketCloseError.Err_1008;
+        }
+        case 1009: {
+            return exports.WebSocketCloseError.Err_1009;
+        }
+    }
+    return exports.WebSocketCloseError.Err_unknown;
+}
+
+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;
+}
+
+/**
+ * 判断是否是真实的对象类型
+ * @param value
+ * @returns
+ */
+function isTrulyObject(value) {
+    return Object.prototype.toString.call(value) === '[object Object]';
+}
+/**
+ * 判断基础类型是否相等
+ * @param value
+ * @param other
+ * @returns
+ */
+function baseIsEqual(value, other) {
+    if (value === other)
+        return true;
+    if (typeof value !== typeof other)
+        return false;
+    if (Number.isNaN(value) && Number.isNaN(other))
+        return true;
+    return false;
+}
+/**
+ * 对象浅比较
+ * @param value
+ * @param other
+ * @returns
+ */
+function objEqualShallow(value, other) {
+    const valueProps = Object.getOwnPropertyNames(value);
+    const otherProps = Object.getOwnPropertyNames(other);
+    if (valueProps.length !== otherProps.length)
+        return false;
+    for (let i = 0, len = valueProps.length; i < len; i++) {
+        const propName = valueProps[i];
+        if (!baseIsEqual(value[propName], other[propName]))
+            return false;
+    }
+    return true;
+}
+/**
+ * 数组浅比较
+ * @param value
+ * @param other
+ * @returns
+ */
+function arrayEqualShallow(value, other) {
+    if (value.length !== other.length)
+        return false;
+    for (let i = 0, len = value.length; i < len; i++) {
+        if (!baseIsEqual(value[i], other[i]))
+            return false;
+    }
+    return true;
+}
+/**
+ * 变量浅比较
+ * @param value
+ * @param other
+ * @returns
+ */
+function isShallowEqual(value, other) {
+    if (baseIsEqual(value, other))
+        return true;
+    if (isTrulyObject(value) && isTrulyObject(other))
+        return objEqualShallow(value, other);
+    if (Array.isArray(value) && Array.isArray(other))
+        return arrayEqualShallow(value, other);
+    return false;
+}
+/**
+ * 对象深比较
+ * @param value
+ * @param other
+ * @returns
+ */
+function isDeepEqual(value, other) {
+    if (baseIsEqual(value, other))
+        return true;
+    if (isTrulyObject(value) && isTrulyObject(other))
+        return objEqualDeep(value, other);
+    if (Array.isArray(value) && Array.isArray(other))
+        return arrayEqualDeep(value, other);
+    return false;
+}
+/**
+ * 数组深比较
+ * @param value
+ * @param other
+ * @returns
+ */
+function arrayEqualDeep(value, other) {
+    if (value.length !== other.length)
+        return false;
+    for (let i = 0, len = value.length; i < len; i++) {
+        if (!isDeepEqual(value[i], other[i]))
+            return false;
+    }
+    return true;
+}
+/**
+ * 对象深比较
+ * @param value
+ * @param other
+ * @returns
+ */
+function objEqualDeep(value, other) {
+    const valueProps = Object.getOwnPropertyNames(value);
+    const otherProps = Object.getOwnPropertyNames(other);
+    if (valueProps.length !== otherProps.length)
+        return false;
+    for (let i = 0, len = valueProps.length; i < len; i++) {
+        const propName = valueProps[i];
+        if (!isDeepEqual(value[propName], other[propName]))
+            return false;
+    }
+    return true;
+}
+/**
+ * 对象比较。
+ * @param value 第一个比较的值。
+ * @param other 第二个比较的值。
+ * @param options 可选参数，可选项：`deep` 是否深比较。
+ * @returns {boolean} 是否相等。
+ */
+function equal(value, other, opt) {
+    if (!opt.deep)
+        return isShallowEqual(value, other);
+    return isDeepEqual(value, other);
+}
+
+class LiveController {
+    constructor(options) {
+        this.readyState = exports.WebSocketState.NOTINITIALIZED;
+        this.canSync = true;
+        this.connecting = false;
+        this.keyframes = {};
+        /**
+         * 检测 WebSocket.readyState 状态
+         */
+        this.checkReadyState = (live) => {
+            do {
+                if (!this.webSocket) {
+                    if (this.readyState !== exports.WebSocketState.NOTINITIALIZED) {
+                        this.readyState = exports.WebSocketState.NOTINITIALIZED;
+                        live.emit('ws.readyStateUpdate', this.readyState);
+                    }
+                    break;
+                }
+                const readyState = this.webSocket.readyState;
+                if (readyState !== this.readyState) {
+                    this.readyState = readyState;
+                    live.emit('ws.readyStateUpdate', this.readyState);
+                }
+            } while (false);
+            return this.readyState;
+        };
+        this.dispose = () => {
+            this.disposeWebSocket();
+            this.connecting = false;
+            if (this.healthCheckId) {
+                clearInterval(this.healthCheckId);
+                this.healthCheckId = undefined;
+            }
+        };
+        /**
+         * 销毁WebSocket相关依赖。
+         */
+        this.disposeWebSocket = () => {
+            if (!this.webSocket)
+                return;
+            if (this.onEvtOpnListener) {
+                this.webSocket.removeEventListener('open', this.onEvtOpnListener);
+                this.onEvtOpnListener = undefined;
+            }
+            if (this.onEvtMsgListener) {
+                this.webSocket.removeEventListener('message', this.onEvtMsgListener);
+                this.onEvtMsgListener = undefined;
+            }
+            if (this.onEvtErrListener) {
+                this.webSocket.removeEventListener('error', this.onEvtErrListener);
+                this.onEvtErrListener = undefined;
+            }
+            if (this.onEvtCLEListener) {
+                this.webSocket.removeEventListener('close', this.onEvtCLEListener);
+                this.onEvtCLEListener = undefined;
+            }
+            this.webSocket.close();
+            this.webSocket = undefined;
+        };
+        this.options = Object.assign({ autoConnect: true, healthCheck: 3000 }, options);
+    }
+    /**
+     * 解析数据
+     * @param liveMsg
+     * @param live
+     */
+    handleMessage(liveMsg, live) {
+        var _a, _b, _c;
+        const { command, data, frontRequestId, code, message } = liveMsg;
+        if (code === 'SUCCESS') {
+            switch (command) {
+                /**
+                 * 自己的状态变化
+                 */
+                case exports.Command.SelfUserInfo: {
+                    const selfInfo = data;
+                    if (equal(this.selfUserInfo, selfInfo, { deep: true }))
+                        return;
+                    this.selfUserInfo = selfInfo;
+                    live.emit('selfInfoUpdate', this.selfUserInfo, frontRequestId);
+                    break;
+                }
+                /**
+                 * 房间信息变化
+                 */
+                case exports.Command.RoomInfo: {
+                    const roomInfo = data;
+                    this.roomInfo = Object.assign({}, roomInfo);
+                    live.emit('readyKeyframeSync', (roomInfo.last_frame || {}));
+                    break;
+                }
+                /**
+                 * 语音信息变化
+                 */
+                case exports.Command.RTCInfo: {
+                    const { voice_id: voiceId, type } = data;
+                    /* 如果已经进入语音房间，则不重复进入 --> "RTCInfo" 指令可能会下发多次 */
+                    if (live.$RTC.joined) {
+                        break;
+                    }
+                    live.$RTC.join({
+                        voiceId,
+                        userId: ((_a = this.selfUserInfo) === null || _a === void 0 ? void 0 : _a.id) || '',
+                        roomId: (_b = this.roomInfo) === null || _b === void 0 ? void 0 : _b.info.room_code,
+                        type,
+                    });
+                    // 加入房间后 麦克风默认就开启了：需要发个指令。
+                    live.updateStatus(exports.BuiltinEventType.UserChange, exports.BuiltinActionType.UserMicroStatus, {
+                        status: exports.MicroStatus.OPEN,
+                    });
+                    break;
+                }
+                /**
+                 * 房间用户列表变化
+                 */
+                case exports.Command.UserList: {
+                    const userList = data;
+                    this.userList = userList;
+                    live.emit('userListUpdate', this.userList, frontRequestId);
+                    break;
+                }
+                /**
+                 * 自定义事件广播
+                 */
+                case exports.Command.CustomEvent: {
+                    const evtMsg = data;
+                    live.emit('broadcast', evtMsg, frontRequestId);
+                    break;
+                }
+                /**
+                 * 帧数据同步
+                 */
+                case exports.Command.KeyframeSync: {
+                    const remoteKeyframes = data;
+                    // 此处做一层 diff，仅跟本地数据不一致的情况下才广播数据。
+                    const keyframes = Object.keys(remoteKeyframes).reduce((accu, curr) => {
+                        if (equal(remoteKeyframes[curr], this.keyframes[curr], { deep: true })) {
+                            return accu;
+                        }
+                        const params = [
+                            remoteKeyframes[curr],
+                            this.keyframes[curr],
+                            frontRequestId,
+                        ];
+                        const evtName = curr;
+                        live.keyframes.emit(evtName, ...params);
+                        this.keyframes[curr] = remoteKeyframes[curr];
+                        accu[curr] = remoteKeyframes[curr];
+                        return accu;
+                    }, {});
+                    live.emit('keyframes', keyframes, frontRequestId);
+                    break;
+                }
+                /**
+                 * 内置消息
+                 */
+                case exports.Command.BuiltinMsg: {
+                    const builtinMsg = data;
+                    live.emit('builtinEvent', builtinMsg);
+                    if (builtinMsg.event_type === exports.BuiltinEventType.UserChange) {
+                        live.emit('userChange', builtinMsg);
+                    }
+                    if (builtinMsg.event_type === exports.BuiltinEventType.RoomChange) {
+                        live.emit('roomChange', builtinMsg);
+                    }
+                    /**
+                     * 下发指令自己操作麦克风
+                     */
+                    if (builtinMsg.event_type === exports.BuiltinEventType.UserChange &&
+                        builtinMsg.action === exports.BuiltinActionType.UserMicroStatus) {
+                        live.toggleMicro(builtinMsg.data.status === exports.MicroStatus.OPEN);
+                    }
+                    /**
+                     * 如果下发指令退出房间，则 关闭麦克风 及 销毁 WebSocket
+                     */
+                    if (builtinMsg.event_type === exports.BuiltinEventType.RoomChange &&
+                        builtinMsg.action === exports.BuiltinActionType.RoomClose) {
+                        (_c = this.options.rtc) === null || _c === void 0 ? void 0 : _c.quit();
+                        this.disposeWebSocket();
+                    }
+                    break;
+                }
+                /**
+                 * 被踢出房间
+                 */
+                case exports.Command.UserKickOut: {
+                    live.emit('kickOut');
+                    break;
+                }
+                /**
+                 * 其它未知广播
+                 */
+                default: {
+                    console.warn('unknown command: ', command);
+                }
+            }
+        }
+        else {
+            live.emit('error', liveMsg);
+        }
+    }
+    /**
+     * 发送数据
+     * @param data
+     */
+    sendMessage(data) {
+        if (!this.webSocket)
+            return console.warn('WebSocket has not yet been initialized!');
+        if (!data)
+            return console.warn('WebSocket messages is empty!');
+        this.webSocket.send(JSON.stringify(data));
+    }
+}
+
+const unimplementedGetVoiceSign = (params) => Promise.reject('unimplemented method GetVoiceSign');
+/**
+ * 创建 `live` 实例。
+ */
+function createLive(options) {
+    const liveController = new LiveController(options);
+    const createLiveMsg = (command, data = {}, toUserIds) => {
+        toUserIds = toUserIds
+            ? Array.isArray(toUserIds)
+                ? toUserIds
+                : [toUserIds]
+            : [];
+        if (toUserIds)
+            data['to_user_ids'] = toUserIds;
+        return { command, front_request_id: uuid(), data };
+    };
+    class LiveTpl extends Subscribe {
+        constructor() {
+            var _a;
+            super();
+            this.keyframes = new Subscribe();
+            // 没有传rtc实例时
+            if (!options.rtc) {
+                // 取指定的内部rtc类型
+                if (options.rtcType) {
+                    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;
+                    switch (options.rtcType) {
+                        case exports.RTCType.RealseeVRWebViewRTC: {
+                            // 内置的 VRWebViewRTC
+                            if (!options.jsBridge) {
+                                throw new Error('JsBridge instance must be passed when using built-in VRWebViewRTC instances');
+                            }
+                            liveController.options.rtc = new VRWebViewRTC({
+                                jsBridge: options.jsBridge,
+                                getVoiceSign,
+                            });
+                            break;
+                        }
+                        case exports.RTCType.RealseeBrowserChimeRTC: {
+                            // 内置的 RealseeBrowserChimeRTC
+                            liveController.options.rtc = new BrowserRTC4Chime({
+                                getVoiceSign,
+                                logLevel: options.__debug__ ? amazonChimeSdkJs.LogLevel.DEBUG : amazonChimeSdkJs.LogLevel.ERROR,
+                            });
+                            break;
+                        }
+                        case exports.RTCType.RealseeBrowserRTC: {
+                            // 内置的 RealseeBrowserRTC
+                            liveController.options.rtc = new BrowserRTC({
+                                getVoiceSign,
+                            });
+                            break;
+                        }
+                        default: {
+                            throw new Error('unknown built-in RTC type');
+                        }
+                    }
+                }
+            }
+            if (!liveController.options.rtc) {
+                console.warn('unused rtc');
+            }
+            // 默认自动连接
+            if (liveController.options.url && liveController.options.getTicket) {
+                this.connect();
+            }
+            // 健康检查：WHY --> 在某些WebView特殊场景下 WebSocket.readyState 发生变化时不会出发error\close等事件;
+            //         因此，开启一个定时任务监测 WebSocket.readyState 状态的更新
+            const healthCheck = ((healthCheck) => {
+                if (!healthCheck)
+                    return 0;
+                if (healthCheck === true)
+                    return 3000;
+                const duration = Number(healthCheck);
+                if (duration > 0)
+                    return duration;
+                return 3000;
+            })(liveController.options.healthCheck);
+            if (healthCheck) {
+                liveController.healthCheckId = setInterval(() => liveController.checkReadyState(this), healthCheck);
+            }
+        }
+        get options() {
+            return Object.freeze(Object.assign({}, liveController.options));
+        }
+        get readyState() {
+            liveController.checkReadyState(this);
+            return liveController.readyState;
+        }
+        get url() {
+            var _a;
+            return ((_a = liveController.webSocket) === null || _a === void 0 ? void 0 : _a.url) || '';
+        }
+        get selfInfo() {
+            return liveController.selfUserInfo;
+        }
+        get userList() {
+            return liveController.userList || [];
+        }
+        get snapshot() {
+            return liveController.keyframes || {};
+        }
+        get $RTC() {
+            return liveController.options.rtc;
+        }
+        async setSelfInfo(userInfo) {
+            if (this.readyState !== exports.WebSocketState.OPEN) {
+                return new Error('The connection is not open and ready to communicate.');
+            }
+            try {
+                return await this.updateStatus(exports.BuiltinEventType.UserChange, exports.BuiltinActionType.UserInfo, userInfo);
+            }
+            catch (error) {
+                return error;
+            }
+        }
+        getFramesByKey(key) {
+            return liveController.keyframes[key];
+        }
+        sendKeyframe(key, frame) {
+            if (this.readyState !== exports.WebSocketState.OPEN) {
+                return new Error('The connection is not open and ready to communicate.');
+            }
+            liveController.keyframes[key] = frame;
+            const liveMsg = createLiveMsg(exports.Command.KeyframeSync, this.snapshot);
+            liveController.sendMessage(liveMsg);
+            return true;
+        }
+        broadcast(data, toUserIds, timeout) {
+            if (this.readyState !== exports.WebSocketState.OPEN) {
+                return new Error('The connection is not open and ready to communicate.');
+            }
+            return new Promise((resolve, reject) => {
+                const customEvent = createLiveMsg(exports.Command.CustomEvent, data, toUserIds);
+                const front_request_id = customEvent.front_request_id;
+                liveController.sendMessage(customEvent);
+                const timeoutId = timeout
+                    ? setTimeout(() => {
+                        reject(new Error('RESPONSE TIMEOUT'));
+                        this.off('broadcast', broadcast);
+                    }, timeout)
+                    : undefined;
+                const broadcast = (data, frontRequestId) => {
+                    if (frontRequestId !== front_request_id)
+                        return;
+                    this.off('broadcast', broadcast);
+                    resolve(data);
+                    if (timeoutId)
+                        clearInterval(timeoutId);
+                };
+                this.on('broadcast', broadcast);
+            });
+        }
+        async updateStatus(evtType, atnType, status, toUserIds) {
+            // TODO 统一规则，不能联合类型
+            if (this.readyState !== exports.WebSocketState.OPEN) {
+                return false;
+            }
+            const data = Object.assign({ event_type: evtType, action: atnType }, { data: status });
+            const liveMsg = createLiveMsg(exports.Command.BuiltinMsg, data, toUserIds);
+            liveController.sendMessage(liveMsg);
+            return true;
+        }
+        // 仅用于用户自己的麦克风控制
+        async toggleMicro(microStatus) {
+            var _a, _b;
+            if (!((_b = (_a = this.selfInfo) === null || _a === void 0 ? void 0 : _a.permission) === null || _b === void 0 ? void 0 : _b.control_own_micro))
+                return false;
+            await this.$RTC.toggleMicro(microStatus);
+            return await this.updateStatus(exports.BuiltinEventType.UserChange, exports.BuiltinActionType.UserMicroStatus, {
+                status: microStatus ? exports.MicroStatus.OPEN : exports.MicroStatus.CLOSE,
+            }, []);
+        }
+        async forbidMicro(microStatus, toUserIds) {
+            var _a, _b;
+            if (liveController.options.canForbidUserMicro &&
+                !liveController.options.canForbidUserMicro(toUserIds)) {
+                return false;
+            }
+            if (!((_b = (_a = this.selfInfo) === null || _a === void 0 ? void 0 : _a.permission) === null || _b === void 0 ? void 0 : _b.control_other_micro)) {
+                return false;
+            }
+            return await this.updateStatus(exports.BuiltinEventType.UserChange, exports.BuiltinActionType.UserMicroStatus, {
+                status: microStatus,
+            }, toUserIds);
+        }
+        /**
+         * @deprecated 暂不可用
+         */
+        async forbidSync(sync, toUserIds) {
+            var _a, _b;
+            if (liveController.options.canForbidUserSync &&
+                !liveController.options.canForbidUserSync(toUserIds)) {
+                return false;
+            }
+            if (!((_b = (_a = this.selfInfo) === null || _a === void 0 ? void 0 : _a.permission) === null || _b === void 0 ? void 0 : _b.control_other_sync)) {
+                return false;
+            }
+            return await this.updateStatus(exports.BuiltinEventType.UserChange, exports.BuiltinActionType.UserPermission, { sync_frame: sync }, toUserIds);
+        }
+        async kick(toUserIds) {
+            var _a, _b;
+            if (liveController.options.canForbidUserKick &&
+                !liveController.options.canForbidUserKick(toUserIds)) {
+                return false;
+            }
+            if (!((_b = (_a = this.selfInfo) === null || _a === void 0 ? void 0 : _a.permission) === null || _b === void 0 ? void 0 : _b.change_other_status)) {
+                return false;
+            }
+            return await this.updateStatus(exports.BuiltinEventType.UserChange, exports.BuiltinActionType.UserStatus, {
+                status: 'KICK_OUT',
+            }, toUserIds);
+        }
+        async exit() {
+            /** 退出强制关闭语音(?) */
+            await this.$RTC.quit();
+            return await this.updateStatus(exports.BuiltinEventType.RoomChange, exports.BuiltinActionType.RoomClose, {});
+        }
+        async connect(options = {}) {
+            // 连接 WebSocket 前验证麦克风权限
+            const microAuth = await this.$RTC.detectMicro();
+            if (!microAuth) {
+                const error = new Error('系统监测麦克风未授权~');
+                this.emit('ws.error', { type: exports.WebSocketErrorType.MicroAuth, error });
+                return error;
+            }
+            // WebSocket 正在连接中，规避重复连接
+            if (liveController.connecting) {
+                const error = new Error('WebSocket 正在连接中，请勿重复连接 ...');
+                this.emit('ws.error', {
+                    type: exports.WebSocketErrorType.DuplicateConnect,
+                    error,
+                });
+                return error;
+            }
+            // 非强制连接场景下，如果已经完成 WebSocket 连接则不执行后续逻辑
+            const { force } = options;
+            if (!force) {
+                if (this.readyState === exports.WebSocketState.CONNECTING ||
+                    this.readyState === exports.WebSocketState.OPEN) {
+                    return true;
+                }
+            }
+            // WebSocket URL 逻辑
+            if (options.url) {
+                liveController.options.url = options.url;
+            }
+            if (options.getTicket) {
+                liveController.options.getTicket = options.getTicket;
+            }
+            if (!liveController.options.url ||
+                !liveController.options.url.startsWith('ws')) {
+                const error = new Error(`WebSocket URL 未配置或格式不合法："${liveController.options.url}"`);
+                this.emit('ws.error', { type: exports.WebSocketErrorType.IllegalURL, error });
+                return error;
+            }
+            if (!liveController.options.getTicket) {
+                const error = new Error(`getTicket() 未配置!`);
+                this.emit('ws.error', { type: exports.WebSocketErrorType.IllegalArgs, error });
+                return error;
+            }
+            // 连接锁
+            liveController.connecting = true;
+            // 连接前销毁之前绑定的事件
+            liveController.disposeWebSocket();
+            this.emit('ws.beforeConnect');
+            const url = force || options.url || !this.url
+                ? appendUri(liveController.options.url, {
+                    ticket: await liveController.options.getTicket(),
+                    force: Number(!!force),
+                })
+                : this.url;
+            liveController.webSocket = new WebSocket(url);
+            liveController.onEvtOpnListener = () => {
+                liveController.checkReadyState(this);
+                this.emit('ws.afterConnect');
+            };
+            liveController.onEvtMsgListener = (evt) => {
+                liveController.checkReadyState(this);
+                try {
+                    const liveMsg = parseLiveMsg(evt.data);
+                    if (liveMsg === false)
+                        return;
+                    liveController.handleMessage(liveMsg, this);
+                }
+                catch (error) {
+                    // 未知错误
+                    this.emit('ws.error', {
+                        type: exports.WebSocketErrorType.Unknown,
+                        error,
+                        target: evt,
+                    });
+                }
+            };
+            liveController.onEvtErrListener = (evt) => {
+                live.emit('ws.error', { type: exports.WebSocketErrorType.Error, target: evt });
+                liveController.checkReadyState(this);
+            };
+            liveController.onEvtCLEListener = (evt) => {
+                liveController.checkReadyState(this);
+                const code = Number(evt.code);
+                if (code === 1000)
+                    return;
+                // 异常退出不一定会触发'error'事件，根据 evt.code 一些类型的退出也算是 error 行为
+                const errMsg = parseWSClsErr(code);
+                live.emit('ws.error', {
+                    target: evt,
+                    type: exports.WebSocketErrorType.Close,
+                    closeError: errMsg,
+                });
+            };
+            liveController.webSocket.addEventListener('open', liveController.onEvtOpnListener);
+            liveController.webSocket.addEventListener('message', liveController.onEvtMsgListener);
+            liveController.webSocket.addEventListener('error', liveController.onEvtErrListener);
+            liveController.webSocket.addEventListener('close', liveController.onEvtCLEListener);
+            return await new Promise((resolve, reject) => {
+                const success = () => {
+                    resolve(true);
+                    liveController.connecting = false;
+                    this.off('ws.error', fail);
+                };
+                const fail = (error) => {
+                    reject(error.error
+                        ? error.error
+                        : new Error('WebSocket connection failed!'));
+                    liveController.connecting = false;
+                    this.off('ws.afterConnect', success);
+                };
+                this.once('ws.afterConnect', success);
+                this.once('ws.error', fail);
+            });
+        }
+        async revoke() {
+            return true;
+        }
+    }
+    const live = new LiveTpl();
+    // 如果是调试环境则将内部状态暴露出来
+    if (options.__debug__) {
+        Object.assign(live, { __controller__: liveController });
+        Object.assign(window, { $live: live });
+    }
+    return live;
+}
+
+function createCommonjsModule(fn) {
+  var module = { exports: {} };
+	return fn(module, module.exports), module.exports;
+}
+
+/**
+ * @license React
+ * react.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var l=Symbol.for("react.element"),n=Symbol.for("react.portal"),p=Symbol.for("react.fragment"),q=Symbol.for("react.strict_mode"),r=Symbol.for("react.profiler"),t=Symbol.for("react.provider"),u=Symbol.for("react.context"),v=Symbol.for("react.forward_ref"),w=Symbol.for("react.suspense"),x=Symbol.for("react.memo"),y=Symbol.for("react.lazy"),z=Symbol.iterator;function A(a){if(null===a||"object"!==typeof a)return null;a=z&&a[z]||a["@@iterator"];return "function"===typeof a?a:null}
+var B={isMounted:function(){return !1},enqueueForceUpdate:function(){},enqueueReplaceState:function(){},enqueueSetState:function(){}},C=Object.assign,D={};function E(a,b,e){this.props=a;this.context=b;this.refs=D;this.updater=e||B;}E.prototype.isReactComponent={};
+E.prototype.setState=function(a,b){if("object"!==typeof a&&"function"!==typeof a&&null!=a)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,a,b,"setState");};E.prototype.forceUpdate=function(a){this.updater.enqueueForceUpdate(this,a,"forceUpdate");};function F(){}F.prototype=E.prototype;function G(a,b,e){this.props=a;this.context=b;this.refs=D;this.updater=e||B;}var H=G.prototype=new F;
+H.constructor=G;C(H,E.prototype);H.isPureReactComponent=!0;var I=Array.isArray,J=Object.prototype.hasOwnProperty,K={current:null},L={key:!0,ref:!0,__self:!0,__source:!0};
+function M(a,b,e){var d,c={},k=null,h=null;if(null!=b)for(d in void 0!==b.ref&&(h=b.ref),void 0!==b.key&&(k=""+b.key),b)J.call(b,d)&&!L.hasOwnProperty(d)&&(c[d]=b[d]);var g=arguments.length-2;if(1===g)c.children=e;else if(1<g){for(var f=Array(g),m=0;m<g;m++)f[m]=arguments[m+2];c.children=f;}if(a&&a.defaultProps)for(d in g=a.defaultProps,g)void 0===c[d]&&(c[d]=g[d]);return {$$typeof:l,type:a,key:k,ref:h,props:c,_owner:K.current}}
+function N(a,b){return {$$typeof:l,type:a.type,key:b,ref:a.ref,props:a.props,_owner:a._owner}}function O(a){return "object"===typeof a&&null!==a&&a.$$typeof===l}function escape(a){var b={"=":"=0",":":"=2"};return "$"+a.replace(/[=:]/g,function(a){return b[a]})}var P=/\/+/g;function Q(a,b){return "object"===typeof a&&null!==a&&null!=a.key?escape(""+a.key):b.toString(36)}
+function R(a,b,e,d,c){var k=typeof a;if("undefined"===k||"boolean"===k)a=null;var h=!1;if(null===a)h=!0;else switch(k){case "string":case "number":h=!0;break;case "object":switch(a.$$typeof){case l:case n:h=!0;}}if(h)return h=a,c=c(h),a=""===d?"."+Q(h,0):d,I(c)?(e="",null!=a&&(e=a.replace(P,"$&/")+"/"),R(c,b,e,"",function(a){return a})):null!=c&&(O(c)&&(c=N(c,e+(!c.key||h&&h.key===c.key?"":(""+c.key).replace(P,"$&/")+"/")+a)),b.push(c)),1;h=0;d=""===d?".":d+":";if(I(a))for(var g=0;g<a.length;g++){k=
+a[g];var f=d+Q(k,g);h+=R(k,b,e,f,c);}else if(f=A(a),"function"===typeof f)for(a=f.call(a),g=0;!(k=a.next()).done;)k=k.value,f=d+Q(k,g++),h+=R(k,b,e,f,c);else if("object"===k)throw b=String(a),Error("Objects are not valid as a React child (found: "+("[object Object]"===b?"object with keys {"+Object.keys(a).join(", ")+"}":b)+"). If you meant to render a collection of children, use an array instead.");return h}
+function S(a,b,e){if(null==a)return a;var d=[],c=0;R(a,d,"","",function(a){return b.call(e,a,c++)});return d}function T(a){if(-1===a._status){var b=a._result;b=b();b.then(function(b){if(0===a._status||-1===a._status)a._status=1,a._result=b;},function(b){if(0===a._status||-1===a._status)a._status=2,a._result=b;});-1===a._status&&(a._status=0,a._result=b);}if(1===a._status)return a._result.default;throw a._result;}
+var U={current:null},V={transition:null},W={ReactCurrentDispatcher:U,ReactCurrentBatchConfig:V,ReactCurrentOwner:K};var Children={map:S,forEach:function(a,b,e){S(a,function(){b.apply(this,arguments);},e);},count:function(a){var b=0;S(a,function(){b++;});return b},toArray:function(a){return S(a,function(a){return a})||[]},only:function(a){if(!O(a))throw Error("React.Children.only expected to receive a single React element child.");return a}};var Component=E;var Fragment=p;
+var Profiler=r;var PureComponent=G;var StrictMode=q;var Suspense=w;var __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED=W;
+var cloneElement=function(a,b,e){if(null===a||void 0===a)throw Error("React.cloneElement(...): The argument must be a React element, but you passed "+a+".");var d=C({},a.props),c=a.key,k=a.ref,h=a._owner;if(null!=b){void 0!==b.ref&&(k=b.ref,h=K.current);void 0!==b.key&&(c=""+b.key);if(a.type&&a.type.defaultProps)var g=a.type.defaultProps;for(f in b)J.call(b,f)&&!L.hasOwnProperty(f)&&(d[f]=void 0===b[f]&&void 0!==g?g[f]:b[f]);}var f=arguments.length-2;if(1===f)d.children=e;else if(1<f){g=Array(f);
+for(var m=0;m<f;m++)g[m]=arguments[m+2];d.children=g;}return {$$typeof:l,type:a.type,key:c,ref:k,props:d,_owner:h}};var createContext=function(a){a={$$typeof:u,_currentValue:a,_currentValue2:a,_threadCount:0,Provider:null,Consumer:null,_defaultValue:null,_globalName:null};a.Provider={$$typeof:t,_context:a};return a.Consumer=a};var createElement=M;var createFactory=function(a){var b=M.bind(null,a);b.type=a;return b};var createRef=function(){return {current:null}};
+var forwardRef=function(a){return {$$typeof:v,render:a}};var isValidElement=O;var lazy=function(a){return {$$typeof:y,_payload:{_status:-1,_result:a},_init:T}};var memo=function(a,b){return {$$typeof:x,type:a,compare:void 0===b?null:b}};var startTransition=function(a){var b=V.transition;V.transition={};try{a();}finally{V.transition=b;}};var unstable_act=function(){throw Error("act(...) is not supported in production builds of React.");};
+var useCallback=function(a,b){return U.current.useCallback(a,b)};var useContext=function(a){return U.current.useContext(a)};var useDebugValue=function(){};var useDeferredValue=function(a){return U.current.useDeferredValue(a)};var useEffect=function(a,b){return U.current.useEffect(a,b)};var useId=function(){return U.current.useId()};var useImperativeHandle=function(a,b,e){return U.current.useImperativeHandle(a,b,e)};
+var useInsertionEffect=function(a,b){return U.current.useInsertionEffect(a,b)};var useLayoutEffect=function(a,b){return U.current.useLayoutEffect(a,b)};var useMemo=function(a,b){return U.current.useMemo(a,b)};var useReducer=function(a,b,e){return U.current.useReducer(a,b,e)};var useRef=function(a){return U.current.useRef(a)};var useState=function(a){return U.current.useState(a)};var useSyncExternalStore=function(a,b,e){return U.current.useSyncExternalStore(a,b,e)};
+var useTransition=function(){return U.current.useTransition()};var version="18.1.0";
+
+var react_production_min = {
+	Children: Children,
+	Component: Component,
+	Fragment: Fragment,
+	Profiler: Profiler,
+	PureComponent: PureComponent,
+	StrictMode: StrictMode,
+	Suspense: Suspense,
+	__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,
+	cloneElement: cloneElement,
+	createContext: createContext,
+	createElement: createElement,
+	createFactory: createFactory,
+	createRef: createRef,
+	forwardRef: forwardRef,
+	isValidElement: isValidElement,
+	lazy: lazy,
+	memo: memo,
+	startTransition: startTransition,
+	unstable_act: unstable_act,
+	useCallback: useCallback,
+	useContext: useContext,
+	useDebugValue: useDebugValue,
+	useDeferredValue: useDeferredValue,
+	useEffect: useEffect,
+	useId: useId,
+	useImperativeHandle: useImperativeHandle,
+	useInsertionEffect: useInsertionEffect,
+	useLayoutEffect: useLayoutEffect,
+	useMemo: useMemo,
+	useReducer: useReducer,
+	useRef: useRef,
+	useState: useState,
+	useSyncExternalStore: useSyncExternalStore,
+	useTransition: useTransition,
+	version: version
+};
+
+/**
+ * @license React
+ * react.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var react_development = createCommonjsModule(function (module, exports) {
+
+if (process.env.NODE_ENV !== "production") {
+  (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 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.
+
+// 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;
+var FAUX_ITERATOR_SYMBOL = '@@iterator';
+function getIteratorFn(maybeIterable) {
+  if (maybeIterable === null || typeof maybeIterable !== 'object') {
+    return null;
+  }
+
+  var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
+
+  if (typeof maybeIterator === 'function') {
+    return maybeIterator;
+  }
+
+  return null;
+}
+
+/**
+ * Keeps track of the current dispatcher.
+ */
+var ReactCurrentDispatcher = {
+  /**
+   * @internal
+   * @type {ReactComponent}
+   */
+  current: null
+};
+
+/**
+ * Keeps track of the current batch's configuration such as how long an update
+ * 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
+};
+
+/**
+ * Keeps track of the current owner.
+ *
+ * The current owner is the component who should own any components that are
+ * currently being constructed.
+ */
+var ReactCurrentOwner = {
+  /**
+   * @internal
+   * @type {ReactComponent}
+   */
+  current: null
+};
+
+var ReactDebugCurrentFrame = {};
+var currentExtraStackFrame = null;
+function setExtraStackFrame(stack) {
+  {
+    currentExtraStackFrame = stack;
+  }
+}
+
+{
+  ReactDebugCurrentFrame.setExtraStackFrame = function (stack) {
+    {
+      currentExtraStackFrame = stack;
+    }
+  }; // Stack implementation injected by the current renderer.
+
+
+  ReactDebugCurrentFrame.getCurrentStack = null;
+
+  ReactDebugCurrentFrame.getStackAddendum = function () {
+    var stack = ''; // Add an extra top frame while an element is being validated
+
+    if (currentExtraStackFrame) {
+      stack += currentExtraStackFrame;
+    } // Delegate to the injected renderer-specific implementation
+
+
+    var impl = ReactDebugCurrentFrame.getCurrentStack;
+
+    if (impl) {
+      stack += impl() || '';
+    }
+
+    return stack;
+  };
+}
+
+var ReactSharedInternals = {
+  ReactCurrentDispatcher: ReactCurrentDispatcher,
+  ReactCurrentBatchConfig: ReactCurrentBatchConfig,
+  ReactCurrentOwner: ReactCurrentOwner
+};
+
+{
+  ReactSharedInternals.ReactDebugCurrentFrame = ReactDebugCurrentFrame;
+  ReactSharedInternals.ReactCurrentActQueue = ReactCurrentActQueue;
+}
+
+// by calls to these methods by a Babel plugin.
+//
+// In PROD (or in packages without access to React internals),
+// they are left as they are instead.
+
+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);
+    }
+  }
+}
+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);
+    }
+  }
+}
+
+function printWarning(level, format, args) {
+  // When changing this logic, you might want to also
+  // update consoleWithStackDev.www.js as well.
+  {
+    var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+    var stack = ReactDebugCurrentFrame.getStackAddendum();
+
+    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);
+    }); // Careful: RN currently depends on this prefix
+
+    argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it
+    // breaks IE9: https://github.com/facebook/react/issues/13610
+    // eslint-disable-next-line react-internal/no-production-logging
+
+    Function.prototype.apply.call(console[level], console, argsWithFormat);
+  }
+}
+
+var didWarnStateUpdateForUnmountedComponent = {};
+
+function warnNoop(publicInstance, callerName) {
+  {
+    var _constructor = publicInstance.constructor;
+    var componentName = _constructor && (_constructor.displayName || _constructor.name) || 'ReactClass';
+    var warningKey = componentName + "." + callerName;
+
+    if (didWarnStateUpdateForUnmountedComponent[warningKey]) {
+      return;
+    }
+
+    error("Can't call %s on a component that is not yet mounted. " + 'This is a no-op, but it might indicate a bug in your application. ' + 'Instead, assign to `this.state` directly or define a `state = {};` ' + 'class property with the desired state in the %s component.', callerName, componentName);
+
+    didWarnStateUpdateForUnmountedComponent[warningKey] = true;
+  }
+}
+/**
+ * This is the abstract API for an update queue.
+ */
+
+
+var ReactNoopUpdateQueue = {
+  /**
+   * Checks whether or not this composite component is mounted.
+   * @param {ReactClass} publicInstance The instance we want to test.
+   * @return {boolean} True if mounted, false otherwise.
+   * @protected
+   * @final
+   */
+  isMounted: function (publicInstance) {
+    return false;
+  },
+
+  /**
+   * Forces an update. This should only be invoked when it is known with
+   * certainty that we are **not** in a DOM transaction.
+   *
+   * You may want to call this when you know that some deeper aspect of the
+   * component's state has changed but `setState` was not called.
+   *
+   * This will not invoke `shouldComponentUpdate`, but it will invoke
+   * `componentWillUpdate` and `componentDidUpdate`.
+   *
+   * @param {ReactClass} publicInstance The instance that should rerender.
+   * @param {?function} callback Called after component is updated.
+   * @param {?string} callerName name of the calling function in the public API.
+   * @internal
+   */
+  enqueueForceUpdate: function (publicInstance, callback, callerName) {
+    warnNoop(publicInstance, 'forceUpdate');
+  },
+
+  /**
+   * Replaces all of the state. Always use this or `setState` to mutate state.
+   * You should treat `this.state` as immutable.
+   *
+   * There is no guarantee that `this.state` will be immediately updated, so
+   * accessing `this.state` after calling this method may return the old value.
+   *
+   * @param {ReactClass} publicInstance The instance that should rerender.
+   * @param {object} completeState Next state.
+   * @param {?function} callback Called after component is updated.
+   * @param {?string} callerName name of the calling function in the public API.
+   * @internal
+   */
+  enqueueReplaceState: function (publicInstance, completeState, callback, callerName) {
+    warnNoop(publicInstance, 'replaceState');
+  },
+
+  /**
+   * Sets a subset of the state. This only exists because _pendingState is
+   * internal. This provides a merging strategy that is not available to deep
+   * properties which is confusing. TODO: Expose pendingState or don't use it
+   * during the merge.
+   *
+   * @param {ReactClass} publicInstance The instance that should rerender.
+   * @param {object} partialState Next partial state to be merged with state.
+   * @param {?function} callback Called after component is updated.
+   * @param {?string} Name of the calling function in the public API.
+   * @internal
+   */
+  enqueueSetState: function (publicInstance, partialState, callback, callerName) {
+    warnNoop(publicInstance, 'setState');
+  }
+};
+
+var assign = Object.assign;
+
+var emptyObject = {};
+
+{
+  Object.freeze(emptyObject);
+}
+/**
+ * Base class helpers for the updating state of a component.
+ */
+
+
+function Component(props, context, updater) {
+  this.props = props;
+  this.context = context; // If a component has string refs, we will assign a different object later.
+
+  this.refs = emptyObject; // We initialize the default updater but the real one gets injected by the
+  // renderer.
+
+  this.updater = updater || ReactNoopUpdateQueue;
+}
+
+Component.prototype.isReactComponent = {};
+/**
+ * Sets a subset of the state. Always use this to mutate
+ * state. You should treat `this.state` as immutable.
+ *
+ * There is no guarantee that `this.state` will be immediately updated, so
+ * accessing `this.state` after calling this method may return the old value.
+ *
+ * There is no guarantee that calls to `setState` will run synchronously,
+ * as they may eventually be batched together.  You can provide an optional
+ * callback that will be executed when the call to setState is actually
+ * completed.
+ *
+ * When a function is provided to setState, it will be called at some point in
+ * the future (not synchronously). It will be called with the up to date
+ * component arguments (state, props, context). These values can be different
+ * from this.* because your function may be called after receiveProps but before
+ * shouldComponentUpdate, and this new state, props, and context will not yet be
+ * assigned to this.
+ *
+ * @param {object|function} partialState Next partial state or function to
+ *        produce next partial state to be merged with current state.
+ * @param {?function} callback Called after state is updated.
+ * @final
+ * @protected
+ */
+
+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.');
+  }
+
+  this.updater.enqueueSetState(this, partialState, callback, 'setState');
+};
+/**
+ * Forces an update. This should only be invoked when it is known with
+ * certainty that we are **not** in a DOM transaction.
+ *
+ * You may want to call this when you know that some deeper aspect of the
+ * component's state has changed but `setState` was not called.
+ *
+ * This will not invoke `shouldComponentUpdate`, but it will invoke
+ * `componentWillUpdate` and `componentDidUpdate`.
+ *
+ * @param {?function} callback Called after update is complete.
+ * @final
+ * @protected
+ */
+
+
+Component.prototype.forceUpdate = function (callback) {
+  this.updater.enqueueForceUpdate(this, callback, 'forceUpdate');
+};
+/**
+ * Deprecated APIs. These APIs used to exist on classic React classes but since
+ * we would like to deprecate them, we're not going to move them over to this
+ * modern base class. Instead, we define a getter that warns if it's accessed.
+ */
+
+
+{
+  var deprecatedAPIs = {
+    isMounted: ['isMounted', 'Instead, make sure to clean up subscriptions and pending requests in ' + 'componentWillUnmount to prevent memory leaks.'],
+    replaceState: ['replaceState', 'Refactor your code to use setState instead (see ' + 'https://github.com/facebook/react/issues/3236).']
+  };
+
+  var defineDeprecationWarning = function (methodName, info) {
+    Object.defineProperty(Component.prototype, methodName, {
+      get: function () {
+        warn('%s(...) is deprecated in plain JavaScript React classes. %s', info[0], info[1]);
+
+        return undefined;
+      }
+    });
+  };
+
+  for (var fnName in deprecatedAPIs) {
+    if (deprecatedAPIs.hasOwnProperty(fnName)) {
+      defineDeprecationWarning(fnName, deprecatedAPIs[fnName]);
+    }
+  }
+}
+
+function ComponentDummy() {}
+
+ComponentDummy.prototype = Component.prototype;
+/**
+ * Convenience component with default shallow equality check for sCU.
+ */
+
+function PureComponent(props, context, updater) {
+  this.props = props;
+  this.context = context; // If a component has string refs, we will assign a different object later.
+
+  this.refs = emptyObject;
+  this.updater = updater || ReactNoopUpdateQueue;
+}
+
+var pureComponentPrototype = PureComponent.prototype = new ComponentDummy();
+pureComponentPrototype.constructor = PureComponent; // Avoid an extra prototype jump for these methods.
+
+assign(pureComponentPrototype, Component.prototype);
+pureComponentPrototype.isPureReactComponent = true;
+
+// an immutable object with a single mutable value
+function createRef() {
+  var refObject = {
+    current: null
+  };
+
+  {
+    Object.seal(refObject);
+  }
+
+  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
+
+
+function getContextName(type) {
+  return type.displayName || 'Context';
+} // Note that the reconciler package should generally prefer to use getComponentNameFromFiber() instead.
+
+
+function getComponentNameFromType(type) {
+  if (type == null) {
+    // Host root, text node or just invalid type.
+    return null;
+  }
+
+  {
+    if (typeof type.tag === 'number') {
+      error('Received an unexpected object in getComponentNameFromType(). ' + 'This is likely a bug in React. Please file an issue.');
+    }
+  }
+
+  if (typeof type === 'function') {
+    return type.displayName || type.name || null;
+  }
+
+  if (typeof type === 'string') {
+    return type;
+  }
+
+  switch (type) {
+    case REACT_FRAGMENT_TYPE:
+      return 'Fragment';
+
+    case REACT_PORTAL_TYPE:
+      return 'Portal';
+
+    case REACT_PROFILER_TYPE:
+      return 'Profiler';
+
+    case REACT_STRICT_MODE_TYPE:
+      return 'StrictMode';
+
+    case REACT_SUSPENSE_TYPE:
+      return 'Suspense';
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      return 'SuspenseList';
+
+  }
+
+  if (typeof type === 'object') {
+    switch (type.$$typeof) {
+      case REACT_CONTEXT_TYPE:
+        var context = type;
+        return getContextName(context) + '.Consumer';
+
+      case REACT_PROVIDER_TYPE:
+        var provider = type;
+        return getContextName(provider._context) + '.Provider';
+
+      case REACT_FORWARD_REF_TYPE:
+        return getWrappedName(type, type.render, 'ForwardRef');
+
+      case REACT_MEMO_TYPE:
+        var outerName = type.displayName || null;
+
+        if (outerName !== null) {
+          return outerName;
+        }
+
+        return getComponentNameFromType(type.type) || 'Memo';
+
+      case REACT_LAZY_TYPE:
+        {
+          var lazyComponent = type;
+          var payload = lazyComponent._payload;
+          var init = lazyComponent._init;
+
+          try {
+            return getComponentNameFromType(init(payload));
+          } catch (x) {
+            return null;
+          }
+        }
+
+      // eslint-disable-next-line no-fallthrough
+    }
+  }
+
+  return null;
+}
+
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+
+var RESERVED_PROPS = {
+  key: true,
+  ref: true,
+  __self: true,
+  __source: true
+};
+var specialPropKeyWarningShown, specialPropRefWarningShown, didWarnAboutStringRefs;
+
+{
+  didWarnAboutStringRefs = {};
+}
+
+function hasValidRef(config) {
+  {
+    if (hasOwnProperty.call(config, 'ref')) {
+      var getter = Object.getOwnPropertyDescriptor(config, 'ref').get;
+
+      if (getter && getter.isReactWarning) {
+        return false;
+      }
+    }
+  }
+
+  return config.ref !== undefined;
+}
+
+function hasValidKey(config) {
+  {
+    if (hasOwnProperty.call(config, 'key')) {
+      var getter = Object.getOwnPropertyDescriptor(config, 'key').get;
+
+      if (getter && getter.isReactWarning) {
+        return false;
+      }
+    }
+  }
+
+  return config.key !== undefined;
+}
+
+function defineKeyPropWarningGetter(props, displayName) {
+  var warnAboutAccessingKey = function () {
+    {
+      if (!specialPropKeyWarningShown) {
+        specialPropKeyWarningShown = true;
+
+        error('%s: `key` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://reactjs.org/link/special-props)', displayName);
+      }
+    }
+  };
+
+  warnAboutAccessingKey.isReactWarning = true;
+  Object.defineProperty(props, 'key', {
+    get: warnAboutAccessingKey,
+    configurable: true
+  });
+}
+
+function defineRefPropWarningGetter(props, displayName) {
+  var warnAboutAccessingRef = function () {
+    {
+      if (!specialPropRefWarningShown) {
+        specialPropRefWarningShown = true;
+
+        error('%s: `ref` is not a prop. Trying to access it will result ' + 'in `undefined` being returned. If you need to access the same ' + 'value within the child component, you should pass it as a different ' + 'prop. (https://reactjs.org/link/special-props)', displayName);
+      }
+    }
+  };
+
+  warnAboutAccessingRef.isReactWarning = true;
+  Object.defineProperty(props, 'ref', {
+    get: warnAboutAccessingRef,
+    configurable: true
+  });
+}
+
+function warnIfStringRefCannotBeAutoConverted(config) {
+  {
+    if (typeof config.ref === 'string' && ReactCurrentOwner.current && config.__self && ReactCurrentOwner.current.stateNode !== config.__self) {
+      var componentName = getComponentNameFromType(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);
+
+        didWarnAboutStringRefs[componentName] = true;
+      }
+    }
+  }
+}
+/**
+ * Factory method to create a new React element. This no longer adheres to
+ * the class pattern, so do not use new to call it. Also, instanceof check
+ * will not work. Instead test $$typeof field against Symbol.for('react.element') to check
+ * if something is a React Element.
+ *
+ * @param {*} type
+ * @param {*} props
+ * @param {*} key
+ * @param {string|object} ref
+ * @param {*} owner
+ * @param {*} self A *temporary* helper to detect places where `this` is
+ * different from the `owner` when React.createElement is called, so that we
+ * can warn. We want to get rid of owner and replace string `ref`s with arrow
+ * functions, and as long as `this` and owner are the same, there will be no
+ * change in behavior.
+ * @param {*} source An annotation object (added by a transpiler or otherwise)
+ * indicating filename, line number, and/or other information.
+ * @internal
+ */
+
+
+var ReactElement = function (type, key, ref, self, source, owner, props) {
+  var element = {
+    // This tag allows us to uniquely identify this as a React Element
+    $$typeof: REACT_ELEMENT_TYPE,
+    // Built-in properties that belong on the element
+    type: type,
+    key: key,
+    ref: ref,
+    props: props,
+    // Record the component responsible for creating this element.
+    _owner: owner
+  };
+
+  {
+    // The validation flag is currently mutative. We put it on
+    // an external backing store so that we can freeze the whole object.
+    // This can be replaced with a WeakMap once they are implemented in
+    // commonly used development environments.
+    element._store = {}; // To make comparing ReactElements easier for testing purposes, we make
+    // the validation flag non-enumerable (where possible, which should
+    // include every environment we run tests in), so the test framework
+    // ignores it.
+
+    Object.defineProperty(element._store, 'validated', {
+      configurable: false,
+      enumerable: false,
+      writable: true,
+      value: false
+    }); // self and source are DEV only properties.
+
+    Object.defineProperty(element, '_self', {
+      configurable: false,
+      enumerable: false,
+      writable: false,
+      value: self
+    }); // Two elements created in two different places should be considered
+    // equal for testing purposes and therefore we hide it from enumeration.
+
+    Object.defineProperty(element, '_source', {
+      configurable: false,
+      enumerable: false,
+      writable: false,
+      value: source
+    });
+
+    if (Object.freeze) {
+      Object.freeze(element.props);
+      Object.freeze(element);
+    }
+  }
+
+  return element;
+};
+/**
+ * Create and return a new ReactElement of the given type.
+ * See https://reactjs.org/docs/react-api.html#createelement
+ */
+
+function createElement(type, config, children) {
+  var propName; // Reserved names are extracted
+
+  var props = {};
+  var key = null;
+  var ref = null;
+  var self = null;
+  var source = null;
+
+  if (config != null) {
+    if (hasValidRef(config)) {
+      ref = config.ref;
+
+      {
+        warnIfStringRefCannotBeAutoConverted(config);
+      }
+    }
+
+    if (hasValidKey(config)) {
+      {
+        checkKeyStringCoercion(config.key);
+      }
+
+      key = '' + config.key;
+    }
+
+    self = config.__self === undefined ? null : config.__self;
+    source = config.__source === undefined ? null : config.__source; // Remaining properties are added to a new props object
+
+    for (propName in config) {
+      if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
+        props[propName] = config[propName];
+      }
+    }
+  } // Children can be more than one argument, and those are transferred onto
+  // the newly allocated props object.
+
+
+  var childrenLength = arguments.length - 2;
+
+  if (childrenLength === 1) {
+    props.children = children;
+  } else if (childrenLength > 1) {
+    var childArray = Array(childrenLength);
+
+    for (var i = 0; i < childrenLength; i++) {
+      childArray[i] = arguments[i + 2];
+    }
+
+    {
+      if (Object.freeze) {
+        Object.freeze(childArray);
+      }
+    }
+
+    props.children = childArray;
+  } // Resolve default props
+
+
+  if (type && type.defaultProps) {
+    var defaultProps = type.defaultProps;
+
+    for (propName in defaultProps) {
+      if (props[propName] === undefined) {
+        props[propName] = defaultProps[propName];
+      }
+    }
+  }
+
+  {
+    if (key || ref) {
+      var displayName = typeof type === 'function' ? type.displayName || type.name || 'Unknown' : type;
+
+      if (key) {
+        defineKeyPropWarningGetter(props, displayName);
+      }
+
+      if (ref) {
+        defineRefPropWarningGetter(props, displayName);
+      }
+    }
+  }
+
+  return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
+}
+function cloneAndReplaceKey(oldElement, newKey) {
+  var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props);
+  return newElement;
+}
+/**
+ * Clone and return a new ReactElement using element as the starting point.
+ * See https://reactjs.org/docs/react-api.html#cloneelement
+ */
+
+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 + ".");
+  }
+
+  var propName; // Original props are copied
+
+  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.
+
+  var self = element._self; // Source is preserved since cloneElement is unlikely to be targeted by a
+  // transpiler, and the original source is probably a better indicator of the
+  // true owner.
+
+  var source = element._source; // Owner will be preserved, unless ref is overridden
+
+  var owner = element._owner;
+
+  if (config != null) {
+    if (hasValidRef(config)) {
+      // Silently steal the ref from the parent.
+      ref = config.ref;
+      owner = ReactCurrentOwner.current;
+    }
+
+    if (hasValidKey(config)) {
+      {
+        checkKeyStringCoercion(config.key);
+      }
+
+      key = '' + config.key;
+    } // Remaining properties override existing props
+
+
+    var defaultProps;
+
+    if (element.type && element.type.defaultProps) {
+      defaultProps = element.type.defaultProps;
+    }
+
+    for (propName in config) {
+      if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
+        if (config[propName] === undefined && defaultProps !== undefined) {
+          // Resolve default props
+          props[propName] = defaultProps[propName];
+        } else {
+          props[propName] = config[propName];
+        }
+      }
+    }
+  } // Children can be more than one argument, and those are transferred onto
+  // the newly allocated props object.
+
+
+  var childrenLength = arguments.length - 2;
+
+  if (childrenLength === 1) {
+    props.children = children;
+  } else if (childrenLength > 1) {
+    var childArray = Array(childrenLength);
+
+    for (var i = 0; i < childrenLength; i++) {
+      childArray[i] = arguments[i + 2];
+    }
+
+    props.children = childArray;
+  }
+
+  return ReactElement(element.type, key, ref, self, source, owner, props);
+}
+/**
+ * Verifies the object is a ReactElement.
+ * See https://reactjs.org/docs/react-api.html#isvalidelement
+ * @param {?object} object
+ * @return {boolean} True if `object` is a ReactElement.
+ * @final
+ */
+
+function isValidElement(object) {
+  return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+}
+
+var SEPARATOR = '.';
+var SUBSEPARATOR = ':';
+/**
+ * Escape and wrap key so it is safe to use as a reactid
+ *
+ * @param {string} key to be escaped.
+ * @return {string} the escaped key.
+ */
+
+function escape(key) {
+  var escapeRegex = /[=:]/g;
+  var escaperLookup = {
+    '=': '=0',
+    ':': '=2'
+  };
+  var escapedString = key.replace(escapeRegex, function (match) {
+    return escaperLookup[match];
+  });
+  return '$' + escapedString;
+}
+/**
+ * TODO: Test that a single child and an array with one item have the same key
+ * pattern.
+ */
+
+
+var didWarnAboutMaps = false;
+var userProvidedKeyEscapeRegex = /\/+/g;
+
+function escapeUserProvidedKey(text) {
+  return text.replace(userProvidedKeyEscapeRegex, '$&/');
+}
+/**
+ * Generate a key string that identifies a element within a set.
+ *
+ * @param {*} element A element that could contain a manual key.
+ * @param {number} index Index that is used if a manual key is not provided.
+ * @return {string}
+ */
+
+
+function getElementKey(element, index) {
+  // Do some typechecking here since we call this blindly. We want to ensure
+  // 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
+
+
+  return index.toString(36);
+}
+
+function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
+  var type = typeof children;
+
+  if (type === 'undefined' || type === 'boolean') {
+    // All of the above are perceived as null.
+    children = null;
+  }
+
+  var invokeCallback = false;
+
+  if (children === null) {
+    invokeCallback = true;
+  } else {
+    switch (type) {
+      case 'string':
+      case 'number':
+        invokeCallback = true;
+        break;
+
+      case 'object':
+        switch (children.$$typeof) {
+          case REACT_ELEMENT_TYPE:
+          case REACT_PORTAL_TYPE:
+            invokeCallback = true;
+        }
+
+    }
+  }
+
+  if (invokeCallback) {
+    var _child = children;
+    var mappedChild = callback(_child); // If it's the only child, treat the name as if it was wrapped in an array
+    // so that it's consistent if the number of children grows:
+
+    var childKey = nameSoFar === '' ? SEPARATOR + getElementKey(_child, 0) : nameSoFar;
+
+    if (isArray(mappedChild)) {
+      var escapedChildKey = '';
+
+      if (childKey != null) {
+        escapedChildKey = escapeUserProvidedKey(childKey) + '/';
+      }
+
+      mapIntoArray(mappedChild, array, escapedChildKey, '', function (c) {
+        return c;
+      });
+    } 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);
+      }
+
+      array.push(mappedChild);
+    }
+
+    return 1;
+  }
+
+  var child;
+  var nextName;
+  var subtreeCount = 0; // Count of children found in the current subtree.
+
+  var nextNamePrefix = nameSoFar === '' ? SEPARATOR : nameSoFar + SUBSEPARATOR;
+
+  if (isArray(children)) {
+    for (var i = 0; i < children.length; i++) {
+      child = children[i];
+      nextName = nextNamePrefix + getElementKey(child, i);
+      subtreeCount += mapIntoArray(child, array, escapedPrefix, nextName, callback);
+    }
+  } else {
+    var iteratorFn = getIteratorFn(children);
+
+    if (typeof iteratorFn === 'function') {
+      var iterableChildren = children;
+
+      {
+        // Warn about using Maps as children
+        if (iteratorFn === iterableChildren.entries) {
+          if (!didWarnAboutMaps) {
+            warn('Using Maps as children is not supported. ' + 'Use an array of keyed ReactElements instead.');
+          }
+
+          didWarnAboutMaps = true;
+        }
+      }
+
+      var iterator = iteratorFn.call(iterableChildren);
+      var step;
+      var ii = 0;
+
+      while (!(step = iterator.next()).done) {
+        child = step.value;
+        nextName = nextNamePrefix + getElementKey(child, ii++);
+        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.');
+    }
+  }
+
+  return subtreeCount;
+}
+
+/**
+ * Maps children that are typically specified as `props.children`.
+ *
+ * See https://reactjs.org/docs/react-api.html#reactchildrenmap
+ *
+ * The provided mapFunction(child, index) will be called for each
+ * leaf child.
+ *
+ * @param {?*} children Children tree container.
+ * @param {function(*, int)} func The map function.
+ * @param {*} context Context for mapFunction.
+ * @return {object} Object containing the ordered map of results.
+ */
+function mapChildren(children, func, context) {
+  if (children == null) {
+    return children;
+  }
+
+  var result = [];
+  var count = 0;
+  mapIntoArray(children, result, '', '', function (child) {
+    return func.call(context, child, count++);
+  });
+  return result;
+}
+/**
+ * Count the number of children that are typically specified as
+ * `props.children`.
+ *
+ * See https://reactjs.org/docs/react-api.html#reactchildrencount
+ *
+ * @param {?*} children Children tree container.
+ * @return {number} The number of children.
+ */
+
+
+function countChildren(children) {
+  var n = 0;
+  mapChildren(children, function () {
+    n++; // Don't return anything
+  });
+  return n;
+}
+
+/**
+ * Iterates through children that are typically specified as `props.children`.
+ *
+ * See https://reactjs.org/docs/react-api.html#reactchildrenforeach
+ *
+ * The provided forEachFunc(child, index) will be called for each
+ * leaf child.
+ *
+ * @param {?*} children Children tree container.
+ * @param {function(*, int)} forEachFunc
+ * @param {*} forEachContext Context for forEachContext.
+ */
+function forEachChildren(children, forEachFunc, forEachContext) {
+  mapChildren(children, function () {
+    forEachFunc.apply(this, arguments); // Don't return anything.
+  }, forEachContext);
+}
+/**
+ * Flatten a children object (typically specified as `props.children`) and
+ * return an array with appropriately re-keyed children.
+ *
+ * See https://reactjs.org/docs/react-api.html#reactchildrentoarray
+ */
+
+
+function toArray(children) {
+  return mapChildren(children, function (child) {
+    return child;
+  }) || [];
+}
+/**
+ * Returns the first child in a collection of children and verifies that there
+ * is only one child in the collection.
+ *
+ * See https://reactjs.org/docs/react-api.html#reactchildrenonly
+ *
+ * The current implementation of this function assumes that a single child gets
+ * passed without a wrapper, but the purpose of this helper function is to
+ * abstract away the particular structure of children.
+ *
+ * @param {?object} children Child collection structure.
+ * @return {ReactElement} The first and only `ReactElement` contained in the
+ * structure.
+ */
+
+
+function onlyChild(children) {
+  if (!isValidElement(children)) {
+    throw new 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?
+  var context = {
+    $$typeof: REACT_CONTEXT_TYPE,
+    // 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
+    // Fabric (secondary); React DOM (primary) and React ART (secondary).
+    // Secondary renderers store their context values on separate fields.
+    _currentValue: defaultValue,
+    _currentValue2: defaultValue,
+    // Used to track how many concurrent renderers this context currently
+    // supports within in a single renderer. Such as parallel server rendering.
+    _threadCount: 0,
+    // These are circular
+    Provider: null,
+    Consumer: null,
+    // Add these to use same hidden class in VM as ServerContext
+    _defaultValue: null,
+    _globalName: null
+  };
+  context.Provider = {
+    $$typeof: REACT_PROVIDER_TYPE,
+    _context: context
+  };
+  var hasWarnedAboutUsingNestedContextConsumers = false;
+  var hasWarnedAboutUsingConsumerProvider = false;
+  var hasWarnedAboutDisplayNameOnConsumer = false;
+
+  {
+    // A separate object, but proxies back to the original context object for
+    // backwards compatibility. It has a different $$typeof, so we can properly
+    // warn for the incorrect usage of Context as a Consumer.
+    var Consumer = {
+      $$typeof: REACT_CONTEXT_TYPE,
+      _context: context
+    }; // $FlowFixMe: Flow complains about not setting a value, which is intentional here
+
+    Object.defineProperties(Consumer, {
+      Provider: {
+        get: function () {
+          if (!hasWarnedAboutUsingConsumerProvider) {
+            hasWarnedAboutUsingConsumerProvider = true;
+
+            error('Rendering <Context.Consumer.Provider> is not supported and will be removed in ' + 'a future major release. Did you mean to render <Context.Provider> instead?');
+          }
+
+          return context.Provider;
+        },
+        set: function (_Provider) {
+          context.Provider = _Provider;
+        }
+      },
+      _currentValue: {
+        get: function () {
+          return context._currentValue;
+        },
+        set: function (_currentValue) {
+          context._currentValue = _currentValue;
+        }
+      },
+      _currentValue2: {
+        get: function () {
+          return context._currentValue2;
+        },
+        set: function (_currentValue2) {
+          context._currentValue2 = _currentValue2;
+        }
+      },
+      _threadCount: {
+        get: function () {
+          return context._threadCount;
+        },
+        set: function (_threadCount) {
+          context._threadCount = _threadCount;
+        }
+      },
+      Consumer: {
+        get: function () {
+          if (!hasWarnedAboutUsingNestedContextConsumers) {
+            hasWarnedAboutUsingNestedContextConsumers = true;
+
+            error('Rendering <Context.Consumer.Consumer> is not supported and will be removed in ' + 'a future major release. Did you mean to render <Context.Consumer> instead?');
+          }
+
+          return context.Consumer;
+        }
+      },
+      displayName: {
+        get: function () {
+          return context.displayName;
+        },
+        set: function (displayName) {
+          if (!hasWarnedAboutDisplayNameOnConsumer) {
+            warn('Setting `displayName` on Context.Consumer has no effect. ' + "You should set it directly on the context with Context.displayName = '%s'.", displayName);
+
+            hasWarnedAboutDisplayNameOnConsumer = true;
+          }
+        }
+      }
+    }); // $FlowFixMe: Flow complains about missing properties because it doesn't understand defineProperty
+
+    context.Consumer = Consumer;
+  }
+
+  {
+    context._currentRenderer = null;
+    context._currentRenderer2 = null;
+  }
+
+  return context;
+}
+
+var Uninitialized = -1;
+var Pending = 0;
+var Resolved = 1;
+var Rejected = 2;
+
+function lazyInitializer(payload) {
+  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.
+
+    thenable.then(function (moduleObject) {
+      if (payload._status === Pending || payload._status === Uninitialized) {
+        // Transition to the next state.
+        var resolved = payload;
+        resolved._status = Resolved;
+        resolved._result = moduleObject;
+      }
+    }, function (error) {
+      if (payload._status === Pending || payload._status === Uninitialized) {
+        // 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;
+  } else {
+    throw payload._result;
+  }
+}
+
+function lazy(ctor) {
+  var payload = {
+    // We use these fields to store the result.
+    _status: Uninitialized,
+    _result: ctor
+  };
+  var lazyType = {
+    $$typeof: REACT_LAZY_TYPE,
+    _payload: payload,
+    _init: lazyInitializer
+  };
+
+  {
+    // In production, this would just set it on the object.
+    var defaultProps;
+    var propTypes; // $FlowFixMe
+
+    Object.defineProperties(lazyType, {
+      defaultProps: {
+        configurable: true,
+        get: function () {
+          return defaultProps;
+        },
+        set: function (newDefaultProps) {
+          error('React.lazy(...): It is not supported to assign `defaultProps` to ' + 'a lazy component import. Either specify them where the component ' + 'is defined, or create a wrapping component around it.');
+
+          defaultProps = newDefaultProps; // Match production behavior more closely:
+          // $FlowFixMe
+
+          Object.defineProperty(lazyType, 'defaultProps', {
+            enumerable: true
+          });
+        }
+      },
+      propTypes: {
+        configurable: true,
+        get: function () {
+          return propTypes;
+        },
+        set: function (newPropTypes) {
+          error('React.lazy(...): It is not supported to assign `propTypes` to ' + 'a lazy component import. Either specify them where the component ' + 'is defined, or create a wrapping component around it.');
+
+          propTypes = newPropTypes; // Match production behavior more closely:
+          // $FlowFixMe
+
+          Object.defineProperty(lazyType, 'propTypes', {
+            enumerable: true
+          });
+        }
+      }
+    });
+  }
+
+  return lazyType;
+}
+
+function forwardRef(render) {
+  {
+    if (render != null && render.$$typeof === REACT_MEMO_TYPE) {
+      error('forwardRef requires a render function but received a `memo` ' + 'component. Instead of forwardRef(memo(...)), use ' + 'memo(forwardRef(...)).');
+    } else if (typeof render !== 'function') {
+      error('forwardRef requires a render function but was given %s.', render === null ? 'null' : typeof render);
+    } else {
+      if (render.length !== 0 && render.length !== 2) {
+        error('forwardRef render functions accept exactly two parameters: props and ref. %s', render.length === 1 ? 'Did you forget to use the ref parameter?' : 'Any additional parameter will be undefined.');
+      }
+    }
+
+    if (render != null) {
+      if (render.defaultProps != null || render.propTypes != null) {
+        error('forwardRef render functions do not support propTypes or defaultProps. ' + 'Did you accidentally pass a React component?');
+      }
+    }
+  }
+
+  var elementType = {
+    $$typeof: REACT_FORWARD_REF_TYPE,
+    render: render
+  };
+
+  {
+    var ownName;
+    Object.defineProperty(elementType, 'displayName', {
+      enumerable: false,
+      configurable: true,
+      get: function () {
+        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) {
+          render.displayName = name;
+        }
+      }
+    });
+  }
+
+  return elementType;
+}
+
+var REACT_MODULE_REFERENCE;
+
+{
+  REACT_MODULE_REFERENCE = Symbol.for('react.module.reference');
+}
+
+function isValidElementType(type) {
+  if (typeof type === 'string' || typeof type === 'function') {
+    return true;
+  } // 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 ) {
+    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) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function memo(type, compare) {
+  {
+    if (!isValidElementType(type)) {
+      error('memo: The first argument must be a component. Instead ' + 'received: %s', type === null ? 'null' : typeof type);
+    }
+  }
+
+  var elementType = {
+    $$typeof: REACT_MEMO_TYPE,
+    type: type,
+    compare: compare === undefined ? null : compare
+  };
+
+  {
+    var ownName;
+    Object.defineProperty(elementType, 'displayName', {
+      enumerable: false,
+      configurable: true,
+      get: function () {
+        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) {
+          type.displayName = name;
+        }
+      }
+    });
+  }
+
+  return elementType;
+}
+
+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.');
+    }
+  } // 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) {
+  var dispatcher = resolveDispatcher();
+
+  {
+    // 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.
+
+      if (realContext.Consumer === Context) {
+        error('Calling useContext(Context.Consumer) is not supported, may cause bugs, and will be ' + 'removed in a future major release. Did you mean to call useContext(Context) instead?');
+      } else if (realContext.Provider === Context) {
+        error('Calling useContext(Context.Provider) is not supported. ' + 'Did you mean to call useContext(Context) instead?');
+      }
+    }
+  }
+
+  return dispatcher.useContext(Context);
+}
+function useState(initialState) {
+  var dispatcher = resolveDispatcher();
+  return dispatcher.useState(initialState);
+}
+function useReducer(reducer, initialArg, init) {
+  var dispatcher = resolveDispatcher();
+  return dispatcher.useReducer(reducer, initialArg, init);
+}
+function useRef(initialValue) {
+  var dispatcher = resolveDispatcher();
+  return dispatcher.useRef(initialValue);
+}
+function useEffect(create, deps) {
+  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);
+}
+function useCallback(callback, deps) {
+  var dispatcher = resolveDispatcher();
+  return dispatcher.useCallback(callback, deps);
+}
+function useMemo(create, deps) {
+  var dispatcher = resolveDispatcher();
+  return dispatcher.useMemo(create, deps);
+}
+function useImperativeHandle(ref, create, deps) {
+  var dispatcher = resolveDispatcher();
+  return dispatcher.useImperativeHandle(ref, create, deps);
+}
+function useDebugValue(value, formatterFn) {
+  {
+    var dispatcher = resolveDispatcher();
+    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
+// lazily which won't cover if the log function was extracted eagerly.
+// We could also eagerly patch the method.
+var disabledDepth = 0;
+var prevLog;
+var prevInfo;
+var prevWarn;
+var prevError;
+var prevGroup;
+var prevGroupCollapsed;
+var prevGroupEnd;
+
+function disabledLog() {}
+
+disabledLog.__reactDisabledLog = true;
+function disableLogs() {
+  {
+    if (disabledDepth === 0) {
+      /* eslint-disable react-internal/no-production-logging */
+      prevLog = console.log;
+      prevInfo = console.info;
+      prevWarn = console.warn;
+      prevError = console.error;
+      prevGroup = console.group;
+      prevGroupCollapsed = console.groupCollapsed;
+      prevGroupEnd = console.groupEnd; // https://github.com/facebook/react/issues/19099
+
+      var props = {
+        configurable: true,
+        enumerable: true,
+        value: disabledLog,
+        writable: true
+      }; // $FlowFixMe Flow thinks console is immutable.
+
+      Object.defineProperties(console, {
+        info: props,
+        log: props,
+        warn: props,
+        error: props,
+        group: props,
+        groupCollapsed: props,
+        groupEnd: props
+      });
+      /* eslint-enable react-internal/no-production-logging */
+    }
+
+    disabledDepth++;
+  }
+}
+function reenableLogs() {
+  {
+    disabledDepth--;
+
+    if (disabledDepth === 0) {
+      /* eslint-disable react-internal/no-production-logging */
+      var props = {
+        configurable: true,
+        enumerable: true,
+        writable: true
+      }; // $FlowFixMe Flow thinks console is immutable.
+
+      Object.defineProperties(console, {
+        log: assign({}, props, {
+          value: prevLog
+        }),
+        info: assign({}, props, {
+          value: prevInfo
+        }),
+        warn: assign({}, props, {
+          value: prevWarn
+        }),
+        error: assign({}, props, {
+          value: prevError
+        }),
+        group: assign({}, props, {
+          value: prevGroup
+        }),
+        groupCollapsed: assign({}, props, {
+          value: prevGroupCollapsed
+        }),
+        groupEnd: assign({}, props, {
+          value: prevGroupEnd
+        })
+      });
+      /* eslint-enable react-internal/no-production-logging */
+    }
+
+    if (disabledDepth < 0) {
+      error('disabledDepth fell below zero. ' + 'This is a bug in React. Please file an issue.');
+    }
+  }
+}
+
+var ReactCurrentDispatcher$1 = ReactSharedInternals.ReactCurrentDispatcher;
+var prefix;
+function describeBuiltInComponentFrame(name, source, ownerFn) {
+  {
+    if (prefix === undefined) {
+      // Extract the VM specific prefix used by each line.
+      try {
+        throw Error();
+      } catch (x) {
+        var match = x.stack.trim().match(/\n( *(at )?)/);
+        prefix = match && match[1] || '';
+      }
+    } // We use the prefix to ensure our stacks line up with native stack frames.
+
+
+    return '\n' + prefix + name;
+  }
+}
+var reentry = false;
+var componentFrameCache;
+
+{
+  var PossiblyWeakMap = typeof WeakMap === 'function' ? WeakMap : Map;
+  componentFrameCache = new PossiblyWeakMap();
+}
+
+function describeNativeComponentFrame(fn, construct) {
+  // If something asked for a stack inside a fake render, it should get ignored.
+  if ( !fn || reentry) {
+    return '';
+  }
+
+  {
+    var frame = componentFrameCache.get(fn);
+
+    if (frame !== undefined) {
+      return frame;
+    }
+  }
+
+  var control;
+  reentry = true;
+  var previousPrepareStackTrace = Error.prepareStackTrace; // $FlowFixMe It does accept undefined.
+
+  Error.prepareStackTrace = undefined;
+  var previousDispatcher;
+
+  {
+    previousDispatcher = ReactCurrentDispatcher$1.current; // Set the dispatcher in DEV because this might be call in the render function
+    // for warnings.
+
+    ReactCurrentDispatcher$1.current = null;
+    disableLogs();
+  }
+
+  try {
+    // This should throw.
+    if (construct) {
+      // Something should be setting the props in the constructor.
+      var Fake = function () {
+        throw Error();
+      }; // $FlowFixMe
+
+
+      Object.defineProperty(Fake.prototype, 'props', {
+        set: function () {
+          // We use a throwing setter instead of frozen or non-writable props
+          // because that won't throw in a non-strict mode function.
+          throw Error();
+        }
+      });
+
+      if (typeof Reflect === 'object' && Reflect.construct) {
+        // We construct a different control for this case to include any extra
+        // frames added by the construct call.
+        try {
+          Reflect.construct(Fake, []);
+        } catch (x) {
+          control = x;
+        }
+
+        Reflect.construct(fn, [], Fake);
+      } else {
+        try {
+          Fake.call();
+        } catch (x) {
+          control = x;
+        }
+
+        fn.call(Fake.prototype);
+      }
+    } else {
+      try {
+        throw Error();
+      } catch (x) {
+        control = x;
+      }
+
+      fn();
+    }
+  } catch (sample) {
+    // This is inlined manually because closure doesn't do it for us.
+    if (sample && control && typeof sample.stack === 'string') {
+      // This extracts the first frame from the sample that isn't also in the control.
+      // Skipping one frame that we assume is the frame that calls the two.
+      var sampleLines = sample.stack.split('\n');
+      var controlLines = control.stack.split('\n');
+      var s = sampleLines.length - 1;
+      var c = controlLines.length - 1;
+
+      while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
+        // We expect at least one stack frame to be shared.
+        // Typically this will be the root most one. However, stack frames may be
+        // cut off due to maximum stack limits. In this case, one maybe cut off
+        // earlier than the other. We assume that the sample is longer or the same
+        // and there for cut off earlier. So we should find the root most frame in
+        // the sample somewhere in the control.
+        c--;
+      }
+
+      for (; s >= 1 && c >= 0; s--, c--) {
+        // Next we find the first one that isn't the same which should be the
+        // frame that called our sample function and the control.
+        if (sampleLines[s] !== controlLines[c]) {
+          // In V8, the first line is describing the message but other VMs don't.
+          // If we're about to return the first line, and the control is also on the same
+          // line, that's a pretty good indicator that our sample threw at same line as
+          // the control. I.e. before we entered the sample frame. So we ignore this result.
+          // This can happen if you passed a class to function component, or non-function.
+          if (s !== 1 || c !== 1) {
+            do {
+              s--;
+              c--; // We may still have similar intermediate frames from the construct call.
+              // The next one that isn't the same should be our match though.
+
+              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);
+                }
+
+                {
+                  if (typeof fn === 'function') {
+                    componentFrameCache.set(fn, _frame);
+                  }
+                } // Return the line we found.
+
+
+                return _frame;
+              }
+            } while (s >= 1 && c >= 0);
+          }
+
+          break;
+        }
+      }
+    }
+  } finally {
+    reentry = false;
+
+    {
+      ReactCurrentDispatcher$1.current = previousDispatcher;
+      reenableLogs();
+    }
+
+    Error.prepareStackTrace = previousPrepareStackTrace;
+  } // Fallback to just using the name if we couldn't make it throw.
+
+
+  var name = fn ? fn.displayName || fn.name : '';
+  var syntheticFrame = name ? describeBuiltInComponentFrame(name) : '';
+
+  {
+    if (typeof fn === 'function') {
+      componentFrameCache.set(fn, syntheticFrame);
+    }
+  }
+
+  return syntheticFrame;
+}
+function describeFunctionComponentFrame(fn, source, ownerFn) {
+  {
+    return describeNativeComponentFrame(fn, false);
+  }
+}
+
+function shouldConstruct(Component) {
+  var prototype = Component.prototype;
+  return !!(prototype && prototype.isReactComponent);
+}
+
+function describeUnknownElementTypeFrameInDEV(type, source, ownerFn) {
+
+  if (type == null) {
+    return '';
+  }
+
+  if (typeof type === 'function') {
+    {
+      return describeNativeComponentFrame(type, shouldConstruct(type));
+    }
+  }
+
+  if (typeof type === 'string') {
+    return describeBuiltInComponentFrame(type);
+  }
+
+  switch (type) {
+    case REACT_SUSPENSE_TYPE:
+      return describeBuiltInComponentFrame('Suspense');
+
+    case REACT_SUSPENSE_LIST_TYPE:
+      return describeBuiltInComponentFrame('SuspenseList');
+  }
+
+  if (typeof type === 'object') {
+    switch (type.$$typeof) {
+      case REACT_FORWARD_REF_TYPE:
+        return describeFunctionComponentFrame(type.render);
+
+      case REACT_MEMO_TYPE:
+        // Memo may contain any component type so we recursively resolve it.
+        return describeUnknownElementTypeFrameInDEV(type.type);
+
+      case REACT_LAZY_TYPE:
+        {
+          var lazyComponent = type;
+          var payload = lazyComponent._payload;
+          var init = lazyComponent._init;
+
+          try {
+            // Lazy may contain any component type so we recursively resolve it.
+            return describeUnknownElementTypeFrameInDEV(init(payload));
+          } catch (x) {}
+        }
+    }
+  }
+
+  return '';
+}
+
+var loggedTypeFailures = {};
+var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;
+
+function setCurrentlyValidatingElement(element) {
+  {
+    if (element) {
+      var stack = describeUnknownElementTypeFrameInDEV(element.type);
+      ReactDebugCurrentFrame$1.setExtraStackFrame(stack);
+    } else {
+      ReactDebugCurrentFrame$1.setExtraStackFrame(null);
+    }
+  }
+}
+
+function checkPropTypes(typeSpecs, values, location, componentName, element) {
+  {
+    // $FlowFixMe This is okay but Flow doesn't know it.
+    var has = Function.call.bind(hasOwnProperty);
+
+    for (var typeSpecName in typeSpecs) {
+      if (has(typeSpecs, typeSpecName)) {
+        var error$1 = void 0; // Prop type validation may throw. In case they do, we don't want to
+        // fail the render phase where it didn't fail before. So we log it.
+        // After these have been cleaned up, we'll let them throw.
+
+        try {
+          // 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;
+          }
+
+          error$1 = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED');
+        } catch (ex) {
+          error$1 = ex;
+        }
+
+        if (error$1 && !(error$1 instanceof Error)) {
+          setCurrentlyValidatingElement(element);
+
+          error('%s: type specification of %s' + ' `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName || 'React class', location, typeSpecName, typeof error$1);
+
+          setCurrentlyValidatingElement(null);
+        }
+
+        if (error$1 instanceof Error && !(error$1.message in loggedTypeFailures)) {
+          // Only monitor this failure once because there tends to be a lot of the
+          // same error.
+          loggedTypeFailures[error$1.message] = true;
+          setCurrentlyValidatingElement(element);
+
+          error('Failed %s type: %s', location, error$1.message);
+
+          setCurrentlyValidatingElement(null);
+        }
+      }
+    }
+  }
+}
+
+function setCurrentlyValidatingElement$1(element) {
+  {
+    if (element) {
+      var stack = describeUnknownElementTypeFrameInDEV(element.type);
+      setExtraStackFrame(stack);
+    } else {
+      setExtraStackFrame(null);
+    }
+  }
+}
+
+var propTypesMisspellWarningShown;
+
+{
+  propTypesMisspellWarningShown = false;
+}
+
+function getDeclarationErrorAddendum() {
+  if (ReactCurrentOwner.current) {
+    var name = getComponentNameFromType(ReactCurrentOwner.current.type);
+
+    if (name) {
+      return '\n\nCheck the render method of `' + name + '`.';
+    }
+  }
+
+  return '';
+}
+
+function getSourceInfoErrorAddendum(source) {
+  if (source !== undefined) {
+    var fileName = source.fileName.replace(/^.*[\\\/]/, '');
+    var lineNumber = source.lineNumber;
+    return '\n\nCheck your code at ' + fileName + ':' + lineNumber + '.';
+  }
+
+  return '';
+}
+
+function getSourceInfoErrorAddendumForProps(elementProps) {
+  if (elementProps !== null && elementProps !== undefined) {
+    return getSourceInfoErrorAddendum(elementProps.__source);
+  }
+
+  return '';
+}
+/**
+ * Warn if there's no key explicitly set on dynamic arrays of children or
+ * object keys are not valid. This allows us to keep track of children between
+ * updates.
+ */
+
+
+var ownerHasKeyUseWarning = {};
+
+function getCurrentComponentErrorInfo(parentType) {
+  var info = getDeclarationErrorAddendum();
+
+  if (!info) {
+    var parentName = typeof parentType === 'string' ? parentType : parentType.displayName || parentType.name;
+
+    if (parentName) {
+      info = "\n\nCheck the top-level render call using <" + parentName + ">.";
+    }
+  }
+
+  return info;
+}
+/**
+ * Warn if the element doesn't have an explicit key assigned to it.
+ * This element is in an array. The array could grow and shrink or be
+ * reordered. All children that haven't already been validated are required to
+ * have a "key" property assigned to it. Error statuses are cached so a warning
+ * will only be shown once.
+ *
+ * @internal
+ * @param {ReactElement} element Element that requires a key.
+ * @param {*} parentType element's parent's type.
+ */
+
+
+function validateExplicitKey(element, parentType) {
+  if (!element._store || element._store.validated || element.key != null) {
+    return;
+  }
+
+  element._store.validated = true;
+  var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);
+
+  if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {
+    return;
+  }
+
+  ownerHasKeyUseWarning[currentComponentErrorInfo] = true; // Usually the current owner is the offender, but if it accepts children as a
+  // property, it may be the creator of the child that's responsible for
+  // assigning it a key.
+
+  var childOwner = '';
+
+  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) + ".";
+  }
+
+  {
+    setCurrentlyValidatingElement$1(element);
+
+    error('Each child in a list should have a unique "key" prop.' + '%s%s See https://reactjs.org/link/warning-keys for more information.', currentComponentErrorInfo, childOwner);
+
+    setCurrentlyValidatingElement$1(null);
+  }
+}
+/**
+ * Ensure that every element either is passed in a static location, in an
+ * array with an explicit keys property defined, or in an object literal
+ * with valid key property.
+ *
+ * @internal
+ * @param {ReactNode} node Statically passed child of any type.
+ * @param {*} parentType node's parent's type.
+ */
+
+
+function validateChildKeys(node, parentType) {
+  if (typeof node !== 'object') {
+    return;
+  }
+
+  if (isArray(node)) {
+    for (var i = 0; i < node.length; i++) {
+      var child = node[i];
+
+      if (isValidElement(child)) {
+        validateExplicitKey(child, parentType);
+      }
+    }
+  } else if (isValidElement(node)) {
+    // This element was passed in a valid location.
+    if (node._store) {
+      node._store.validated = true;
+    }
+  } else if (node) {
+    var iteratorFn = getIteratorFn(node);
+
+    if (typeof iteratorFn === 'function') {
+      // Entry iterators used to provide implicit keys,
+      // but now we print a separate warning for them later.
+      if (iteratorFn !== node.entries) {
+        var iterator = iteratorFn.call(node);
+        var step;
+
+        while (!(step = iterator.next()).done) {
+          if (isValidElement(step.value)) {
+            validateExplicitKey(step.value, parentType);
+          }
+        }
+      }
+    }
+  }
+}
+/**
+ * Given an element, validate that its props follow the propTypes definition,
+ * provided by the type.
+ *
+ * @param {ReactElement} element
+ */
+
+
+function validatePropTypes(element) {
+  {
+    var type = element.type;
+
+    if (type === null || type === undefined || typeof type === 'string') {
+      return;
+    }
+
+    var propTypes;
+
+    if (typeof type === 'function') {
+      propTypes = type.propTypes;
+    } else if (typeof type === 'object' && (type.$$typeof === REACT_FORWARD_REF_TYPE || // Note: Memo only checks outer props here.
+    // Inner props are checked in the reconciler.
+    type.$$typeof === REACT_MEMO_TYPE)) {
+      propTypes = type.propTypes;
+    } else {
+      return;
+    }
+
+    if (propTypes) {
+      // Intentionally inside to avoid triggering lazy initializers:
+      var name = getComponentNameFromType(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);
+
+      error('Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?', _name || 'Unknown');
+    }
+
+    if (typeof type.getDefaultProps === 'function' && !type.getDefaultProps.isReactClassApproved) {
+      error('getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.');
+    }
+  }
+}
+/**
+ * Given a fragment, validate that it can only be provided with fragment props
+ * @param {ReactElement} fragment
+ */
+
+
+function validateFragmentProps(fragment) {
+  {
+    var keys = Object.keys(fragment.props);
+
+    for (var i = 0; i < keys.length; i++) {
+      var key = keys[i];
+
+      if (key !== 'children' && key !== 'key') {
+        setCurrentlyValidatingElement$1(fragment);
+
+        error('Invalid prop `%s` supplied to `React.Fragment`. ' + 'React.Fragment can only have `key` and `children` props.', key);
+
+        setCurrentlyValidatingElement$1(null);
+        break;
+      }
+    }
+
+    if (fragment.ref !== null) {
+      setCurrentlyValidatingElement$1(fragment);
+
+      error('Invalid attribute `ref` supplied to `React.Fragment`.');
+
+      setCurrentlyValidatingElement$1(null);
+    }
+  }
+}
+function createElementWithValidation(type, props, children) {
+  var validType = isValidElementType(type); // We warn in this case but don't throw. We expect the element creation to
+  // succeed and there will likely be errors in render.
+
+  if (!validType) {
+    var info = '';
+
+    if (type === undefined || typeof type === 'object' && type !== null && Object.keys(type).length === 0) {
+      info += ' You likely forgot to export your component from the file ' + "it's defined in, or you might have mixed up default and named imports.";
+    }
+
+    var sourceInfo = getSourceInfoErrorAddendumForProps(props);
+
+    if (sourceInfo) {
+      info += sourceInfo;
+    } else {
+      info += getDeclarationErrorAddendum();
+    }
+
+    var typeString;
+
+    if (type === null) {
+      typeString = 'null';
+    } else if (isArray(type)) {
+      typeString = 'array';
+    } else if (type !== undefined && type.$$typeof === REACT_ELEMENT_TYPE) {
+      typeString = "<" + (getComponentNameFromType(type.type) || 'Unknown') + " />";
+      info = ' Did you accidentally export a JSX literal instead of a component?';
+    } else {
+      typeString = typeof type;
+    }
+
+    {
+      error('React.createElement: type is invalid -- expected a string (for ' + 'built-in components) or a class/function (for composite ' + 'components) but got: %s.%s', typeString, info);
+    }
+  }
+
+  var element = createElement.apply(this, arguments); // The result can be nullish if a mock or a custom function is used.
+  // TODO: Drop this when these are no longer allowed as the type argument.
+
+  if (element == null) {
+    return element;
+  } // Skip key warning if the type isn't valid since our key validation logic
+  // doesn't expect a non-string/function type and can throw confusing errors.
+  // We don't want exception behavior to differ between dev and prod.
+  // (Rendering will throw with a helpful message and as soon as the type is
+  // fixed, the key warnings will appear.)
+
+
+  if (validType) {
+    for (var i = 2; i < arguments.length; i++) {
+      validateChildKeys(arguments[i], type);
+    }
+  }
+
+  if (type === REACT_FRAGMENT_TYPE) {
+    validateFragmentProps(element);
+  } else {
+    validatePropTypes(element);
+  }
+
+  return element;
+}
+var didWarnAboutDeprecatedCreateFactory = false;
+function createFactoryWithValidation(type) {
+  var validatedFactory = createElementWithValidation.bind(null, type);
+  validatedFactory.type = type;
+
+  {
+    if (!didWarnAboutDeprecatedCreateFactory) {
+      didWarnAboutDeprecatedCreateFactory = true;
+
+      warn('React.createFactory() is deprecated and will be removed in ' + 'a future major release. Consider using JSX ' + 'or use React.createElement() directly instead.');
+    } // Legacy hook: remove it
+
+
+    Object.defineProperty(validatedFactory, 'type', {
+      enumerable: false,
+      get: function () {
+        warn('Factory.type is deprecated. Access the class directly ' + 'before passing it to createFactory.');
+
+        Object.defineProperty(this, 'type', {
+          value: type
+        });
+        return type;
+      }
+    });
+  }
+
+  return validatedFactory;
+}
+function cloneElementWithValidation(element, props, children) {
+  var newElement = cloneElement.apply(this, arguments);
+
+  for (var i = 2; i < arguments.length; i++) {
+    validateChildKeys(arguments[i], newElement.type);
+  }
+
+  validatePropTypes(newElement);
+  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;
+      }
+    }
+  }
+}
+
+var createElement$1 =  createElementWithValidation ;
+var cloneElement$1 =  cloneElementWithValidation ;
+var createFactory =  createFactoryWithValidation ;
+var Children = {
+  map: mapChildren,
+  forEach: forEachChildren,
+  count: countChildren,
+  toArray: toArray,
+  only: onlyChild
+};
+
+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;
+exports.createElement = createElement$1;
+exports.createFactory = createFactory;
+exports.createRef = createRef;
+exports.forwardRef = forwardRef;
+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());
+}
+        
+  })();
+}
+});
+
+var require$$0 = react_production_min;
+
+var require$$1 = react_development;
+
+var react = createCommonjsModule(function (module) {
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require$$0;
+} else {
+  module.exports = require$$1;
+}
+});
+
+var React = react;
+
+/**
+ * 创建 {@link LiveReact} 实例，并提供 `React` 技术栈相关工具链。
+ */
+function createLiveReact(options) {
+    const LiveContext = React.createContext(null);
+    const live = createLive(options);
+    function LiveProvider(props) {
+        return (React.createElement(LiveContext.Provider, { value: props.live || live }, props.children));
+    }
+    function useLiveInstance() {
+        const context = React.useContext(LiveContext);
+        if (!context)
+            throw new Error('LiveProvider never found.');
+        return context;
+    }
+    /**
+     * @deprecated
+     * @returns
+     */
+    function unsafe__useLiveInstance() {
+        return useLiveInstance();
+    }
+    function useRTCInstance() {
+        const live = useLiveInstance();
+        return live.$RTC;
+    }
+    /**
+     * @deprecated
+     * @returns
+     */
+    function unsafe__useRTCInstance() {
+        return useRTCInstance();
+    }
+    function useConnect() {
+        const live = useLiveInstance();
+        return async (options) => await live.connect(options);
+    }
+    function useCurrentWebSocketUrl() {
+        const live = useLiveInstance();
+        const [state, setState] = React.useState(undefined);
+        React.useEffect(() => {
+            const onWSBeforeConnect = () => setState(live.url);
+            live.on('ws.beforeConnect', onWSBeforeConnect);
+            return () => live.off('ws.beforeConnect', onWSBeforeConnect);
+        }, [live]);
+        return state;
+    }
+    function useKeyframeUpdateCallback(name, callback, deps = []) {
+        const live = useLiveInstance();
+        const dependencyList = [live, name, ...deps];
+        const dispose = () => live.keyframes.off(name, callback);
+        React.useEffect(() => {
+            live.keyframes.on(name, callback);
+            return dispose;
+        }, dependencyList);
+        return dispose;
+    }
+    function useLiveAction() {
+        const live = useLiveInstance();
+        const toggleMicro = React.useCallback((microStatus) => live.toggleMicro(microStatus), [live]);
+        const broadcast = React.useCallback((data, toUserIds, timeout = 0) => live.broadcast(data, toUserIds, timeout), [live]);
+        const exit = React.useCallback(() => live.exit(), [live]);
+        const kick = React.useCallback((toUserIds) => live.kick(toUserIds), [live]);
+        const forbidMicro = React.useCallback((micro, toUserIds) => live.forbidMicro(micro, toUserIds), [live]);
+        // const forbidSync = React.useCallback(
+        //   (sync: boolean, toUserIds?: string | string[] | undefined) =>
+        //     live.forbidSync(sync, toUserIds),
+        //   [live],
+        // );
+        const getFramesByKey = React.useCallback((key) => live.getFramesByKey(key), [live]);
+        const sendKeyframe = React.useCallback((key, frame) => live.sendKeyframe(key, frame), [live]);
+        const setSelfInfo = React.useCallback((userInfo) => live.setSelfInfo(userInfo), [live]);
+        const updateStatus = React.useCallback((evtType, atnType, status, toUserIds) => live.updateStatus(evtType, atnType, status, toUserIds), [live]);
+        return {
+            broadcast,
+            exit,
+            kick,
+            toggleMicro,
+            forbidMicro,
+            // forbidSync,
+            sendKeyframe,
+            getFramesByKey,
+            setSelfInfo,
+            updateStatus,
+        };
+    }
+    function useKeyframe(key) {
+        const live = useLiveInstance();
+        const [state, updateState] = React.useState(live.getFramesByKey(key));
+        React.useEffect(() => {
+            const onUpdate = (nextKeyframes) => updateState(nextKeyframes);
+            const evtName = key;
+            const callback = onUpdate;
+            live.keyframes.on(evtName, callback);
+            return () => live.keyframes.off(evtName, callback);
+        }, [live]);
+        const setState = React.useCallback((frame) => live.sendKeyframe(key, frame), [live]);
+        return [state, setState];
+    }
+    function useLiveEventCallback(name, callback, deps = []) {
+        const live = useLiveInstance();
+        const dispose = () => live.off(name, callback);
+        const dependencyList = [live, name, ...deps];
+        React.useEffect(() => {
+            live.on(name, callback);
+            return dispose;
+        }, dependencyList);
+        return dispose;
+    }
+    /**
+     * @deprecated
+     * @returns
+     */
+    function useReadyState() {
+        const live = useLiveInstance();
+        const [state, updateState] = React.useState(live.readyState);
+        React.useEffect(() => {
+            const readyStateUpdate = (readyState) => updateState(readyState);
+            live.on('ws.readyStateUpdate', readyStateUpdate);
+            return () => live.off('ws.readyStateUpdate', readyStateUpdate);
+        }, [live]);
+        return state;
+    }
+    function useRTCAction() {
+        const live = useLiveInstance();
+        const join = React.useCallback((options) => live.$RTC.join(options), [live]);
+        const quit = React.useCallback(() => live.$RTC.quit(), [live]);
+        const shock = React.useCallback(() => { var _a, _b; return (_b = (_a = live.$RTC).shock) === null || _b === void 0 ? void 0 : _b.call(_a); }, [live]);
+        const toggleMicro = React.useCallback((flag) => live.$RTC.toggleMicro(flag), [live]);
+        const detectMicro = React.useCallback(() => live.$RTC.detectMicro(), [live]);
+        return {
+            join,
+            quit,
+            shock,
+            toggleMicro,
+            detectMicro,
+        };
+    }
+    function useRTCEventCallback(name, callback, deps = []) {
+        const live = useLiveInstance();
+        const dispose = () => live.$RTC.off(name, callback);
+        const dependencyList = [live, name, ...deps];
+        React.useEffect(() => {
+            live.$RTC.on(name, callback);
+            return dispose;
+        }, dependencyList);
+        return dispose;
+    }
+    function useSelfInfo() {
+        const live = useLiveInstance();
+        const [state, updateState] = React.useState(live.selfInfo || {});
+        const selfInfoUpdate = (userInfo) => updateState(userInfo);
+        React.useEffect(() => {
+            live.on('selfInfoUpdate', selfInfoUpdate);
+            return () => live.off('selfInfoUpdate', selfInfoUpdate);
+        }, [live]);
+        const setState = React.useCallback(async (userInfo) => {
+            return await live.setSelfInfo(userInfo);
+        }, [live]);
+        return [state, setState];
+    }
+    function useSnapshot() {
+        const live = useLiveInstance();
+        const [state, setState] = React.useState(live.snapshot);
+        React.useEffect(() => {
+            const onKeyframes = (keyframes) => setState(keyframes);
+            live.on('keyframes', onKeyframes);
+            return () => live.off('keyframes', onKeyframes);
+        });
+        return state;
+    }
+    function useUserList() {
+        const live = useLiveInstance();
+        const [state, updateState] = React.useState(live.userList);
+        const userListUpdate = (userList) => updateState(userList);
+        React.useEffect(() => {
+            live.on('userListUpdate', userListUpdate);
+            return () => live.off('userListUpdate', userListUpdate);
+        }, [live]);
+        return state;
+    }
+    /**
+     *
+     * @param name
+     * @param callback
+     * @param deps
+     * @returns
+     * @deprecated
+     */
+    function useWebSocketEventCallback(name, callback, deps = []) {
+        const live = useLiveInstance();
+        const dispose = () => live.off(name, callback);
+        const dependencyList = [live, name, ...deps];
+        React.useEffect(() => {
+            live.on(name, callback);
+            return dispose;
+        }, dependencyList);
+        return dispose;
+    }
+    return {
+        live,
+        LiveProvider,
+        unsafe__useLiveInstance,
+        unsafe__useRTCInstance,
+        useCurrentWebSocketUrl,
+        useConnect,
+        useKeyframe,
+        useKeyframeUpdateCallback,
+        useLiveAction,
+        useLiveEventCallback,
+        useReadyState,
+        useRTCAction,
+        useRTCEventCallback,
+        useSelfInfo,
+        useSnapshot,
+        useUserList,
+        useWebSocketEventCallback,
+    };
+}
+
+exports.BrowserRTC = BrowserRTC;
+exports.BrowserRTC4Chime = BrowserRTC4Chime;
+exports.CoreRTC = CoreRTC;
+exports.VRWebViewRTC = VRWebViewRTC;
+exports.createLive = createLive;
+exports.createLiveReact = createLiveReact;
+exports.parseLiveMsg = parseLiveMsg;
+exports.parseWSClsErr = parseWSClsErr;
+//# sourceMappingURL=realsee-live.cjs.development.js.map