@hehanlin/open-agent-bridge 0.6.3 → 0.6.4

package/node_modules/@byted/frontier-web-sdk/lib/fws.umd.js

@@ -0,0 +1,2699 @@
+(function(root, factory) {
+    if ('object' == typeof exports && 'object' == typeof module) module.exports = factory();
+    else if ('function' == typeof define && define.amd) define([], factory);
+    else if ('object' == typeof exports) exports["fws"] = factory();
+    else root["fws"] = factory();
+})(globalThis, ()=>(()=>{
+        "use strict";
+        var __webpack_modules__ = {
+            "../../node_modules/.pnpm/idb@7.0.2/node_modules/idb/build/index.js": function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+                __webpack_require__.r(__webpack_exports__);
+                __webpack_require__.d(__webpack_exports__, {
+                    deleteDB: ()=>deleteDB,
+                    wrap: ()=>wrap,
+                    openDB: ()=>openDB,
+                    unwrap: ()=>unwrap
+                });
+                const instanceOfAny = (object, constructors)=>constructors.some((c)=>object instanceof c);
+                let idbProxyableTypes;
+                let cursorAdvanceMethods;
+                function getIdbProxyableTypes() {
+                    return idbProxyableTypes || (idbProxyableTypes = [
+                        IDBDatabase,
+                        IDBObjectStore,
+                        IDBIndex,
+                        IDBCursor,
+                        IDBTransaction
+                    ]);
+                }
+                function getCursorAdvanceMethods() {
+                    return cursorAdvanceMethods || (cursorAdvanceMethods = [
+                        IDBCursor.prototype.advance,
+                        IDBCursor.prototype.continue,
+                        IDBCursor.prototype.continuePrimaryKey
+                    ]);
+                }
+                const cursorRequestMap = new WeakMap();
+                const transactionDoneMap = new WeakMap();
+                const transactionStoreNamesMap = new WeakMap();
+                const transformCache = new WeakMap();
+                const reverseTransformCache = new WeakMap();
+                function promisifyRequest(request) {
+                    const promise = new Promise((resolve, reject)=>{
+                        const unlisten = ()=>{
+                            request.removeEventListener('success', success);
+                            request.removeEventListener('error', error);
+                        };
+                        const success = ()=>{
+                            resolve(wrap(request.result));
+                            unlisten();
+                        };
+                        const error = ()=>{
+                            reject(request.error);
+                            unlisten();
+                        };
+                        request.addEventListener('success', success);
+                        request.addEventListener('error', error);
+                    });
+                    promise.then((value)=>{
+                        if (value instanceof IDBCursor) cursorRequestMap.set(value, request);
+                    }).catch(()=>{});
+                    reverseTransformCache.set(promise, request);
+                    return promise;
+                }
+                function cacheDonePromiseForTransaction(tx) {
+                    if (transactionDoneMap.has(tx)) return;
+                    const done = new Promise((resolve, reject)=>{
+                        const unlisten = ()=>{
+                            tx.removeEventListener('complete', complete);
+                            tx.removeEventListener('error', error);
+                            tx.removeEventListener('abort', error);
+                        };
+                        const complete = ()=>{
+                            resolve();
+                            unlisten();
+                        };
+                        const error = ()=>{
+                            reject(tx.error || new DOMException('AbortError', 'AbortError'));
+                            unlisten();
+                        };
+                        tx.addEventListener('complete', complete);
+                        tx.addEventListener('error', error);
+                        tx.addEventListener('abort', error);
+                    });
+                    transactionDoneMap.set(tx, done);
+                }
+                let idbProxyTraps = {
+                    get (target, prop, receiver) {
+                        if (target instanceof IDBTransaction) {
+                            if ('done' === prop) return transactionDoneMap.get(target);
+                            if ('objectStoreNames' === prop) return target.objectStoreNames || transactionStoreNamesMap.get(target);
+                            if ('store' === prop) return receiver.objectStoreNames[1] ? void 0 : receiver.objectStore(receiver.objectStoreNames[0]);
+                        }
+                        return wrap(target[prop]);
+                    },
+                    set (target, prop, value) {
+                        target[prop] = value;
+                        return true;
+                    },
+                    has (target, prop) {
+                        if (target instanceof IDBTransaction && ('done' === prop || 'store' === prop)) return true;
+                        return prop in target;
+                    }
+                };
+                function replaceTraps(callback) {
+                    idbProxyTraps = callback(idbProxyTraps);
+                }
+                function wrapFunction(func) {
+                    if (func === IDBDatabase.prototype.transaction && !('objectStoreNames' in IDBTransaction.prototype)) return function(storeNames, ...args) {
+                        const tx = func.call(unwrap(this), storeNames, ...args);
+                        transactionStoreNamesMap.set(tx, storeNames.sort ? storeNames.sort() : [
+                            storeNames
+                        ]);
+                        return wrap(tx);
+                    };
+                    if (getCursorAdvanceMethods().includes(func)) return function(...args) {
+                        func.apply(unwrap(this), args);
+                        return wrap(cursorRequestMap.get(this));
+                    };
+                    return function(...args) {
+                        return wrap(func.apply(unwrap(this), args));
+                    };
+                }
+                function transformCachableValue(value) {
+                    if ('function' == typeof value) return wrapFunction(value);
+                    if (value instanceof IDBTransaction) cacheDonePromiseForTransaction(value);
+                    if (instanceOfAny(value, getIdbProxyableTypes())) return new Proxy(value, idbProxyTraps);
+                    return value;
+                }
+                function wrap(value) {
+                    if (value instanceof IDBRequest) return promisifyRequest(value);
+                    if (transformCache.has(value)) return transformCache.get(value);
+                    const newValue = transformCachableValue(value);
+                    if (newValue !== value) {
+                        transformCache.set(value, newValue);
+                        reverseTransformCache.set(newValue, value);
+                    }
+                    return newValue;
+                }
+                const unwrap = (value)=>reverseTransformCache.get(value);
+                function openDB(name, version, { blocked, upgrade, blocking, terminated } = {}) {
+                    const request = indexedDB.open(name, version);
+                    const openPromise = wrap(request);
+                    if (upgrade) request.addEventListener('upgradeneeded', (event)=>{
+                        upgrade(wrap(request.result), event.oldVersion, event.newVersion, wrap(request.transaction));
+                    });
+                    if (blocked) request.addEventListener('blocked', ()=>blocked());
+                    openPromise.then((db)=>{
+                        if (terminated) db.addEventListener('close', ()=>terminated());
+                        if (blocking) db.addEventListener('versionchange', ()=>blocking());
+                    }).catch(()=>{});
+                    return openPromise;
+                }
+                function deleteDB(name, { blocked } = {}) {
+                    const request = indexedDB.deleteDatabase(name);
+                    if (blocked) request.addEventListener('blocked', ()=>blocked());
+                    return wrap(request).then(()=>void 0);
+                }
+                const readMethods = [
+                    'get',
+                    'getKey',
+                    'getAll',
+                    'getAllKeys',
+                    'count'
+                ];
+                const writeMethods = [
+                    'put',
+                    'add',
+                    'delete',
+                    'clear'
+                ];
+                const cachedMethods = new Map();
+                function getMethod(target, prop) {
+                    if (!(target instanceof IDBDatabase && !(prop in target) && 'string' == typeof prop)) return;
+                    if (cachedMethods.get(prop)) return cachedMethods.get(prop);
+                    const targetFuncName = prop.replace(/FromIndex$/, '');
+                    const useIndex = prop !== targetFuncName;
+                    const isWrite = writeMethods.includes(targetFuncName);
+                    if (!(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) || !(isWrite || readMethods.includes(targetFuncName))) return;
+                    const method = async function(storeName, ...args) {
+                        const tx = this.transaction(storeName, isWrite ? 'readwrite' : 'readonly');
+                        let target = tx.store;
+                        if (useIndex) target = target.index(args.shift());
+                        return (await Promise.all([
+                            target[targetFuncName](...args),
+                            isWrite && tx.done
+                        ]))[0];
+                    };
+                    cachedMethods.set(prop, method);
+                    return method;
+                }
+                replaceTraps((oldTraps)=>({
+                        ...oldTraps,
+                        get: (target, prop, receiver)=>getMethod(target, prop) || oldTraps.get(target, prop, receiver),
+                        has: (target, prop)=>!!getMethod(target, prop) || oldTraps.has(target, prop)
+                    }));
+            }
+        };
+        var __webpack_module_cache__ = {};
+        function __webpack_require__(moduleId) {
+            var cachedModule = __webpack_module_cache__[moduleId];
+            if (void 0 !== cachedModule) return cachedModule.exports;
+            var module1 = __webpack_module_cache__[moduleId] = {
+                exports: {}
+            };
+            __webpack_modules__[moduleId](module1, module1.exports, __webpack_require__);
+            return module1.exports;
+        }
+        (()=>{
+            __webpack_require__.d = (exports1, definition)=>{
+                for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                    enumerable: true,
+                    get: definition[key]
+                });
+            };
+        })();
+        (()=>{
+            __webpack_require__.g = (()=>{
+                if ('object' == typeof globalThis) return globalThis;
+                try {
+                    return this || new Function('return this')();
+                } catch (e) {
+                    if ('object' == typeof window) return window;
+                }
+            })();
+        })();
+        (()=>{
+            __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+        })();
+        (()=>{
+            __webpack_require__.r = (exports1)=>{
+                if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+                    value: 'Module'
+                });
+                Object.defineProperty(exports1, '__esModule', {
+                    value: true
+                });
+            };
+        })();
+        var __webpack_exports__ = {};
+        (()=>{
+            __webpack_require__.r(__webpack_exports__);
+            __webpack_require__.d(__webpack_exports__, {
+                FWS: ()=>FWS,
+                CustomErrorEvent: ()=>CustomErrorEvent,
+                createCloseEvent: ()=>createCloseEvent,
+                ReconnectEvent: ()=>ReconnectEvent,
+                createErrorEvent: ()=>createErrorEvent,
+                decodedFrame: ()=>decodedFrame,
+                createOpenEvent: ()=>createOpenEvent,
+                CustomCloseEvent: ()=>CustomCloseEvent,
+                createReconnectEvent: ()=>createReconnectEvent,
+                FrontierMessageEvent: ()=>FrontierMessageEvent,
+                encodeFrame: ()=>protobuf_encodeFrame,
+                createMessageEvent: ()=>createMessageEvent,
+                OpenEvent: ()=>OpenEvent,
+                ErrorCode: ()=>event_ErrorCode,
+                Event: ()=>Event,
+                MessageEvent: ()=>MessageEvent
+            });
+            let cachedIP = '';
+            function genLogIDNew(ip = '') {
+                const version = '02';
+                const timeStamp = `${Date.now()}`;
+                const v6Addr = cachedIP || (cachedIP = IPToIPv6(ip));
+                const rand = Math.random().toString(16).slice(-6);
+                return version + timeStamp + v6Addr + rand;
+            }
+            function genLogID() {
+                return 10000 * Date.now() + Math.floor(10000 * Math.random());
+            }
+            function ocetToBinary(ocetStr) {
+                return (Array(8).join('0') + parseInt(ocetStr, 10).toString(2)).slice(-8);
+            }
+            function binaryToHex(binaryStr) {
+                return (Array(4).join('0') + parseInt(binaryStr, 2).toString(16)).slice(-4);
+            }
+            function IPv4ToIPv6(v4Addr) {
+                const v4AddrBytes = v4Addr.split(/\./).map((ocetPart)=>ocetToBinary(ocetPart));
+                const v6AddrBytes = [];
+                v6AddrBytes[0] = binaryToHex(v4AddrBytes[0] + v4AddrBytes[1]);
+                v6AddrBytes[1] = binaryToHex(v4AddrBytes[2] + v4AddrBytes[3]);
+                const v6Addr = [
+                    '0000',
+                    '0000',
+                    '0000',
+                    '0000',
+                    '0000',
+                    'ffff',
+                    v6AddrBytes[0],
+                    v6AddrBytes[1]
+                ];
+                return v6Addr.join('');
+            }
+            function IPToIPv6(ip) {
+                const isIPv4 = /(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}/.test(ip);
+                const isIPv6 = /(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))/.test(ip);
+                return isIPv4 ? IPv4ToIPv6(ip) : isIPv6 ? formatIpv6Address(ip) : '00000000000000000000000000000000';
+            }
+            function formatIpv6Address(address) {
+                let result = '';
+                const resultParts = [];
+                let zerosPos = 0;
+                let partNums = 0;
+                let zerosPosFlag = true;
+                const ZERO_PART = '0000';
+                if (address.indexOf('::') > -1) {
+                    const parts = address.split('::');
+                    for(let i = 0; i < parts.length; i++){
+                        const part = parts[i];
+                        if (part.indexOf(':') > 0) {
+                            const subPart = part.split(':');
+                            if (zerosPosFlag) zerosPos = subPart.length;
+                            partNums += subPart.length;
+                            for(let j = 0; j < subPart.length; j++)if (4 !== subPart[j].length) {
+                                const zeroPad = ZERO_PART.substring(0, 4 - subPart[j].length);
+                                const partWithPad = zeroPad.concat(subPart[j]);
+                                resultParts.push(partWithPad);
+                            } else resultParts.push(subPart[j]);
+                            zerosPosFlag = false;
+                        } else {
+                            if (4 !== part.length) {
+                                const zeroPad = ZERO_PART.substring(0, 4 - part.length);
+                                const partWithPad = zeroPad.concat(part);
+                                resultParts.push(partWithPad);
+                            } else resultParts.push(part);
+                            if (zerosPosFlag) zerosPos += 1;
+                            partNums += 1;
+                            zerosPosFlag = false;
+                        }
+                    }
+                    let zeros = '';
+                    for(let h = 0; h < 8 - partNums; h++)zeros = zeros.concat(ZERO_PART);
+                    for(let y = 0; y < resultParts.length; y++)if (y === zerosPos) {
+                        result = result.concat(zeros);
+                        result = result.concat(resultParts[y]);
+                    } else result = result.concat(resultParts[y]);
+                    return result;
+                }
+                {
+                    const parts = address.split(':');
+                    for(let i = 0; i < parts.length; i++){
+                        const part = parts[i];
+                        if (4 !== parts[i].length) {
+                            const zeroPad = ZERO_PART.substring(0, 4 - parts[i].length);
+                            const partWithPad = zeroPad.concat(part);
+                            result = result.concat(partWithPad);
+                        } else result = result.concat(part);
+                    }
+                    return result;
+                }
+            }
+            function _encodeHeader(message, bb) {
+                const $key = message.key;
+                if (void 0 !== $key) {
+                    writeVarint32(bb, 10);
+                    writeString(bb, $key);
+                }
+                const $value = message.value;
+                if (void 0 !== $value) {
+                    writeVarint32(bb, 18);
+                    writeString(bb, $value);
+                }
+            }
+            function _decodeHeader(bb) {
+                const message = {};
+                end_of_message: while(!isAtEnd(bb)){
+                    const tag = readVarint32(bb);
+                    switch(tag >>> 3){
+                        case 0:
+                            break end_of_message;
+                        case 1:
+                            message.key = readString(bb, readVarint32(bb));
+                            break;
+                        case 2:
+                            message.value = readString(bb, readVarint32(bb));
+                            break;
+                        default:
+                            skipUnknownField(bb, 7 & tag);
+                    }
+                }
+                if (void 0 === message.key) throw new Error('Missing required field: key');
+                if (void 0 === message.value) throw new Error('Missing required field: value');
+                return message;
+            }
+            function encodeFrame(message) {
+                const bb = popByteBuffer();
+                _encodeFrame(message, bb);
+                return toUint8Array(bb);
+            }
+            function _encodeFrame(message, bb) {
+                const $SeqID = message.SeqID;
+                if (void 0 !== $SeqID) {
+                    writeVarint32(bb, 8);
+                    writeVarint64(bb, $SeqID);
+                }
+                const $LogID = message.LogID;
+                if (void 0 !== $LogID) {
+                    writeVarint32(bb, 16);
+                    writeVarint64(bb, $LogID);
+                }
+                const $service = message.service;
+                if (void 0 !== $service) {
+                    writeVarint32(bb, 24);
+                    writeVarint64(bb, intToLong($service));
+                }
+                const $method = message.method;
+                if (void 0 !== $method) {
+                    writeVarint32(bb, 32);
+                    writeVarint64(bb, intToLong($method));
+                }
+                const array$headers = message.headers;
+                if (void 0 !== array$headers) for (const value of array$headers){
+                    writeVarint32(bb, 42);
+                    const nested = popByteBuffer();
+                    _encodeHeader(value, nested);
+                    writeVarint32(bb, nested.limit);
+                    writeByteBuffer(bb, nested);
+                    pushByteBuffer(nested);
+                }
+                const $payload_encoding = message.payloadEncoding;
+                if (void 0 !== $payload_encoding) {
+                    writeVarint32(bb, 50);
+                    writeString(bb, $payload_encoding);
+                }
+                const $payload_type = message.payloadType;
+                if (void 0 !== $payload_type) {
+                    writeVarint32(bb, 58);
+                    writeString(bb, $payload_type);
+                }
+                const $payload = message.payload;
+                if (void 0 !== $payload) {
+                    writeVarint32(bb, 66);
+                    writeVarint32(bb, $payload.length), writeBytes(bb, $payload);
+                }
+                const $LogIDNew = message.LogIDNew;
+                if (void 0 !== $LogIDNew) {
+                    writeVarint32(bb, 74);
+                    writeString(bb, $LogIDNew);
+                }
+                const $server_timing = message.serverTiming;
+                if (void 0 !== $server_timing) {
+                    writeVarint32(bb, 82);
+                    writeString(bb, $server_timing);
+                }
+                const $msg_id = message.msgID;
+                if (void 0 !== $msg_id) {
+                    writeVarint32(bb, 90);
+                    writeString(bb, $msg_id);
+                }
+                const $frame_type = message.frameType;
+                if (void 0 !== $frame_type) {
+                    writeVarint32(bb, 96);
+                    writeVarint64(bb, intToLong($frame_type));
+                }
+            }
+            function decodeFrame(binary) {
+                return _decodeFrame(wrapByteBuffer(binary));
+            }
+            function _decodeFrame(bb) {
+                const message = {};
+                end_of_message: while(!isAtEnd(bb)){
+                    const tag = readVarint32(bb);
+                    switch(tag >>> 3){
+                        case 0:
+                            break end_of_message;
+                        case 1:
+                            message.SeqID = readVarint64(bb, true);
+                            break;
+                        case 2:
+                            message.LogID = readVarint64(bb, true);
+                            break;
+                        case 3:
+                            message.service = readVarint32(bb);
+                            break;
+                        case 4:
+                            message.method = readVarint32(bb);
+                            break;
+                        case 5:
+                            {
+                                const limit = pushTemporaryLength(bb);
+                                const values = message.headers || (message.headers = []);
+                                values.push(_decodeHeader(bb));
+                                bb.limit = limit;
+                                break;
+                            }
+                        case 6:
+                            message.payloadEncoding = readString(bb, readVarint32(bb));
+                            break;
+                        case 7:
+                            message.payloadType = readString(bb, readVarint32(bb));
+                            break;
+                        case 8:
+                            message.payload = readBytes(bb, readVarint32(bb));
+                            break;
+                        case 9:
+                            message.LogIDNew = readString(bb, readVarint32(bb));
+                            break;
+                        case 10:
+                            message.serverTiming = readString(bb, readVarint32(bb));
+                            break;
+                        case 11:
+                            message.msgID = readString(bb, readVarint32(bb));
+                            break;
+                        case 12:
+                            message.frameType = readVarint32(bb);
+                            break;
+                        default:
+                            skipUnknownField(bb, 7 & tag);
+                    }
+                }
+                if (void 0 === message.SeqID) throw new Error('Missing required field: SeqID');
+                if (void 0 === message.LogID) throw new Error('Missing required field: LogID');
+                if (void 0 === message.service) throw new Error('Missing required field: service');
+                if (void 0 === message.method) throw new Error('Missing required field: method');
+                return message;
+            }
+            function pushTemporaryLength(bb) {
+                const length = readVarint32(bb);
+                const limit = bb.limit;
+                bb.limit = bb.offset + length;
+                return limit;
+            }
+            function skipUnknownField(bb, type) {
+                switch(type){
+                    case 0:
+                        while(0x80 & readByte(bb));
+                        break;
+                    case 2:
+                        skip(bb, readVarint32(bb));
+                        break;
+                    case 5:
+                        skip(bb, 4);
+                        break;
+                    case 1:
+                        skip(bb, 8);
+                        break;
+                    default:
+                        throw new Error('Unimplemented type: ' + type);
+                }
+            }
+            function intToLong(value) {
+                value |= 0;
+                return {
+                    low: value,
+                    high: value >> 31,
+                    unsigned: value >= 0
+                };
+            }
+            const bbStack = [];
+            function popByteBuffer() {
+                const bb = bbStack.pop();
+                if (!bb) return {
+                    bytes: new Uint8Array(64),
+                    offset: 0,
+                    limit: 0
+                };
+                bb.offset = bb.limit = 0;
+                return bb;
+            }
+            function pushByteBuffer(bb) {
+                bbStack.push(bb);
+            }
+            function wrapByteBuffer(bytes) {
+                return {
+                    bytes,
+                    offset: 0,
+                    limit: bytes.length
+                };
+            }
+            function toUint8Array(bb) {
+                const bytes = bb.bytes;
+                const limit = bb.limit;
+                return bytes.length === limit ? bytes : bytes.subarray(0, limit);
+            }
+            function skip(bb, offset) {
+                if (bb.offset + offset > bb.limit) throw new Error('Skip past limit');
+                bb.offset += offset;
+            }
+            function isAtEnd(bb) {
+                return bb.offset >= bb.limit;
+            }
+            function grow(bb, count) {
+                const bytes = bb.bytes;
+                const offset = bb.offset;
+                const limit = bb.limit;
+                const finalOffset = offset + count;
+                if (finalOffset > bytes.length) {
+                    const newBytes = new Uint8Array(2 * finalOffset);
+                    newBytes.set(bytes);
+                    bb.bytes = newBytes;
+                }
+                bb.offset = finalOffset;
+                if (finalOffset > limit) bb.limit = finalOffset;
+                return offset;
+            }
+            function advance(bb, count) {
+                const offset = bb.offset;
+                if (offset + count > bb.limit) throw new Error('Read past limit');
+                bb.offset += count;
+                return offset;
+            }
+            function readBytes(bb, count) {
+                const offset = advance(bb, count);
+                return bb.bytes.subarray(offset, offset + count);
+            }
+            function writeBytes(bb, buffer) {
+                const offset = grow(bb, buffer.length);
+                bb.bytes.set(buffer, offset);
+            }
+            function readString(bb, count) {
+                const offset = advance(bb, count);
+                const fromCharCode = String.fromCharCode;
+                const bytes = bb.bytes;
+                const invalid = '\uFFFD';
+                let text = '';
+                for(let i = 0; i < count; i++){
+                    const c1 = bytes[i + offset];
+                    let c2, c3, c4, c;
+                    if ((0x80 & c1) === 0) text += fromCharCode(c1);
+                    else if ((0xe0 & c1) === 0xc0) if (i + 1 >= count) text += invalid;
+                    else {
+                        c2 = bytes[i + offset + 1];
+                        if ((0xc0 & c2) !== 0x80) text += invalid;
+                        else {
+                            c = (0x1f & c1) << 6 | 0x3f & c2;
+                            if (c < 0x80) text += invalid;
+                            else {
+                                text += fromCharCode(c);
+                                i++;
+                            }
+                        }
+                    }
+                    else if ((0xf0 & c1) == 0xe0) if (i + 2 >= count) text += invalid;
+                    else {
+                        c2 = bytes[i + offset + 1];
+                        c3 = bytes[i + offset + 2];
+                        if (((c2 | c3 << 8) & 0xc0c0) !== 0x8080) text += invalid;
+                        else {
+                            c = (0x0f & c1) << 12 | (0x3f & c2) << 6 | 0x3f & c3;
+                            if (c < 0x0800 || c >= 0xd800 && c <= 0xdfff) text += invalid;
+                            else {
+                                text += fromCharCode(c);
+                                i += 2;
+                            }
+                        }
+                    }
+                    else if ((0xf8 & c1) == 0xf0) if (i + 3 >= count) text += invalid;
+                    else {
+                        c2 = bytes[i + offset + 1];
+                        c3 = bytes[i + offset + 2];
+                        c4 = bytes[i + offset + 3];
+                        if (((c2 | c3 << 8 | c4 << 16) & 0xc0c0c0) !== 0x808080) text += invalid;
+                        else {
+                            c = (0x07 & c1) << 0x12 | (0x3f & c2) << 0x0c | (0x3f & c3) << 0x06 | 0x3f & c4;
+                            if (c < 0x10000 || c > 0x10ffff) text += invalid;
+                            else {
+                                c -= 0x10000;
+                                text += fromCharCode((c >> 10) + 0xd800, (0x3ff & c) + 0xdc00);
+                                i += 3;
+                            }
+                        }
+                    }
+                    else text += invalid;
+                }
+                return text;
+            }
+            function writeString(bb, text) {
+                const n = text.length;
+                let byteCount = 0;
+                for(let i = 0; i < n; i++){
+                    let c = text.charCodeAt(i);
+                    if (c >= 0xd800 && c <= 0xdbff && i + 1 < n) c = (c << 10) + text.charCodeAt(++i) - 0x35fdc00;
+                    byteCount += c < 0x80 ? 1 : c < 0x800 ? 2 : c < 0x10000 ? 3 : 4;
+                }
+                writeVarint32(bb, byteCount);
+                let offset = grow(bb, byteCount);
+                const bytes = bb.bytes;
+                for(let i = 0; i < n; i++){
+                    let c = text.charCodeAt(i);
+                    if (c >= 0xd800 && c <= 0xdbff && i + 1 < n) c = (c << 10) + text.charCodeAt(++i) - 0x35fdc00;
+                    if (c < 0x80) bytes[offset++] = c;
+                    else {
+                        if (c < 0x800) bytes[offset++] = c >> 6 & 0x1f | 0xc0;
+                        else {
+                            if (c < 0x10000) bytes[offset++] = c >> 12 & 0x0f | 0xe0;
+                            else {
+                                bytes[offset++] = c >> 18 & 0x07 | 0xf0;
+                                bytes[offset++] = c >> 12 & 0x3f | 0x80;
+                            }
+                            bytes[offset++] = c >> 6 & 0x3f | 0x80;
+                        }
+                        bytes[offset++] = 0x3f & c | 0x80;
+                    }
+                }
+            }
+            function writeByteBuffer(bb, buffer) {
+                const offset = grow(bb, buffer.limit);
+                const from = bb.bytes;
+                const to = buffer.bytes;
+                for(let i = 0, n = buffer.limit; i < n; i++)from[i + offset] = to[i];
+            }
+            function readByte(bb) {
+                return bb.bytes[advance(bb, 1)];
+            }
+            function writeByte(bb, value) {
+                const offset = grow(bb, 1);
+                bb.bytes[offset] = value;
+            }
+            function readVarint32(bb) {
+                let c = 0;
+                let value = 0;
+                let b;
+                do {
+                    b = readByte(bb);
+                    if (c < 32) value |= (0x7f & b) << c;
+                    c += 7;
+                }while (0x80 & b);
+                return value;
+            }
+            function writeVarint32(bb, value) {
+                value >>>= 0;
+                while(value >= 0x80){
+                    writeByte(bb, 0x7f & value | 0x80);
+                    value >>>= 7;
+                }
+                writeByte(bb, value);
+            }
+            function readVarint64(bb, unsigned) {
+                let part0 = 0;
+                let part1 = 0;
+                let part2 = 0;
+                let b;
+                b = readByte(bb);
+                part0 = 0x7f & b;
+                if (0x80 & b) {
+                    b = readByte(bb);
+                    part0 |= (0x7f & b) << 7;
+                    if (0x80 & b) {
+                        b = readByte(bb);
+                        part0 |= (0x7f & b) << 14;
+                        if (0x80 & b) {
+                            b = readByte(bb);
+                            part0 |= (0x7f & b) << 21;
+                            if (0x80 & b) {
+                                b = readByte(bb);
+                                part1 = 0x7f & b;
+                                if (0x80 & b) {
+                                    b = readByte(bb);
+                                    part1 |= (0x7f & b) << 7;
+                                    if (0x80 & b) {
+                                        b = readByte(bb);
+                                        part1 |= (0x7f & b) << 14;
+                                        if (0x80 & b) {
+                                            b = readByte(bb);
+                                            part1 |= (0x7f & b) << 21;
+                                            if (0x80 & b) {
+                                                b = readByte(bb);
+                                                part2 = 0x7f & b;
+                                                if (0x80 & b) {
+                                                    b = readByte(bb);
+                                                    part2 |= (0x7f & b) << 7;
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                return {
+                    low: part0 | part1 << 28,
+                    high: part1 >>> 4 | part2 << 24,
+                    unsigned
+                };
+            }
+            function writeVarint64(bb, value) {
+                const part0 = value.low >>> 0;
+                const part1 = (value.low >>> 28 | value.high << 4) >>> 0;
+                const part2 = value.high >>> 24;
+                const size = 0 === part2 ? 0 === part1 ? part0 < 16384 ? part0 < 128 ? 1 : 2 : part0 < 2097152 ? 3 : 4 : part1 < 16384 ? part1 < 128 ? 5 : 6 : part1 < 2097152 ? 7 : 8 : part2 < 128 ? 9 : 10;
+                const offset = grow(bb, size);
+                const bytes = bb.bytes;
+                switch(size){
+                    case 10:
+                        bytes[offset + 9] = part2 >>> 7 & 0x01;
+                    case 9:
+                        bytes[offset + 8] = 9 !== size ? 0x80 | part2 : 0x7f & part2;
+                    case 8:
+                        bytes[offset + 7] = 8 !== size ? part1 >>> 21 | 0x80 : part1 >>> 21 & 0x7f;
+                    case 7:
+                        bytes[offset + 6] = 7 !== size ? part1 >>> 14 | 0x80 : part1 >>> 14 & 0x7f;
+                    case 6:
+                        bytes[offset + 5] = 6 !== size ? part1 >>> 7 | 0x80 : part1 >>> 7 & 0x7f;
+                    case 5:
+                        bytes[offset + 4] = 5 !== size ? 0x80 | part1 : 0x7f & part1;
+                    case 4:
+                        bytes[offset + 3] = 4 !== size ? part0 >>> 21 | 0x80 : part0 >>> 21 & 0x7f;
+                    case 3:
+                        bytes[offset + 2] = 3 !== size ? part0 >>> 14 | 0x80 : part0 >>> 14 & 0x7f;
+                    case 2:
+                        bytes[offset + 1] = 2 !== size ? part0 >>> 7 | 0x80 : part0 >>> 7 & 0x7f;
+                    case 1:
+                        bytes[offset] = 1 !== size ? 0x80 | part0 : 0x7f & part0;
+                }
+            }
+            function decodedFrame(buffer) {
+                return decodeFrame(buffer);
+            }
+            function protobuf_encodeFrame(message) {
+                return encodeFrame(message);
+            }
+            const TWO_PWR_16_DBL = 65536;
+            const ZERO_HASH = '\0\0\0\0\0\0\0\0';
+            const TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL;
+            const TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL;
+            const TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2;
+            const charCodeAt = String.prototype.charCodeAt;
+            class long_Long {
+                constructor(low, high, unsigned){
+                    this.isLong = true;
+                    this.low = 0 | low;
+                    this.high = 0 | high;
+                    this.unsigned = !!unsigned;
+                }
+                static isLong(obj) {
+                    return obj && true === obj.isLong;
+                }
+                static fromBits(lowBits, highBits, unsigned) {
+                    return new long_Long(lowBits, highBits, unsigned);
+                }
+                static fromBytes(bytes, unsigned, le) {
+                    return le ? long_Long.fromBytesLE(bytes, unsigned) : long_Long.fromBytesBE(bytes, unsigned);
+                }
+                static fromBytesLE(bytes, unsigned) {
+                    return new long_Long(bytes[0] | bytes[1] << 8 | bytes[2] << 16 | bytes[3] << 24, bytes[4] | bytes[5] << 8 | bytes[6] << 16 | bytes[7] << 24, unsigned);
+                }
+                static fromBytesBE(bytes, unsigned) {
+                    return new long_Long(bytes[4] << 24 | bytes[5] << 16 | bytes[6] << 8 | bytes[7], bytes[0] << 24 | bytes[1] << 16 | bytes[2] << 8 | bytes[3], unsigned);
+                }
+                static fromHash(hash) {
+                    if (hash === ZERO_HASH) return ZERO;
+                    return new long_Long((charCodeAt.call(hash, 0) | charCodeAt.call(hash, 1) << 8 | charCodeAt.call(hash, 2) << 16 | charCodeAt.call(hash, 3) << 24) >>> 0, (charCodeAt.call(hash, 4) | charCodeAt.call(hash, 5) << 8 | charCodeAt.call(hash, 6) << 16 | charCodeAt.call(hash, 7) << 24) >>> 0, true);
+                }
+                toHash() {
+                    return String.fromCharCode(255 & this.low, this.low >>> 8 & 255, this.low >>> 16 & 255, this.low >>> 24, 255 & this.high, this.high >>> 8 & 255, this.high >>> 16 & 255, this.high >>> 24);
+                }
+                static fromNumber(value, unsigned = true) {
+                    if (isNaN(value)) return unsigned ? UNSIGNED_ZERO : ZERO;
+                    if (unsigned) {
+                        if (value >= TWO_PWR_64_DBL) return MAX_UNSIGNED_VALUE;
+                    } else {
+                        if (value <= -TWO_PWR_63_DBL) return MIN_VALUE;
+                        if (value + 1 >= TWO_PWR_63_DBL) return MAX_VALUE;
+                    }
+                    return long_Long.fromBits(value % TWO_PWR_32_DBL | 0, value / TWO_PWR_32_DBL | 0, unsigned);
+                }
+                toNumber() {
+                    if (this.unsigned) return (this.high >>> 0) * TWO_PWR_32_DBL + (this.low >>> 0);
+                    return this.high * TWO_PWR_32_DBL + (this.low >>> 0);
+                }
+                isZero() {
+                    return 0 === this.high && 0 === this.low;
+                }
+                add(addend) {
+                    if (!long_Long.isLong(addend)) addend = long_Long.fromNumber(addend);
+                    const a48 = this.high >>> 16;
+                    const a32 = 0xffff & this.high;
+                    const a16 = this.low >>> 16;
+                    const a00 = 0xffff & this.low;
+                    const b48 = addend.high >>> 16;
+                    const b32 = 0xffff & addend.high;
+                    const b16 = addend.low >>> 16;
+                    const b00 = 0xffff & addend.low;
+                    let c48 = 0, c32 = 0, c16 = 0, c00 = 0;
+                    c00 += a00 + b00;
+                    c16 += c00 >>> 16;
+                    c00 &= 0xffff;
+                    c16 += a16 + b16;
+                    c32 += c16 >>> 16;
+                    c16 &= 0xffff;
+                    c32 += a32 + b32;
+                    c48 += c32 >>> 16;
+                    c32 &= 0xffff;
+                    c48 += a48 + b48;
+                    c48 &= 0xffff;
+                    return long_Long.fromBits(c16 << 16 | c00, c48 << 16 | c32, this.unsigned);
+                }
+                equals(other) {
+                    if (!long_Long.isLong(other)) other = long_Long.fromNumber(other);
+                    if (this.unsigned !== other.unsigned && this.high >>> 31 === 1 && other.high >>> 31 === 1) return false;
+                    return this.high === other.high && this.low === other.low;
+                }
+                addOne() {
+                    if (-1 === this.low && -1 === this.high) return long_Long.fromBits(0, 0, this.unsigned);
+                    if (-1 === this.low) return long_Long.fromBits(0, this.high + 1, this.unsigned);
+                    return long_Long.fromBits(this.low + 1, this.high, this.unsigned);
+                }
+                toBytes(le) {
+                    return le ? this.toBytesLE() : this.toBytesBE();
+                }
+                toBytesLE() {
+                    const hi = this.high, lo = this.low;
+                    return [
+                        0xff & lo,
+                        lo >>> 8 & 0xff,
+                        lo >>> 16 & 0xff,
+                        lo >>> 24,
+                        0xff & hi,
+                        hi >>> 8 & 0xff,
+                        hi >>> 16 & 0xff,
+                        hi >>> 24
+                    ];
+                }
+                toBytesBE() {
+                    const hi = this.high, lo = this.low;
+                    return [
+                        hi >>> 24,
+                        hi >>> 16 & 0xff,
+                        hi >>> 8 & 0xff,
+                        0xff & hi,
+                        lo >>> 24,
+                        lo >>> 16 & 0xff,
+                        lo >>> 8 & 0xff,
+                        0xff & lo
+                    ];
+                }
+            }
+            const ZERO = new long_Long(0, 0, false);
+            const UNSIGNED_ZERO = new long_Long(0, 0, true);
+            const MAX_VALUE = long_Long.fromBits(-1, 2147483647, false);
+            const MAX_UNSIGNED_VALUE = long_Long.fromBits(-1, -1, true);
+            const MIN_VALUE = long_Long.fromBits(0, -2147483648, false);
+            var event_ErrorCode = /*#__PURE__*/ function(ErrorCode) {
+                ErrorCode[ErrorCode["NATIVE_ERROR"] = 5001] = "NATIVE_ERROR";
+                ErrorCode[ErrorCode["CONNECTING_ERROR"] = 5002] = "CONNECTING_ERROR";
+                ErrorCode[ErrorCode["MAX_RETRIES_ERROR"] = 5003] = "MAX_RETRIES_ERROR";
+                ErrorCode[ErrorCode["MESSAGE_ERROR"] = 5004] = "MESSAGE_ERROR";
+                ErrorCode[ErrorCode["OPEN_ERROR"] = 5005] = "OPEN_ERROR";
+                return ErrorCode;
+            }({});
+            class Event {
+                constructor(type){
+                    this.type = type;
+                    this.target = null;
+                }
+            }
+            class ReconnectEvent extends Event {
+                constructor(type, eventInitDict){
+                    super(type);
+                    this.message = eventInitDict && eventInitDict.message || null;
+                }
+            }
+            class CustomErrorEvent extends Event {
+                constructor(type, eventInitDict){
+                    super(type);
+                    this.error = eventInitDict && eventInitDict.error || null;
+                    this.colno = eventInitDict && eventInitDict.colno || 0;
+                    this.filename = eventInitDict && eventInitDict.filename || '';
+                    this.lineno = eventInitDict && eventInitDict.lineno || 0;
+                    this.message = eventInitDict && eventInitDict.message || '';
+                    this.code = eventInitDict && eventInitDict.code || 5001;
+                }
+            }
+            class CustomCloseEvent extends Event {
+                constructor(type, eventInitDict){
+                    super(type);
+                    this.code = eventInitDict && eventInitDict.code || 0;
+                    this.reason = eventInitDict && eventInitDict.reason || '';
+                    this.wasClean = eventInitDict && eventInitDict.wasClean || false;
+                    this.willReconnect = eventInitDict && eventInitDict.willReconnect || false;
+                }
+            }
+            class MessageEvent extends Event {
+                constructor(type, eventInitDict){
+                    super(type);
+                    this.data = eventInitDict && eventInitDict.data || null;
+                }
+            }
+            class FrontierMessageEvent extends MessageEvent {
+                constructor(type, eventInitDict){
+                    super(type);
+                    this.data = eventInitDict && eventInitDict.data || null;
+                    this.message = eventInitDict && eventInitDict.message || null;
+                }
+            }
+            class OpenEvent extends Event {
+                constructor(type, eventInitDict){
+                    super(type);
+                    this.data = eventInitDict && eventInitDict.data || null;
+                }
+            }
+            function createErrorEvent(type, { message, code, error }) {
+                return new CustomErrorEvent(type, {
+                    message,
+                    code,
+                    error
+                });
+            }
+            function createCloseEvent(type, { code, reason, wasClean, willReconnect }) {
+                return new CustomCloseEvent(type, {
+                    code,
+                    reason,
+                    wasClean,
+                    willReconnect
+                });
+            }
+            function createMessageEvent(type, { data, message }) {
+                return new FrontierMessageEvent(type, {
+                    data,
+                    message
+                });
+            }
+            function createOpenEvent(type, { data }) {
+                return new OpenEvent(type, {
+                    data
+                });
+            }
+            function createReconnectEvent(type, { message }) {
+                return new ReconnectEvent(type, {
+                    message
+                });
+            }
+            class EndpointManager {
+                constructor(endpoints, maxRetries){
+                    this.endpoints = endpoints;
+                    this.maxRetries = maxRetries;
+                    this.currentIndex = 0;
+                    this.currentEndpointTriesCount = 0;
+                }
+                resetEndpointConfig() {
+                    this.currentIndex = 0;
+                    this.currentEndpointTriesCount = 0;
+                }
+                resetTries() {
+                    this.currentEndpointTriesCount = 0;
+                }
+                getCurrentEndpoint() {
+                    return this.endpoints[this.currentIndex];
+                }
+                getCurrentEndpointTriesCount() {
+                    return this.currentEndpointTriesCount;
+                }
+                checkReachMaxTries() {
+                    if (this.currentIndex >= this.endpoints.length) return true;
+                    if (this.currentIndex === this.endpoints.length - 1 && this.currentEndpointTriesCount === this.maxRetries) return true;
+                    return false;
+                }
+                checkCurrentEndpointReachedMaxRetries() {
+                    if (this.currentIndex == this.endpoints.length) return true;
+                    return this.currentEndpointTriesCount > this.maxRetries;
+                }
+                replaceBackupEndpointAndUpdateCount() {
+                    this.currentEndpointTriesCount = 1;
+                    this.currentIndex++;
+                    return this.endpoints[this.currentIndex];
+                }
+                getCurrentEndpointAndUpdateCount() {
+                    this.currentEndpointTriesCount++;
+                    return this.getCurrentEndpoint();
+                }
+            }
+            const IS_BROWSER = ('undefined' != typeof globalThis && 'Window' === globalThis.constructor.name || 'undefined' != typeof window && 'Window' === window.constructor.name) && 'undefined' != typeof document;
+            const IS_MINI_TT = 'undefined' != typeof globalThis && ('Object' === globalThis.constructor.name || 'DedicatedWorkerGlobalScope' === globalThis.constructor.name) && 'undefined' != typeof tt;
+            const IS_MINI_WX = ('undefined' != typeof globalThis && 'Object' === globalThis.constructor.name || 'undefined' == typeof globalThis || 'undefined' != typeof globalThis && !!globalThis.WeixinJSBridge) && 'undefined' != typeof wx;
+            const IS_WORKER = 'undefined' != typeof globalThis && ('DedicatedWorkerGlobalScope' === globalThis.constructor.name || 'SharedWorkerGlobalScope' === globalThis.constructor.name || 'ServiceWorkerGlobalScope' === globalThis.constructor.name) && 'undefined' != typeof self;
+            const IS_NODE = 'undefined' != typeof globalThis && 'Object' === globalThis.constructor.name && void 0 !== __webpack_require__.g && 'Object' === __webpack_require__.g.constructor.name && 'undefined' != typeof process && !!process.version;
+            class EventEmitter {
+                constructor(){
+                    this._listeners = {};
+                }
+                emit(evt, ...args) {
+                    const listeners = this._listeners[evt];
+                    if (listeners) listeners.slice().forEach((listener)=>listener.fn.apply(listener.ctx, args));
+                    else if ('error' === evt && !this.onerror) {
+                        const err = args.length && args[0];
+                        if (err instanceof Error) throw err;
+                        const error = new Error('Unhandled error.' + (err ? ' (' + err.message + ')' : ''));
+                        error.context = err;
+                        throw err;
+                    }
+                    return this;
+                }
+                off(evt, fn) {
+                    if (void 0 === evt) this._listeners = {};
+                    else if (void 0 === fn) this._listeners[evt] = null;
+                    else {
+                        const listeners = this._listeners[evt];
+                        if (listeners) for(let i = 0; i < listeners.length;)if (listeners[i].fn === fn) listeners.splice(i, 1);
+                        else ++i;
+                    }
+                    return this;
+                }
+                on(evt, fn, ctx) {
+                    (this._listeners[evt] || (this._listeners[evt] = [])).push({
+                        fn: fn,
+                        ctx: ctx || this
+                    });
+                    return this;
+                }
+            }
+            class MiniWebSocket extends EventEmitter {
+                _formatErrorMessage(error) {
+                    if (error.errMsg || error.errNo) return `message: ${error.errMsg || ''} code: ${error.errNo || ''}`.trim();
+                    return JSON.stringify(error);
+                }
+                constructor(url, protocols, headers){
+                    super(), this._socket = null;
+                    if (IS_MINI_WX && wx.connectSocket) this._socket = wx.connectSocket({
+                        url: url,
+                        protocols: protocols,
+                        header: headers,
+                        fail: this._createSocketFailHandler.bind(this),
+                        success: this._createSocketSuccessHandler.bind(this)
+                    });
+                    if (IS_MINI_TT && tt.connectSocket) this._socket = tt.connectSocket({
+                        url: url,
+                        protocols: protocols,
+                        header: headers,
+                        fail: this._createSocketFailHandler.bind(this),
+                        success: this._createSocketSuccessHandler.bind(this)
+                    });
+                }
+                _createSocketSuccessHandler() {
+                    Promise.resolve().then(()=>{
+                        this._addWsListeners();
+                    });
+                }
+                _createSocketFailHandler(error) {
+                    Promise.resolve().then(()=>{
+                        const errorEvent = createErrorEvent('error', {
+                            message: this._formatErrorMessage(error)
+                        });
+                        this.emit('error', errorEvent);
+                        const closeEvent = createCloseEvent('close', {
+                            reason: this._formatErrorMessage(error)
+                        });
+                        this.emit('close', closeEvent);
+                    });
+                }
+                _addWsListeners() {
+                    this._socket.onOpen((event)=>{
+                        this.emit('open', createOpenEvent('open', {
+                            ...event,
+                            data: event.errMsg || ''
+                        }));
+                    });
+                    this._socket.onClose((event)=>{
+                        this.emit('close', createCloseEvent('close', {
+                            ...event
+                        }));
+                    });
+                    this._socket.onMessage((event)=>{
+                        this.emit('message', createMessageEvent('message', {
+                            ...event
+                        }));
+                    });
+                    this._socket.onError((event)=>{
+                        this.emit('error', createErrorEvent('error', {
+                            ...event,
+                            message: event.errMsg || ''
+                        }));
+                    });
+                }
+                send(data) {
+                    if (data instanceof Uint8Array) {
+                        const buffer = data.buffer.slice(data.byteOffset, data.byteLength + data.byteOffset);
+                        this._socket && this._socket.send({
+                            data: buffer,
+                            fail: (err)=>{
+                                this.emit('error', createErrorEvent('error', {
+                                    message: this._formatErrorMessage(err)
+                                }));
+                            }
+                        });
+                    } else this._socket && this._socket.send({
+                        data,
+                        fail: (err)=>{
+                            this.emit('error', createErrorEvent('error', {
+                                message: this._formatErrorMessage(err)
+                            }));
+                        }
+                    });
+                }
+                close(code, reason) {
+                    this._socket && this._socket.close({
+                        code,
+                        reason
+                    });
+                }
+                addEventListener(type, listener) {
+                    this.on(type, listener);
+                }
+                removeEventListener(type, listener) {
+                    this.off(type, listener);
+                }
+                get readyState() {
+                    return this._socket.readyState;
+                }
+                get binaryType() {
+                    return this._socket.binaryType;
+                }
+                set binaryType(_val) {}
+                get url() {
+                    return this._socket.url;
+                }
+                get protocol() {
+                    return this._socket.protocol;
+                }
+                get extensions() {
+                    return this._socket.extensions;
+                }
+                get bufferedAmount() {
+                    return 0;
+                }
+            }
+            function globalWebSocketInit(params, ws) {
+                if (ws) return new ws(params.url, params.protocol);
+                if (IS_MINI_WX || IS_MINI_TT) return new MiniWebSocket(params.url, params.protocol, params.headers);
+                if ((IS_BROWSER || IS_WORKER) && 'undefined' != typeof WebSocket && !!WebSocket) return new WebSocket(params.url, params.protocols);
+            }
+            function checkWebSocketConstructorValid(ws) {
+                if (ws) return true;
+                if (IS_MINI_WX && wx.connectSocket) return true;
+                if (IS_MINI_TT && tt.connectSocket) return true;
+                if ((IS_BROWSER || IS_WORKER) && 'undefined' != typeof WebSocket && !!WebSocket) return true;
+                return false;
+            }
+            function processTrigger(self1, ctx, process1) {
+                let index = -1;
+                async function dispatch(i) {
+                    if (i <= index) return Promise.reject(new Error('next() called multiple times in process'));
+                    index = i;
+                    if (i === process1.length) return Promise.resolve();
+                    const fn = process1[i];
+                    return fn.bind(self1)(ctx, dispatch.bind(null, i + 1));
+                }
+                dispatch(0);
+            }
+            function utf8Length(string) {
+                let len = 0, c = 0;
+                for(let i = 0; i < string.length; ++i){
+                    c = string.charCodeAt(i);
+                    if (c < 128) len += 1;
+                    else if (c < 2048) len += 2;
+                    else if ((0xfc00 & c) === 0xd800 && (0xfc00 & string.charCodeAt(i + 1)) === 0xdc00) {
+                        ++i;
+                        len += 4;
+                    } else len += 3;
+                }
+                return len;
+            }
+            function utf8_utf8Read(buffer, start, end) {
+                if (end - start < 1) return '';
+                let str = '';
+                for(let i = start; i < end;){
+                    const t = buffer[i++];
+                    if (t <= 0x7f) str += String.fromCharCode(t);
+                    else if (t >= 0xc0 && t < 0xe0) str += String.fromCharCode((0x1f & t) << 6 | 0x3f & buffer[i++]);
+                    else if (t >= 0xe0 && t < 0xf0) str += String.fromCharCode((0xf & t) << 12 | (0x3f & buffer[i++]) << 6 | 0x3f & buffer[i++]);
+                    else if (t >= 0xf0) {
+                        const t2 = ((7 & t) << 18 | (0x3f & buffer[i++]) << 12 | (0x3f & buffer[i++]) << 6 | 0x3f & buffer[i++]) - 0x10000;
+                        str += String.fromCharCode(0xd800 + (t2 >> 10));
+                        str += String.fromCharCode(0xdc00 + (0x3ff & t2));
+                    }
+                }
+                return str;
+            }
+            function utf8Write(string, buffer, offset) {
+                const start = offset;
+                let c1, c2;
+                for(let i = 0; i < string.length; ++i){
+                    c1 = string.charCodeAt(i);
+                    if (c1 < 128) buffer[offset++] = c1;
+                    else if (c1 < 2048) {
+                        buffer[offset++] = c1 >> 6 | 192;
+                        buffer[offset++] = 63 & c1 | 128;
+                    } else if ((0xfc00 & c1) === 0xd800 && (0xfc00 & (c2 = string.charCodeAt(i + 1))) === 0xdc00) {
+                        c1 = 0x10000 + ((0x03ff & c1) << 10) + (0x03ff & c2);
+                        ++i;
+                        buffer[offset++] = c1 >> 18 | 240;
+                        buffer[offset++] = c1 >> 12 & 63 | 128;
+                        buffer[offset++] = c1 >> 6 & 63 | 128;
+                        buffer[offset++] = 63 & c1 | 128;
+                    } else {
+                        buffer[offset++] = c1 >> 12 | 224;
+                        buffer[offset++] = c1 >> 6 & 63 | 128;
+                        buffer[offset++] = 63 & c1 | 128;
+                    }
+                }
+                return offset - start;
+            }
+            async function dataToUnit8Array(data) {
+                if ('string' == typeof data) {
+                    const buffer = new Uint8Array(utf8Length(data));
+                    utf8Write(data, buffer, 0);
+                    return buffer;
+                }
+                if (data instanceof ArrayBuffer) return new Uint8Array(data);
+                return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+            }
+            function checkPayloadType(payload) {
+                try {
+                    if ('string' != typeof payload && (payload instanceof ArrayBuffer || payload.buffer && payload.buffer instanceof ArrayBuffer)) return '';
+                    if ('string' != typeof payload) return '';
+                    JSON.parse(payload);
+                    return 'application/json';
+                } catch  {
+                    if ('string' == typeof payload) return 'text/plain;charset=utf-8';
+                    return '';
+                }
+            }
+            const envParamsGen = (xUseEnv, xTTEnv)=>{
+                switch(xUseEnv){
+                    case 'boe':
+                    case 'ppe':
+                        return {
+                            [`x-use-${xUseEnv}`]: 1,
+                            'x-tt-env': xTTEnv
+                        };
+                    default:
+                        return {};
+                }
+            };
+            class PkgLossCounter {
+                constructor(maxLossCount){
+                    this.maxLossCount = maxLossCount;
+                    this.count = 0;
+                }
+                addCount() {
+                    this.count++;
+                }
+                checkReachMaxCount() {
+                    return this.count >= this.maxLossCount;
+                }
+                resetCounter(maxCount = 0) {
+                    this.maxLossCount = maxCount;
+                    this.count = 0;
+                }
+            }
+            async function getSocketError(url) {
+                return new Promise((resolve)=>{
+                    if (!IS_BROWSER) return resolve('unknown reason');
+                    try {
+                        const script = document.createElement("script");
+                        window.frontierJSONP = (reason)=>{
+                            document.body.removeChild(script);
+                            window.frontierJSONP = void 0;
+                            resolve(reason && reason.msg || 'unknown reason');
+                        };
+                        script.type = "text/javascript";
+                        script.src = url.replace(/^ws/, 'http') + '&jscallback=frontierJSONP';
+                        try {
+                            document.body.appendChild(script);
+                        } catch  {
+                            document.body.removeChild(script);
+                        }
+                    } catch  {
+                        window.frontierJSONP = void 0;
+                        resolve('unknown reason');
+                    }
+                });
+            }
+            function getKeyBoolean(headers, key, value) {
+                return !!headers?.find((header)=>header.key === key && header.value === value);
+            }
+            function getKeyValue(headers, key) {
+                return headers?.find((header)=>header.key === key)?.value;
+            }
+            let openDBLoader = null;
+            async function loadOpenDB() {
+                if (!openDBLoader) openDBLoader = Promise.resolve().then(__webpack_require__.bind(__webpack_require__, "../../node_modules/.pnpm/idb@7.0.2/node_modules/idb/build/index.js"));
+                return openDBLoader;
+            }
+            class QoSDB extends EventEmitter {
+                constructor(_dbName, _keyPath){
+                    super(), this._dbName = _dbName, this._keyPath = _keyPath, this._qosDB = void 0, this._initPromise = null;
+                }
+                async openDB() {
+                    await this._init();
+                }
+                async _init() {
+                    if (this._qosDB) return;
+                    if (this._initPromise) return this._initPromise;
+                    try {
+                        const dbName = this._dbName;
+                        const keyPath = this._keyPath;
+                        this._initPromise = (async ()=>{
+                            const { openDB } = await loadOpenDB();
+                            this._qosDB = await openDB(`frontier_${dbName}`, 1, {
+                                upgrade (db) {
+                                    db.createObjectStore(dbName, {
+                                        keyPath: keyPath
+                                    });
+                                }
+                            });
+                        })();
+                        await this._initPromise;
+                    } catch (e) {
+                        console.log(e);
+                    } finally{
+                        this._initPromise = null;
+                    }
+                }
+                async get(key) {
+                    try {
+                        await this._init();
+                        return this._qosDB?.get(this._dbName, key);
+                    } catch (e) {
+                        console.log(e);
+                    }
+                }
+                async set(val, _key) {
+                    await this._init();
+                    return this._qosDB?.put(this._dbName, val);
+                }
+                async del(key) {
+                    try {
+                        await this._init();
+                        return this._qosDB?.delete(this._dbName, key);
+                    } catch (e) {
+                        console.log(e);
+                    }
+                }
+                async clear() {
+                    try {
+                        await this._init();
+                        return this._qosDB?.clear(this._dbName);
+                    } catch (e) {
+                        console.log(e);
+                    }
+                }
+                async keys() {
+                    await this._init();
+                    return this._qosDB?.getAllKeys(this._dbName);
+                }
+                async getAll() {
+                    await this._init();
+                    return this._qosDB?.getAll(this._dbName);
+                }
+                async closeDB() {
+                    try {
+                        this._qosDB?.close();
+                        this._qosDB = void 0;
+                    } catch (e) {
+                        console.log(e);
+                    }
+                }
+                get isReady() {
+                    try {
+                        return !!this._qosDB;
+                    } catch (e) {
+                        console.log(e);
+                        return false;
+                    }
+                }
+            }
+            class QoSLocalStorage {
+                constructor(_DBName, _pathKey){
+                    this._DBName = _DBName;
+                    this._pathKey = _pathKey;
+                    this._qosDB = localStorage;
+                }
+                async openDB() {}
+                get _prefix() {
+                    return `frontier_${this._DBName}`;
+                }
+                async get(key) {
+                    const jsonString = this._qosDB.getItem(this._prefix);
+                    const jsonData = JSON.parse(jsonString || '{}');
+                    return jsonData[key];
+                }
+                async set(val, key) {
+                    const jsonString = this._qosDB.getItem(this._prefix);
+                    const jsonData = JSON.parse(jsonString || '{}');
+                    jsonData[key || val[this._pathKey]] = val;
+                    this._qosDB.setItem(this._prefix, JSON.stringify(jsonData));
+                    return key || val[this._pathKey];
+                }
+                async del(key) {
+                    const jsonString = this._qosDB.getItem(this._prefix);
+                    const jsonData = JSON.parse(jsonString || '{}');
+                    jsonData[key] = void 0;
+                    return this._qosDB.setItem(this._prefix, JSON.stringify(jsonData));
+                }
+                async clear() {
+                    return this._qosDB.clear();
+                }
+                async keys() {
+                    const jsonString = this._qosDB.getItem(this._prefix);
+                    const jsonData = JSON.parse(jsonString || '{}');
+                    return Object.keys(jsonData);
+                }
+                async getAll() {
+                    const jsonString = this._qosDB.getItem(this._prefix);
+                    const jsonData = JSON.parse(jsonString || '{}');
+                    return Object.values(jsonData);
+                }
+                closeDB() {
+                    return Promise.resolve();
+                }
+                get isReady() {
+                    return !!this._qosDB;
+                }
+            }
+            class QoSMiniStorage {
+                constructor(_DBName, _pathKey){
+                    this._DBName = _DBName;
+                    this._pathKey = _pathKey;
+                    this._qosDB = IS_MINI_TT ? tt : IS_MINI_WX ? wx : null;
+                }
+                async openDB() {}
+                get _prefix() {
+                    return `frontier_${this._DBName}`;
+                }
+                async get(key) {
+                    const jsonString = this._qosDB.getStorageSync(this._prefix);
+                    const jsonData = JSON.parse(jsonString || '{}');
+                    return jsonData[key];
+                }
+                async set(val, key) {
+                    const jsonString = this._qosDB.getStorageSync(this._prefix);
+                    const jsonData = JSON.parse(jsonString || '{}');
+                    jsonData[key || val[this._pathKey]] = val;
+                    this._qosDB.setStorageSync(this._prefix, JSON.stringify(jsonData));
+                    return key || val[this._pathKey];
+                }
+                async del(key) {
+                    const jsonString = this._qosDB.getStorageSync(this._prefix);
+                    const jsonData = JSON.parse(jsonString || '{}');
+                    jsonData[key] = void 0;
+                    return this._qosDB.setStorageSync(this._prefix, JSON.stringify(jsonData));
+                }
+                async clear() {
+                    return this._qosDB.clearStorageSync();
+                }
+                async keys() {
+                    const jsonString = this._qosDB.getStorageInfoSync(this._prefix);
+                    const jsonData = JSON.parse(jsonString || '{}');
+                    return Object.keys(jsonData);
+                }
+                async getAll() {
+                    const jsonString = this._qosDB.getStorageInfoSync(this._prefix);
+                    const jsonData = JSON.parse(jsonString || '{}');
+                    return Object.values(jsonData);
+                }
+                closeDB() {
+                    return Promise.resolve();
+                }
+                get isReady() {
+                    return !!this._qosDB;
+                }
+            }
+            function getQoSDB(dbName, keyPath) {
+                if (IS_MINI_TT || IS_MINI_TT) return new QoSMiniStorage(dbName, keyPath);
+                if ((IS_BROWSER || IS_WORKER) && 'undefined' != typeof indexedDB) return new QoSDB(dbName, keyPath);
+                if ((IS_BROWSER || IS_WORKER) && 'undefined' != typeof localStorage) return new QoSLocalStorage(dbName, keyPath);
+                throw new Error('init QoSDB failed');
+            }
+            class QoSManager {
+                constructor(){
+                    this._intervalTimeoutId = null;
+                    this._interval = 3600000;
+                    this._qosDB = getQoSDB('qos', 'message_id');
+                }
+                async _intervalFlush() {
+                    clearInterval(this._intervalTimeoutId);
+                    this._intervalTimeoutId = setInterval(()=>{
+                        this.flushExpired();
+                    }, this._interval);
+                }
+                async openDB() {
+                    await this._qosDB.openDB().then(()=>{
+                        this._intervalFlush();
+                    });
+                }
+                async flushExpired() {
+                    const allMsgs = await this._qosDB?.getAll() || [];
+                    const expiredMsgs = allMsgs.filter(({ timestamp })=>timestamp < Date.now());
+                    expiredMsgs.forEach((msg)=>{
+                        this._qosDB?.del(msg.message_id);
+                    });
+                }
+                async del(msgID) {
+                    return this._qosDB?.del(msgID);
+                }
+                async set(msgID, timestamp) {
+                    return this._qosDB?.set({
+                        message_id: msgID,
+                        timestamp
+                    });
+                }
+                async get(msgID) {
+                    return this._qosDB?.get(msgID);
+                }
+                async closeDB() {
+                    clearInterval(this._intervalTimeoutId);
+                    await this._qosDB?.closeDB();
+                }
+                get isReady() {
+                    return this._qosDB?.isReady;
+                }
+            }
+            function getFrontierQoSState(ctx) {
+                const enabled = !!this._options.enableQoS;
+                if (!enabled) return {
+                    enabled,
+                    isQoSMessage: false,
+                    isQoSAck: false,
+                    isAckCleanupMessage: false,
+                    ackMsgIds: []
+                };
+                const isQoSMessage = getKeyBoolean(ctx.message.headers, 'x_frontier_qos', '2');
+                const isQoSAck = isQoSMessage && getKeyBoolean(ctx.message.headers, 'x_frontier_qos_ack', '1');
+                const isAckCleanupMessage = isQoSMessage && getKeyBoolean(ctx.message.headers, 'x_frontier_is_ack', '1');
+                const ackMsgIds = isAckCleanupMessage ? getKeyValue(ctx.message.headers, 'x_frontier_ack_msgid')?.split(',').filter(Boolean) || [] : [];
+                return {
+                    enabled,
+                    isQoSMessage,
+                    isQoSAck,
+                    isAckCleanupMessage,
+                    ackMsgIds
+                };
+            }
+            async function ensureQoSManager() {
+                if (!this._QoSManager) this._QoSManager = new QoSManager();
+                if (!this._QoSManager.isReady) await this._QoSManager.openDB();
+                return this._QoSManager;
+            }
+            async function ackProcess(ctx, next) {
+                const { enableAutoAck } = this._options;
+                const needAck = getKeyBoolean(ctx.message.headers, 'need_ack', '1');
+                const isAck = getKeyBoolean(ctx.message.headers, 'is_ack', '1');
+                const qosState = getFrontierQoSState.call(this, ctx);
+                if (enableAutoAck && needAck) {
+                    const { SeqID, LogID, service, LogIDNew, method } = ctx.message;
+                    this._sendAck({
+                        SeqID,
+                        LogID,
+                        LogIDNew,
+                        service,
+                        method,
+                        headers: [
+                            {
+                                key: 'is_ack',
+                                value: '1'
+                            },
+                            {
+                                key: 'ack_id',
+                                value: LogIDNew || ''
+                            },
+                            {
+                                key: 'ack_code',
+                                value: '0'
+                            }
+                        ]
+                    });
+                }
+                if (isAck && !qosState.isQoSAck) this._dispatchAckMessageEvent(ctx);
+                next();
+            }
+            async function finishMessageProcess(ctx, next) {
+                this._debug('received', ctx.message);
+                next();
+            }
+            async function decodeMessageProcess(ctx, next) {
+                const data = decodedFrame(await dataToUnit8Array(ctx.data));
+                try {
+                    if (data.payload instanceof Uint8Array) {
+                        const localPayloadEncoding = this._options.payloadEncoding instanceof Object ? {
+                            force: !!this._options.payloadEncoding.force,
+                            encoding: this._options.payloadEncoding.encoding ? this._options.payloadEncoding.encoding.replace(/\s/g, '').toLowerCase() : ''
+                        } : {
+                            force: false,
+                            encoding: this._options.payloadEncoding ? this._options.payloadEncoding.replace(/\s/g, '').toLowerCase() : ''
+                        };
+                        const remotePayloadEncoding = data.payloadEncoding ? data.payloadEncoding.replace(/\s/g, '').toLowerCase() : '';
+                        const localPayloadType = this._options.payloadType instanceof Object ? {
+                            force: !!this._options.payloadType.force,
+                            type: this._options.payloadType.type ? this._options.payloadType.type.replace(/\s/g, '').toLowerCase() : ''
+                        } : {
+                            force: false,
+                            type: this._options.payloadType ? this._options.payloadType.replace(/\s/g, '').toLowerCase() : ''
+                        };
+                        const remotePayloadType = data.payloadType ? data.payloadType.replace(/\s/g, '').toLowerCase() : '';
+                        const payloadType = localPayloadType.force ? localPayloadType.type : remotePayloadType ? remotePayloadType : localPayloadType.type;
+                        const payloadEncoding = localPayloadEncoding.force ? localPayloadEncoding.encoding : remotePayloadEncoding ? remotePayloadEncoding : localPayloadEncoding.encoding;
+                        const encodingAllowList = [
+                            'text/plain;charset=utf-8',
+                            'application/json',
+                            'application/json;charset=utf-8',
+                            'string'
+                        ];
+                        const typeAllowList = [
+                            'none_none',
+                            'binary'
+                        ];
+                        if (this._options.enableTransformTextPayload && encodingAllowList.includes(payloadType) && (!payloadEncoding || typeAllowList.includes(payloadEncoding))) data.textPayload = utf8_utf8Read(data.payload, 0, data.payload.byteLength);
+                        else data.textPayload = '';
+                    } else data.textPayload = '';
+                } catch (err) {
+                    data.textPayload = '';
+                    console.log(err);
+                }
+                ctx.message = data;
+                next();
+            }
+            function pool(alloc, slice, size) {
+                const SIZE = size || 8192;
+                const MAX = SIZE >>> 1;
+                let slab = null;
+                let offset = SIZE;
+                return function(size) {
+                    if (size < 1 || size > MAX) return alloc(size);
+                    if (offset + size > SIZE) {
+                        slab = alloc(SIZE);
+                        offset = 0;
+                    }
+                    const buf = slice.call(slab, offset, offset += size);
+                    if (7 & offset) offset = (7 | offset) + 1;
+                    return buf;
+                };
+            }
+            const MAX_UINT32 = 0xffffffff;
+            function IndexOutOfRangeError(pos, span, length) {
+                return RangeError('index out of range: ' + pos + ' + ' + (span || 1) + ' > ' + length);
+            }
+            function writeUInt32(buf, pos, num) {
+                if (num > MAX_UINT32) throw new Error('integer too large');
+                let index = 3;
+                while(index >= 0){
+                    const value = 0xff & num;
+                    buffer_writeByte(value, buf, pos + index);
+                    num >>>= 8;
+                    index--;
+                }
+                return pos + 4;
+            }
+            function readUInt32(buffer, pos) {
+                let result = 0;
+                let bufferOffset = pos;
+                const end = pos + 4;
+                while(bufferOffset < end){
+                    const { value, offset } = buffer_readByte(buffer, bufferOffset);
+                    bufferOffset = offset;
+                    result = result << 8 >>> 0;
+                    result += value;
+                }
+                return {
+                    value: result,
+                    offset: end
+                };
+            }
+            function buffer_writeString(val, buf, pos) {
+                if (!val) return pos;
+                if (val.length < 40) return utf8Write(val, buf, pos) + pos;
+                if (buf.utf8Write) return buf.utf8Write(val, pos) + pos;
+                if (buf.write) return buf.write(val, pos) + pos;
+                return utf8Write(val, buf, pos) + pos;
+            }
+            function readInt64FromBE(buf, pos) {
+                const value = new long_Long(buf[pos + 4] << 24 | buf[pos + 5] << 16 | buf[pos + 6] << 8 | buf[pos + 7], buf[pos + 0] << 24 | buf[pos + 1] << 16 | buf[pos + 2] << 8 | buf[pos + 3], true);
+                pos += 8;
+                return {
+                    value,
+                    offset: pos + 8
+                };
+            }
+            function writeInt64ToBE(val, buf, pos) {
+                const low = val.low;
+                const high = val.high;
+                buf[pos] = high >>> 24;
+                buf[pos + 1] = high >>> 16 & 255;
+                buf[pos + 2] = high >>> 8 & 255;
+                buf[pos + 3] = 255 & high;
+                buf[pos + 4] = low >>> 24;
+                buf[pos + 5] = low >>> 16 & 255;
+                buf[pos + 6] = low >>> 8 & 255;
+                buf[pos + 7] = 255 & low;
+                pos += 8;
+                return pos;
+            }
+            function buffer_readByte(buf, pos) {
+                if (buf.readUInt8) return {
+                    value: buf.readUInt8(pos),
+                    offset: pos + 1
+                };
+                return {
+                    value: 255 & buf[pos],
+                    offset: pos + 1
+                };
+            }
+            function buffer_writeByte(val, buf, pos) {
+                if (buf.writeUint8) buf.writeUint8(val, pos);
+                else buf[pos] = 255 & val;
+                return pos + 1;
+            }
+            const uint8ArrayAlloc = function(size) {
+                return new Uint8Array(size);
+            };
+            const buffer_alloc = 'undefined' != typeof Buffer ? Buffer.allocUnsafe : pool(uint8ArrayAlloc, Uint8Array.prototype.subarray);
+            (()=>{
+                let value = 4294967295;
+                return function(buf, pos, unsigned = true) {
+                    value = (127 & buf[pos]) >>> 0;
+                    if (buf[pos++] < 128) return {
+                        value: unsigned ? value : 0 | value,
+                        offset: pos
+                    };
+                    value = (value | (127 & buf[pos]) << 7) >>> 0;
+                    if (buf[pos++] < 128) return {
+                        value: unsigned ? value : 0 | value,
+                        offset: pos
+                    };
+                    value = (value | (127 & buf[pos]) << 14) >>> 0;
+                    if (buf[pos++] < 128) return {
+                        value: unsigned ? value : 0 | value,
+                        offset: pos
+                    };
+                    value = (value | (127 & buf[pos]) << 21) >>> 0;
+                    if (buf[pos++] < 128) return {
+                        value: unsigned ? value : 0 | value,
+                        offset: pos
+                    };
+                    value = (value | (15 & buf[pos]) << 28) >>> 0;
+                    if (buf[pos++] < 128) return {
+                        value: unsigned ? value : 0 | value,
+                        offset: pos
+                    };
+                    if ((pos += 5) > buf.length) {
+                        pos = buf.length;
+                        throw IndexOutOfRangeError(pos, 10, buf.length);
+                    }
+                    return {
+                        value: unsigned ? value : 0 | value,
+                        offset: pos
+                    };
+                };
+            })();
+            const CURSOR_FILE_NAME_FRAME = 16;
+            const CURSOR_DATA_FRAME = 32;
+            function calculateTotalBufferLength(cursors) {
+                let totalLength = 0;
+                const cursorLengthMap = {};
+                for(let i = 0; i < cursors.length; i++){
+                    cursorLengthMap[cursors[i].cursor_name] = utf8Length(cursors[i].cursor_name);
+                    totalLength += 14 + cursorLengthMap[cursors[i].cursor_name];
+                }
+                return [
+                    totalLength,
+                    cursorLengthMap
+                ];
+            }
+            function serializeCursorData(cursors, defaultCursor, cursorFileName) {
+                const [totalBufferLength, cursorLengthMap] = calculateTotalBufferLength(cursors);
+                const dataBuffer = buffer_alloc(totalBufferLength);
+                let pos = 0;
+                cursors.forEach((cursor)=>{
+                    console.log('cursor.service', cursor, cursor.service);
+                    pos = buffer_writeByte(0, dataBuffer, pos);
+                    console.log('header', pos);
+                    pos = writeUInt32(dataBuffer, pos, cursor.service || 0);
+                    console.log('service', pos);
+                    pos = buffer_writeByte(cursorLengthMap[cursor.cursor_name], dataBuffer, pos);
+                    console.log('service-name', pos);
+                    pos = buffer_writeString(cursor.cursor_name, dataBuffer, pos);
+                    console.log('name', pos);
+                    pos = writeInt64ToBE(long_Long.fromNumber(cursor.cursor || defaultCursor), dataBuffer, pos);
+                    console.log('curvalue', pos);
+                });
+                return {
+                    frameType: CURSOR_DATA_FRAME,
+                    headers: [
+                        {
+                            key: 'cursor_file_name',
+                            value: cursorFileName
+                        }
+                    ],
+                    payload: dataBuffer
+                };
+            }
+            function deserializeCursorData(cursorData) {
+                let pos = 0;
+                const cursors = [];
+                while(pos < cursorData.byteLength){
+                    const { offset: versionOffset } = buffer_readByte(cursorData, pos);
+                    pos = versionOffset;
+                    const cursor = {
+                        cursor_name: '',
+                        cursor: 0,
+                        service: 0
+                    };
+                    const { value: serviceValue, offset: serviceOffset } = readUInt32(cursorData, pos);
+                    cursor.service = serviceValue;
+                    pos = serviceOffset;
+                    const { value: length, offset: lenOffset } = buffer_readByte(cursorData, pos);
+                    pos = lenOffset;
+                    cursor.cursor_name = utf8_utf8Read(cursorData, pos, pos + length);
+                    pos += length;
+                    const { value: cursorValue, offset: valueOffset } = readInt64FromBE(cursorData, pos);
+                    cursor.cursor = cursorValue.toNumber();
+                    pos = valueOffset;
+                    cursors.push(cursor);
+                }
+                return cursors;
+            }
+            function serializeCursorFileName() {
+                return {
+                    frameType: CURSOR_DATA_FRAME,
+                    headers: [
+                        {
+                            key: 'cursor_file_name',
+                            value: 'FILE_NOT_EXIST'
+                        }
+                    ],
+                    payload: void 0
+                };
+            }
+            class CursorManager {
+                constructor(_cursorNameSpace, _cursorFileName, _messageStrategy){
+                    this._cursorNameSpace = _cursorNameSpace;
+                    this._cursorFileName = _cursorFileName;
+                    this._messageStrategy = _messageStrategy;
+                    this._qosDB = getQoSDB(this._cursorNameSpace, 'cursor_name');
+                }
+                async openDB() {
+                    await this._qosDB.openDB();
+                }
+                async getCursors() {
+                    if (!this._qosDB.isReady) return;
+                    const strategy = this._messageStrategy;
+                    const allCursorValues = await this._qosDB.getAll();
+                    console.log('allCursorValues', allCursorValues);
+                    switch(strategy){
+                        case 'ALL':
+                            return allCursorValues && allCursorValues.length ? serializeCursorData(allCursorValues, 0, this._cursorFileName) : void 0;
+                        case 'INSTANT':
+                            return;
+                        case 'CONTINUE':
+                            return allCursorValues && allCursorValues.length ? serializeCursorData(allCursorValues, 0, this._cursorFileName) : serializeCursorFileName();
+                    }
+                }
+                async set(cursorName, cursor, service) {
+                    console.log('setdb', cursorName, cursor, service);
+                    return this._qosDB.set({
+                        cursor_name: cursorName,
+                        cursor: cursor,
+                        service: service
+                    });
+                }
+                async setCursors(cursorData) {
+                    const cursors = deserializeCursorData(cursorData);
+                    for (const cursor of cursors){
+                        console.log('setcursor', cursors);
+                        await this._qosDB.set(cursor);
+                    }
+                }
+                async get(cursorName) {
+                    return (await this._qosDB.get(cursorName))?.cursor;
+                }
+                async closeDB() {
+                    await this._qosDB.closeDB();
+                }
+                updateCursorFileName(cursorFileName) {
+                    this._cursorFileName = cursorFileName;
+                }
+                get isReady() {
+                    return this._qosDB.isReady;
+                }
+            }
+            const DEFAULT_X_MSG_CURSOR_FILE_NAME = '__x_msg_qos__';
+            async function ensureCursorManager(cursorFileName) {
+                if (!this._options.enableQoS) return null;
+                const { aID, fpID, messageStrategy } = this._options;
+                const resolvedCursorFileName = cursorFileName || DEFAULT_X_MSG_CURSOR_FILE_NAME;
+                try {
+                    if (this._cursorManager) {
+                        if (cursorFileName) this._cursorManager.updateCursorFileName(cursorFileName);
+                    } else this._cursorManager = new CursorManager(`${fpID}_${aID}_${resolvedCursorFileName}`, resolvedCursorFileName, messageStrategy);
+                    if (!this._cursorManager.isReady) await this._cursorManager.openDB();
+                    return this._cursorManager;
+                } catch  {
+                    return null;
+                }
+            }
+            async function dispatchMessageProcess(ctx, next) {
+                const isAbnormalCode = getKeyBoolean(ctx.message.headers, 'code', '-1');
+                const isAck = getKeyBoolean(ctx.message.headers, 'is_ack', '1');
+                const xFrontierMsgId = getKeyValue(ctx.message.headers, 'x_frontier_msgid');
+                const xFrontierTTL = Number(getKeyValue(ctx.message.headers, 'x_frontier_ttl')) || 0;
+                const qosState = getFrontierQoSState.call(this, ctx);
+                const isXMsgQoS = getKeyBoolean(ctx.message.headers, 'x-msg-qos', '2');
+                const xMsgCursorName = getKeyValue(ctx.message.headers, 'x-msg-cursor_name');
+                const xMsgCursorValue = Number(getKeyValue(ctx.message.headers, 'x-msg-cursor_value'));
+                if (qosState.isQoSAck) return next();
+                const qosManager = qosState.isQoSMessage ? await ensureQoSManager.call(this) : null;
+                if (ctx.message.service > 0 && isAck && !isAbnormalCode || ctx.message.service > 0) {
+                    if (xFrontierMsgId && qosState.isQoSMessage && qosManager) {
+                        const isDuplicatedMsg = !!await qosManager.get(xFrontierMsgId);
+                        if (!isDuplicatedMsg) {
+                            this._dispatchMessageEvent(ctx);
+                            await qosManager.set(xFrontierMsgId, Date.now() + xFrontierTTL);
+                        }
+                        return next();
+                    }
+                    if (isXMsgQoS) {
+                        const cursorManager = await ensureCursorManager.call(this);
+                        if (!cursorManager) {
+                            this._dispatchMessageEvent(ctx);
+                            return next();
+                        }
+                        const localCursorValue = await cursorManager.get(xMsgCursorName) ?? -1;
+                        if (localCursorValue < xMsgCursorValue) {
+                            this._dispatchMessageEvent(ctx);
+                            cursorManager.set(xMsgCursorName, xMsgCursorValue, ctx.message.service);
+                        } else throw new Error(`recevied message cursor ${xMsgCursorValue} larger than local cursor ${localCursorValue}`);
+                        return next();
+                    }
+                    this._dispatchMessageEvent(ctx);
+                    return next();
+                }
+            }
+            async function qosProcess(ctx, next) {
+                const qosState = getFrontierQoSState.call(this, ctx);
+                if (!qosState.isQoSMessage) return next();
+                const qosManager = await ensureQoSManager.call(this);
+                if (qosState.isAckCleanupMessage && qosState.ackMsgIds.length) for (const msgId of qosState.ackMsgIds)await qosManager.del(msgId);
+                next();
+            }
+            async function cursorProcess(ctx, next) {
+                const isCursorFileNameFrame = ctx.message.frameType === CURSOR_FILE_NAME_FRAME;
+                const isCursorDataFrame = ctx.message.frameType === CURSOR_DATA_FRAME;
+                if (!isCursorFileNameFrame && !isCursorDataFrame) return next();
+                const cursorFileName = getKeyValue(ctx.message.headers, 'cursor_file_name');
+                if (!cursorFileName) return next();
+                const cursorManager = await ensureCursorManager.call(this, cursorFileName);
+                if (!cursorManager) return next();
+                if (isCursorFileNameFrame) {
+                    const cursorInfo = await cursorManager.getCursors();
+                    const frameData = {
+                        frameType: cursorInfo?.frameType,
+                        SeqID: long_Long.fromNumber(this._seqId++),
+                        LogID: long_Long.fromNumber(this._options.logIDGenerator()),
+                        service: 9000,
+                        method: 5,
+                        headers: cursorInfo?.headers,
+                        payload: cursorInfo?.payload
+                    };
+                    const encodedData = encodeFrame(frameData);
+                    this._ws && this._ws.readyState && this._ws.send(encodedData);
+                }
+                if (isCursorDataFrame) {
+                    const cursorData = ctx.message.payload;
+                    cursorData && cursorManager.setCursors(cursorData);
+                }
+            }
+            const openProcess = async function(_, next) {
+                this._isInit = false;
+                clearTimeout(this._connectionTimeoutId);
+                next();
+            };
+            const openSucceedProcess = async function(ctx, next) {
+                if (!this._ws || this._ws.readyState !== this.OPEN) return next();
+                const { pingInterval } = this._options;
+                this._endpointManager?.resetEndpointConfig();
+                for(let i = 0; i < this._messageQueue.length; i++){
+                    const message = this._messageQueue[i];
+                    if (this._ws.readyState === this.OPEN && null !== message) {
+                        this._ws && this._ws.send(message);
+                        this._messageQueue[i] = null;
+                    } else break;
+                }
+                this._messageQueue = this._messageQueue.filter((item)=>Boolean(item));
+                this._pingPongTimeoutId = setTimeout(()=>this._ping(), pingInterval);
+                this._dispatchOpenEvent(ctx);
+                if (this._isBrowser) this._ws && (this._ws.binaryType = this._binaryType);
+                const currentEndpoint = this._endpointManager?.getCurrentEndpoint();
+                this._debug(`open ${currentEndpoint} success`);
+                next();
+            };
+            const finishOpenProcess = async function(_, next) {
+                const currentEndpoint = this._endpointManager?.getCurrentEndpoint();
+                this._debug(`open ${currentEndpoint}`);
+                next();
+            };
+            class FWS extends EventEmitter {
+                constructor(options){
+                    super(), this._miniNavigatorOnline = true, this._isBrowser = IS_BROWSER, this._isNode = IS_NODE, this._isMiniTT = IS_MINI_TT, this._isMiniWX = IS_MINI_WX, this._isWorker = IS_WORKER, this._messageQueue = [], this._endpointManager = null, this._readyClosed = false, this._binaryType = 'arraybuffer', this._connectLock = false, this._connectionTimeoutId = null, this._reconnectTimeoutId = null, this._pingPongTimeoutId = null, this._seqId = 0, this._isInit = false, this._url = '', this._QoSManager = null, this._cursorManager = null, this._pingLossCounter = null, this._protocols = 'pbbp2', this.CLOSED = 3, this.CONNECTING = 0, this.OPEN = 1, this.CLOSING = 2, this._onOpen = (openEvent)=>{
+                        try {
+                            processTrigger(this, openEvent, [
+                                openProcess,
+                                openSucceedProcess,
+                                finishOpenProcess
+                            ]);
+                        } catch (error) {
+                            const errorEvent = createErrorEvent('error', {
+                                message: error.message,
+                                code: event_ErrorCode.OPEN_ERROR,
+                                error
+                            });
+                            this._dispatchErrorEvent(errorEvent);
+                        }
+                    }, this._onMessage = async (messageEvent)=>{
+                        const { pingInterval, pingFrequency } = this._options;
+                        if ('hi' === messageEvent.data && 'always' === pingFrequency || 'auto' === pingFrequency) {
+                            this._clearPingTimer();
+                            this.emit('ping_once_success', 'success');
+                            this._pingPongTimeoutId = setTimeout(this._ping.bind(this), pingInterval);
+                        }
+                        if ('hi' === messageEvent.data) return;
+                        try {
+                            processTrigger(this, messageEvent, [
+                                decodeMessageProcess,
+                                ackProcess,
+                                qosProcess,
+                                cursorProcess,
+                                dispatchMessageProcess,
+                                finishMessageProcess
+                            ]);
+                        } catch (error) {
+                            const errorEvent = createErrorEvent('error', {
+                                message: error.message,
+                                code: event_ErrorCode.MESSAGE_ERROR,
+                                error
+                            });
+                            this._dispatchErrorEvent(errorEvent);
+                        }
+                    }, this._onError = (errorEvent)=>{
+                        const isReachMaxTries = this._endpointManager?.checkReachMaxTries();
+                        const currentEndpoint = this._endpointManager?.getCurrentEndpoint();
+                        if (isReachMaxTries && !errorEvent.message) {
+                            const message = `connect ${currentEndpoint} fail, max retries reached`;
+                            this._dispatchErrorEvent(createErrorEvent('error', {
+                                message,
+                                code: event_ErrorCode.MAX_RETRIES_ERROR,
+                                error: errorEvent
+                            }));
+                            return;
+                        }
+                        this._ws && this._ws.readyState === this.OPEN && this._disconnect();
+                        this._dispatchErrorEvent(createErrorEvent('error', {
+                            message: errorEvent.message,
+                            code: event_ErrorCode.NATIVE_ERROR,
+                            error: errorEvent
+                        }));
+                    }, this._onClose = async (event)=>{
+                        this._clearTimer();
+                        this._clearPingTimer();
+                        this._removeWsListeners();
+                        this._ws = null;
+                        this._connectLock = false;
+                        const isReachMaxTries = this._endpointManager?.checkReachMaxTries();
+                        if (!isReachMaxTries && this._navigatorOnline() && !this._readyClosed) {
+                            const currentEndpoint = this._endpointManager?.getCurrentEndpoint();
+                            const interceptorRes = this._options.reconnectInterceptor(event.code, event.reason);
+                            this._dispatchCloseEvent(createCloseEvent('close', {
+                                code: 1006,
+                                reason: event.reason || `connecting failed, unknown reason, hostname: ${currentEndpoint}`,
+                                willReconnect: interceptorRes
+                            }));
+                            interceptorRes && this._connect();
+                            return;
+                        }
+                        if (1000 !== event.code && this._readyClosed) {
+                            this._dispatchCloseEvent(createCloseEvent('close', {
+                                code: 1000,
+                                reason: 'bye'
+                            }));
+                            this._endpointManager?.resetEndpointConfig();
+                            this._pingLossCounter?.resetCounter();
+                            return;
+                        }
+                        if (1000 !== event.code && isReachMaxTries) {
+                            const currentEndpoint = this._endpointManager?.getCurrentEndpoint();
+                            let _reason = event.reason;
+                            if (!_reason) _reason = await getSocketError(this._url);
+                            _reason = `connecting failed, ${_reason}, hostname: ${currentEndpoint}, max retries reached`;
+                            this._dispatchCloseEvent(createCloseEvent('close', {
+                                code: event.code,
+                                reason: _reason
+                            }));
+                            const message = `connect ${currentEndpoint} fail, max retries reached`;
+                            this._dispatchErrorEvent(createErrorEvent('error', {
+                                message,
+                                code: event_ErrorCode.MAX_RETRIES_ERROR
+                            }));
+                            this._endpointManager?.resetEndpointConfig();
+                            this._pingLossCounter?.resetCounter();
+                            return;
+                        }
+                        if (1000 !== event.code && !event.reason) {
+                            const currentEndpoint = this._endpointManager?.getCurrentEndpoint();
+                            this._dispatchCloseEvent(createCloseEvent('close', {
+                                code: event.code,
+                                reason: `connecting failed, unknown reason, hostname: ${currentEndpoint}`
+                            }));
+                            this._endpointManager?.resetEndpointConfig();
+                            this._pingLossCounter?.resetCounter();
+                            return;
+                        }
+                        this._dispatchCloseEvent(event);
+                        this._endpointManager?.resetEndpointConfig();
+                        this._pingLossCounter?.resetCounter();
+                    }, this.onclose = null, this.onerror = null, this.onmessage = null, this.onopen = null, this.onStartReconnect = null, this.onReceiveAck = null, this.onStopImmediatelyReconnect = null;
+                    this._handleOnLine = this._handleOnLine.bind(this);
+                    this._handleOffLine = this._handleOffLine.bind(this);
+                    this._handlePageHide = this._handlePageHide.bind(this);
+                    this._handlePageShow = this._handlePageShow.bind(this);
+                    this._options = {
+                        url: '',
+                        automaticOpen: true,
+                        initReconnectInterval: 1000,
+                        maxReconnectInterval: 10000,
+                        reconnectIntervalGrowFactor: 2,
+                        timeoutInterval: 5000,
+                        maxRetries: 5,
+                        debug: false,
+                        maxMessageQueueLength: 1 / 0,
+                        service: 0,
+                        logIDGenerator: genLogID,
+                        headers: void 0,
+                        payloadEncoding: '',
+                        payloadType: '',
+                        fpID: '',
+                        deviceID: '',
+                        accessKey: '',
+                        ttwID: '',
+                        bddID: '',
+                        aID: '',
+                        disableAutoReconnect: false,
+                        customParams: {},
+                        pingInterval: 15000,
+                        pingTimeoutInterval: 4000,
+                        pingFrequency: 'auto',
+                        pingLossCount: 2,
+                        enableTransformTextPayload: false,
+                        logIDNewConfig: {
+                            enableAutoGenerateLogIDNew: false,
+                            userIp: ''
+                        },
+                        miniProgramParams: {
+                            customHttpHeader: {}
+                        },
+                        enableAutoAck: false,
+                        reconnectInterceptor: ()=>true,
+                        enableQoS: false,
+                        QoSLevel: 2,
+                        messageStrategy: 'CONTINUE',
+                        env: {
+                            xTTEnv: '',
+                            xUseEnv: ''
+                        },
+                        listenNetworkChanged: true
+                    };
+                    const { url, ws } = options;
+                    const endpoints = Array.isArray(url) ? url : 'string' == typeof url ? [
+                        url
+                    ] : [];
+                    if (!endpoints || 0 === endpoints.length) throw new Error('please provide valid url');
+                    if (!checkWebSocketConstructorValid(ws)) throw new Error('please provide ws params, WebSocket constructor is undefined');
+                    Object.assign(this._options, options);
+                    this._endpointManager = new EndpointManager(endpoints, this._options.maxRetries);
+                    this._pingLossCounter = new PkgLossCounter(this._options.pingLossCount);
+                    if (this._options.automaticOpen) {
+                        this._isInit = true;
+                        this._connect();
+                    }
+                    if (this._options.listenNetworkChanged) {
+                        if (this._isMiniTT || this._isMiniWX) this._onPageNetWorkChange();
+                        else if (this._isBrowser) this._initGlobalEventListener();
+                    }
+                }
+                _handleOnLine() {
+                    if (this._options.disableAutoReconnect || this._readyClosed) return;
+                    this._handleReconnect();
+                }
+                _handleOffLine() {
+                    this._destroyWebSocket();
+                    const reconnectEvent = createReconnectEvent('reconnect', {
+                        message: 'stop immediately reconnect'
+                    });
+                    this.onStopImmediatelyReconnect && this.onStopImmediatelyReconnect(reconnectEvent);
+                }
+                _initGlobalEventListener() {
+                    this._isBrowser && window.addEventListener('online', this._handleOnLine);
+                    this._isBrowser && window.addEventListener('offline', this._handleOffLine);
+                    this._isBrowser && window.addEventListener('pagehide', this._handlePageHide);
+                    this._isBrowser && window.addEventListener('pageshow', this._handlePageShow);
+                }
+                _dropGlobalEventListener() {
+                    this._isBrowser && window.removeEventListener('online', this._handleOnLine);
+                    this._isBrowser && window.removeEventListener('offline', this._handleOffLine);
+                    this._isBrowser && window.removeEventListener('pagehide', this._handlePageHide);
+                    this._isBrowser && window.removeEventListener('pageshow', this._handlePageShow);
+                }
+                _handlePageHide(event) {
+                    if (!event.persisted) {
+                        this._isBrowser && window.removeEventListener('pagehide', this._handlePageHide);
+                        this._isBrowser && window.removeEventListener('pageshow', this._handlePageShow);
+                        this.close();
+                    }
+                    this._isBrowser && window.removeEventListener('online', this._handleOnLine);
+                    this._isBrowser && window.removeEventListener('offline', this._handleOffLine);
+                }
+                _handlePageShow(event) {
+                    if (event.persisted) {
+                        if (this._navigatorOnline() && (!this._ws || this._ws.readyState !== this.OPEN || this._ws.readyState !== this.CONNECTING)) this._handleOnLine();
+                        this._isBrowser && window.addEventListener('online', this._handleOnLine);
+                        this._isBrowser && window.addEventListener('offline', this._handleOffLine);
+                    }
+                }
+                async _generateUrl(endpoint) {
+                    const { fpID, deviceID, bddID, ttwID, accessKey, aID, customParams = {}, enableAutoAck, enableQoS, QoSLevel, env } = this._options;
+                    let wsProtocol, wsEndpoint, currentEndpoint;
+                    if (this._isBrowser || this._isMiniWX || this._isMiniTT) {
+                        wsProtocol = location && 'https:' == location.protocol ? 'wss://' : 'ws://';
+                        wsEndpoint = endpoint.replace(/((^ws)|(^http))((?:[s]*:\/\/))/, '');
+                        currentEndpoint = /^wss(.*:\/\/)/.test(endpoint) ? endpoint : `${wsProtocol}${wsEndpoint}`;
+                    } else {
+                        wsProtocol = 'wss://';
+                        wsEndpoint = endpoint.replace(/(^http)((?:[s]*:\/\/))/, '');
+                        currentEndpoint = /(^ws)((?:[s]*:\/\/))/.test(wsEndpoint) ? wsEndpoint : `${wsProtocol}${wsEndpoint}`;
+                    }
+                    const dIDKey = bddID ? 'bd_did' : ttwID ? 'ttwid' : 'device_id';
+                    const dIDArg = bddID ? bddID : ttwID ? ttwID : deviceID;
+                    if (!dIDArg || !dIDKey) throw new Error('please provide bddID, deviceID or ttwID');
+                    const customParamsMap = 'function' == typeof customParams ? await customParams() : customParams;
+                    const envParams = env ? envParamsGen(env.xUseEnv, env.xTTEnv) : {};
+                    const params = Object.assign({
+                        device_platform: 'web',
+                        version_code: 'fws_1.0.0',
+                        access_key: accessKey,
+                        fpid: fpID,
+                        aid: aID,
+                        [dIDKey]: dIDArg,
+                        xsack: enableAutoAck ? 1 : 0,
+                        xaack: enableAutoAck ? 1 : 0,
+                        xsqos: enableQoS ? 1 : 0,
+                        qos_level: enableQoS ? QoSLevel : void 0,
+                        qos_sdk_version: 2,
+                        ...envParams
+                    }, customParamsMap);
+                    const queryParams = Object.keys(params).reduce((pre, key)=>void 0 !== params[key] ? `${pre}${pre ? '&' : '?'}${key}=${params[key]}` : pre, '');
+                    return `${currentEndpoint}/ws/v2${queryParams}`;
+                }
+                async _connect() {
+                    if (this._connectLock || this._readyClosed) return;
+                    this._connectLock = true;
+                    try {
+                        const isReachedMaxRetries = this._endpointManager?.checkCurrentEndpointReachedMaxRetries();
+                        const { timeoutInterval } = this._options;
+                        if (isReachedMaxRetries) {
+                            const currentEndpoint = this._endpointManager?.getCurrentEndpoint();
+                            const backUpEndpoint = this._endpointManager?.replaceBackupEndpointAndUpdateCount();
+                            const backUpEndpointTriesCount = this._endpointManager?.getCurrentEndpointTriesCount();
+                            if (backUpEndpoint) {
+                                const message = `connect ${currentEndpoint} timeout, max retries reached, will use backup endpoint ${backUpEndpoint} to retry`;
+                                const errorEvent = createErrorEvent('error', {
+                                    message,
+                                    code: event_ErrorCode.MAX_RETRIES_ERROR
+                                });
+                                this._debug(message);
+                                this._dispatchErrorEvent(errorEvent);
+                                this._url = await this._generateUrl(backUpEndpoint);
+                                this._debug(`connect ${backUpEndpoint} ${backUpEndpointTriesCount} times`);
+                                this._removeWsListeners();
+                            } else {
+                                const message = `connect ${currentEndpoint} timeout, max retries reached`;
+                                this._debug(message);
+                                this._dispatchErrorEvent(createErrorEvent('error', {
+                                    message,
+                                    code: event_ErrorCode.MAX_RETRIES_ERROR
+                                }));
+                                return;
+                            }
+                        } else {
+                            const currentEndpoint = this._endpointManager?.getCurrentEndpointAndUpdateCount();
+                            const currentEndpointTriesCount = this._endpointManager?.getCurrentEndpointTriesCount();
+                            this._url = await this._generateUrl(currentEndpoint || '');
+                            this._debug(`connect ${currentEndpoint} ${currentEndpointTriesCount} times`);
+                            this._removeWsListeners();
+                        }
+                        if (this._isInit) this._isInit = false;
+                        else {
+                            const reconnectEvent = createReconnectEvent('reconnect', {
+                                message: 'start'
+                            });
+                            this.onStartReconnect && this.onStartReconnect(reconnectEvent);
+                        }
+                        const currentEndpointTriesCount = this._endpointManager?.getCurrentEndpointTriesCount() || 0;
+                        if (currentEndpointTriesCount > 1) await this._wait(currentEndpointTriesCount - 1);
+                        this._debug(`connecting url: ${this._url} protocols: ${this._protocols}`);
+                        this._ws = globalWebSocketInit({
+                            url: this._url,
+                            protocols: [
+                                this._protocols
+                            ],
+                            headers: this._options.miniProgramParams.customHttpHeader
+                        }, this._options.ws);
+                        if (this._isBrowser || this._isWorker) this._ws && (this._ws.binaryType = this._binaryType);
+                        this._addWsListeners();
+                        this._connectionTimeoutId = setTimeout(this._onTimeout.bind(this), timeoutInterval);
+                    } catch (err) {
+                        this._connectLock = false;
+                        throw err;
+                    }
+                }
+                _clearTimer() {
+                    clearTimeout(this._connectionTimeoutId);
+                    this._connectionTimeoutId = null;
+                }
+                _clearPingTimer() {
+                    clearTimeout(this._pingPongTimeoutId);
+                    clearTimeout(this._reconnectTimeoutId);
+                    this._pingPongTimeoutId = null;
+                    this._reconnectTimeoutId = null;
+                }
+                _debug(...args) {
+                    if (this._options.debug) console.log.apply(console, [
+                        'FRONTIER>',
+                        ...args
+                    ]);
+                }
+                _getIntervalValue(times) {
+                    const { initReconnectInterval, maxReconnectInterval, reconnectIntervalGrowFactor } = this._options;
+                    const nextInterval = initReconnectInterval * Math.pow(reconnectIntervalGrowFactor, times - 1);
+                    return nextInterval > maxReconnectInterval ? maxReconnectInterval : nextInterval;
+                }
+                _ping() {
+                    if (this._ws && this._ws.readyState === this.CONNECTING) {
+                        this._clearPingTimer();
+                        this._pingPongTimeoutId = setTimeout(this._ping.bind(this), this._options.pingInterval);
+                        return;
+                    }
+                    if (!this._ws || this._ws.readyState !== this.OPEN) return void this._handleReconnect();
+                    this._ws && this._ws.send('hi');
+                    this._reconnectTimeoutId = setTimeout(this._handleReconnectTimeout.bind(this), this._options.pingTimeoutInterval);
+                }
+                _handleReconnectTimeout() {
+                    this._pingLossCounter?.addCount();
+                    this.emit('ping_once_timeout', 'timeout');
+                    if (this._pingLossCounter?.checkReachMaxCount()) this._handleReconnect();
+                    else this._ping();
+                }
+                _navigatorOnline() {
+                    if (this._isMiniTT || this._isMiniWX) return this._miniNavigatorOnline;
+                    if ((this._isBrowser || this._isWorker) && this._options.listenNetworkChanged) return navigator.onLine;
+                    return true;
+                }
+                _handleReconnect() {
+                    if (!this._navigatorOnline() || this._readyClosed) return;
+                    this._endpointManager?.resetEndpointConfig();
+                    this._pingLossCounter?.resetCounter();
+                    this._ws ? this._disconnect(1001, 'going away, try reconnecting server', true) : this._connect();
+                }
+                _onPageNetWorkChange() {
+                    if (this._isMiniTT) tt.onNetworkStatusChange(({ isConnected })=>{
+                        this._miniNavigatorOnline = isConnected;
+                        isConnected ? this._handleOnLine() : this._handleOffLine();
+                    });
+                    else if (this._isMiniWX) wx.onNetworkStatusChange(({ isConnected })=>{
+                        this._miniNavigatorOnline = isConnected;
+                        isConnected ? this._handleOnLine() : this._handleOffLine();
+                    });
+                }
+                _wait(times) {
+                    return new Promise((resolve)=>{
+                        setTimeout(resolve, this._getIntervalValue(times));
+                    });
+                }
+                _disconnect(code = 1000, reason = '', needReconnect = false) {
+                    if (!this._ws) return;
+                    this._destroyWebSocket(code, reason, needReconnect);
+                }
+                _onTimeout() {
+                    const currentEndpoint = this._endpointManager?.getCurrentEndpoint();
+                    this._debug(`connect ${currentEndpoint} timeout`);
+                    this._disconnect(1001, 'timeout, try reconnecting', true);
+                }
+                _sendAck(frameData) {
+                    const encodedData = protobuf_encodeFrame(frameData);
+                    if (this._ws && this._ws.readyState === this.OPEN) {
+                        this._ws && this._ws.send(encodedData);
+                        this._debug('send_ack', frameData);
+                    }
+                }
+                _removeWsListeners() {
+                    if (!this._ws) return;
+                    this._ws.removeEventListener('open', this._onOpen);
+                    this._ws.removeEventListener('close', this._onClose);
+                    this._ws.removeEventListener('message', this._onMessage);
+                    this._ws.removeEventListener('error', this._onError);
+                }
+                _addWsListeners() {
+                    if (!this._ws) return;
+                    this._ws.addEventListener('open', this._onOpen);
+                    this._ws.addEventListener('close', this._onClose);
+                    this._ws.addEventListener('message', this._onMessage);
+                    this._ws.addEventListener('error', this._onError);
+                }
+                _wsInstanceClose(code = 1000, reason = '') {
+                    try {
+                        this._ws && this._ws.close(code, reason);
+                    } catch  {}
+                }
+                _destroyWebSocket(code = 1000, reason = '', needReconnect = false) {
+                    this._clearPingTimer();
+                    this._clearTimer();
+                    this._removeWsListeners();
+                    this._wsInstanceClose(1000, reason);
+                    this._connectLock = false;
+                    if (needReconnect && this._navigatorOnline() && !this._readyClosed) {
+                        const isReachedMaxRetries = this._endpointManager?.checkReachMaxTries();
+                        if (isReachedMaxRetries) {
+                            const currentEndpoint = this._endpointManager?.getCurrentEndpoint();
+                            this._dispatchCloseEvent(createCloseEvent('close', {
+                                code: 1006,
+                                reason: `connect ${currentEndpoint} timeout, max retries reached`,
+                                wasClean: true
+                            }));
+                        } else {
+                            const interceptorRes = this._options.reconnectInterceptor(code, reason);
+                            this._dispatchCloseEvent(createCloseEvent('close', {
+                                code,
+                                reason,
+                                wasClean: true,
+                                willReconnect: interceptorRes
+                            }));
+                            interceptorRes && this._connect();
+                        }
+                        return;
+                    }
+                    if (this._navigatorOnline() || this._readyClosed) this._dispatchCloseEvent(createCloseEvent('close', {
+                        code,
+                        reason: 'bye'
+                    }));
+                    else this._dispatchCloseEvent(createCloseEvent('close', {
+                        code: 1006,
+                        reason: 'going away, network offline'
+                    }));
+                    this._ws = null;
+                    this._endpointManager?.resetEndpointConfig();
+                    this._pingLossCounter?.resetCounter();
+                }
+                _dispatchOpenEvent(event) {
+                    this.emit('open', event);
+                    this.onopen && this.onopen(event);
+                }
+                _dispatchMessageEvent(event) {
+                    this.emit('message', event);
+                    this.onmessage && this.onmessage(event);
+                }
+                _dispatchAckMessageEvent(event) {
+                    this.emit('ack', event);
+                    this.onReceiveAck && this.onReceiveAck(event);
+                }
+                _dispatchErrorEvent(event) {
+                    this.emit('error', event);
+                    this.onerror && this.onerror(event);
+                }
+                _dispatchCloseEvent(event) {
+                    this.emit('close', event);
+                    this.onclose && this.onclose(event);
+                }
+                get binaryType() {
+                    return this._ws ? this._ws.binaryType : this._binaryType;
+                }
+                set binaryType(value) {
+                    this._binaryType = value;
+                    this._ws && (this._ws.binaryType = value);
+                }
+                get retryCount() {
+                    return this._endpointManager?.getCurrentEndpointTriesCount() || 0;
+                }
+                get bufferedAmount() {
+                    const bytes = this._messageQueue.reduce((amo, message)=>{
+                        amo += message && message.byteLength || 0;
+                        return amo;
+                    }, 0);
+                    return bytes + (this._ws ? this._ws.bufferedAmount : 0);
+                }
+                get extensions() {
+                    return this._ws ? this._ws.extensions : '';
+                }
+                get protocol() {
+                    return this._ws ? this._ws.protocol : '';
+                }
+                get readyState() {
+                    if (this._ws) return this._ws.readyState;
+                    if (this._options.automaticOpen) return this.CONNECTING;
+                    return this.CLOSED;
+                }
+                get url() {
+                    return this._ws ? this._ws.url : this._url;
+                }
+                close(code = 1000, reason) {
+                    this._readyClosed = true;
+                    this._clearTimer();
+                    this._clearPingTimer();
+                    this._dropGlobalEventListener();
+                    this._QoSManager?.closeDB();
+                    if (!this._ws) return void this._debug('close, ws instance not initialized');
+                    if (this._ws.readyState === this.CLOSED || this._ws.readyState === this.CLOSING) return void this._debug('close, ws already closed');
+                    this._destroyWebSocket(code, reason);
+                }
+                async send(data, options) {
+                    if (null == data) throw new Error('please provide a valid data, data must be a string or an arraybuffer');
+                    if ('number' == typeof data) data = JSON.stringify(data);
+                    if ('string' != typeof data && !(data instanceof ArrayBuffer) && !(data.buffer && data.buffer instanceof ArrayBuffer)) data = JSON.stringify(data);
+                    const payload = await dataToUnit8Array(data);
+                    const identifiedPayloadType = checkPayloadType(data);
+                    const { method = 0, service = this._options.service, logID = this._options.logIDGenerator(), headers = this._options.headers, payloadEncoding = this._options.payloadEncoding, payloadType = this._options.payloadType, logIDNew = this._options.logIDNewConfig.enableAutoGenerateLogIDNew ? genLogIDNew(this._options.logIDNewConfig.userIp) : '' } = options || {};
+                    if (!service) throw new Error('please provide a valid service');
+                    const frameData = {
+                        SeqID: long_Long.fromNumber(this._seqId++),
+                        LogID: long_Long.fromNumber(logID),
+                        service,
+                        method,
+                        headers,
+                        payloadEncoding: payloadEncoding instanceof Object ? payloadEncoding.encoding ? payloadEncoding.encoding : '' : payloadEncoding,
+                        payloadType: payloadType instanceof Object ? payloadType.type ? payloadType.type : identifiedPayloadType : payloadType ? payloadType : identifiedPayloadType,
+                        payload,
+                        LogIDNew: logIDNew
+                    };
+                    const encodedData = protobuf_encodeFrame(frameData);
+                    if (this._ws && this._ws.readyState === this.OPEN) {
+                        this._ws && this._ws.send(encodedData);
+                        this._debug('sent', frameData);
+                    } else if (this._messageQueue.length < this._options.maxMessageQueueLength) {
+                        this._messageQueue.push(encodedData);
+                        this._debug('enqueue', frameData);
+                    } else {
+                        this._messageQueue.shift();
+                        this._messageQueue.push(encodedData);
+                    }
+                    return {
+                        seqID: this._seqId,
+                        logID: logID,
+                        logIDNew: logIDNew
+                    };
+                }
+                async reconnect(options) {
+                    const { url } = options || {};
+                    const endpoints = Array.isArray(url) ? url : 'string' == typeof url ? [
+                        url
+                    ] : [];
+                    if (options) Object.assign(this._options, options);
+                    if (endpoints && endpoints.length) this._endpointManager = new EndpointManager(endpoints, this._options.maxRetries);
+                    else this._endpointManager?.resetEndpointConfig();
+                    this._pingLossCounter?.resetCounter(this._options.pingLossCount);
+                    this._readyClosed = false;
+                    if (this._ws && this._ws.readyState !== this.CLOSED) this._disconnect(1000, 'manual reconnecting', true);
+                    else {
+                        this._isInit = true;
+                        this._connect();
+                    }
+                }
+                async connect() {
+                    if (!this._connectLock) {
+                        this._endpointManager?.resetEndpointConfig();
+                        this._pingLossCounter?.resetCounter();
+                        this._readyClosed = false;
+                        this._isInit = true;
+                        this._connect();
+                    }
+                }
+                addEventListener(type, listener) {
+                    this.on(type, listener);
+                }
+                dispatchEvent(event) {
+                    const { type } = event;
+                    this.emit(type, event);
+                }
+                removeEventListener(type, listener) {
+                    this.off(type, listener);
+                }
+                pingOnce() {
+                    return new Promise((resolve, reject)=>{
+                        this._clearPingTimer();
+                        this._pingPongTimeoutId = setTimeout(this._ping.bind(this), this._options.pingInterval);
+                        const resolveFn = ()=>{
+                            resolve('success');
+                            this.off('ping_once_success', resolveFn);
+                            this.off('ping_once_timeout', rejectFn);
+                        };
+                        const rejectFn = ()=>{
+                            reject('timeout');
+                            this.off('ping_once_success', resolveFn);
+                            this.off('ping_once_timeout', rejectFn);
+                        };
+                        this.on('ping_once_success', resolveFn);
+                        this.on('ping_once_timeout', rejectFn);
+                        this._ping();
+                    });
+                }
+            }
+        })();
+        return __webpack_exports__;
+    })());