@bililive-tools/bilibili-recorder 1.16.1 → 1.18.0

package/lib/bilibili_api.d.ts

@@ -7,6 +7,7 @@ export declare function getRoomInit(roomIdOrShortId: number): Promise<{
     live_time: number;
     encrypted: boolean;
     is_sp: 0 | 1;
+    special_type: number;
 }>;
 export declare function getRoomInfo(roomIdOrShortId: number): Promise<{
     room_id: number;
@@ -79,6 +80,7 @@ export declare function getRoomPlayInfo(roomIdOrShortId: number, opts?: {
     short_id: number;
     live_status: LiveStatus;
     live_time: number;
+    all_special_types?: number[];
     playurl_info: {
         conf_json: string;
         playurl: {

package/lib/danma.d.ts

@@ -4,7 +4,11 @@ declare class DanmaClient extends EventEmitter {
     private roomId;
     private auth;
     private uid;
+    private readonly maxRetryCount;
     private retryCount;
+    private reconnectTimer;
+    private connectionGeneration;
+    private stopped;
     private useServerTimestamp;
     constructor(roomId: number, { auth, uid, useServerTimestamp, }: {
         auth: string | undefined;

package/lib/danma.js

@@ -46,7 +46,11 @@ class DanmaClient extends EventEmitter {
     roomId;
     auth;
     uid;
-    retryCount = 10;
+    maxRetryCount = 10;
+    retryCount = this.maxRetryCount;
+    reconnectTimer = null;
+    connectionGeneration = 0;
+    stopped = true;
     useServerTimestamp;
     constructor(roomId, { auth, uid, useServerTimestamp, }) {
         super();
@@ -56,9 +60,21 @@ class DanmaClient extends EventEmitter {
         this.useServerTimestamp = useServerTimestamp ?? true;
     }
     async start() {
+        const connectionGeneration = ++this.connectionGeneration;
+        this.stopped = false;
+        this.retryCount = this.maxRetryCount;
         const info = await getCachedBuvidConf();
+        if (this.stopped || connectionGeneration !== this.connectionGeneration)
+            return;
         const buvid3 = info.data.b_3;
         const handler = {
+            onOpen: () => {
+                this.retryCount = this.maxRetryCount;
+                this.emit("open");
+            },
+            onClose: () => {
+                this.emit("close");
+            },
             onIncomeDanmu: (msg) => {
                 let content = msg.body.content;
                 content = content.replace(/(^\s*)|(\s*$)/g, "").replace(/[\r\n]/g, "");
@@ -159,26 +175,54 @@ class DanmaClient extends EventEmitter {
                 lastAuth = `buvid3=${buvid3}`;
             }
         }
-        this.client = startListen(this.roomId, handler, {
-            ws: {
-                headers: {
-                    Cookie: lastAuth,
+        const connect = () => {
+            if (this.stopped || connectionGeneration !== this.connectionGeneration)
+                return;
+            const client = startListen(this.roomId, handler, {
+                ws: {
+                    headers: {
+                        Cookie: lastAuth,
+                    },
+                    uid: this.uid ?? 0,
+                    // 在本层控制重连次数，避免底层无限重连。
+                    keepalive: false,
                 },
-                uid: this.uid ?? 0,
-            },
-        });
-        this.client.live.on("error", (err) => {
-            this.retryCount -= 1;
-            if (this.retryCount > 0) {
-                setTimeout(() => {
-                    this.client && this.client.reconnect();
+            });
+            this.client = client;
+            client.live.on("close", () => {
+                if (this.stopped ||
+                    connectionGeneration !== this.connectionGeneration ||
+                    this.client !== client ||
+                    this.reconnectTimer) {
+                    return;
+                }
+                if (this.retryCount <= 0) {
+                    console.error(`DanmaClient reconnect failed after ${this.maxRetryCount} attempts`);
+                    return;
+                }
+                const attempt = this.maxRetryCount - this.retryCount + 1;
+                this.retryCount -= 1;
+                this.emit("reconnect", { retryCount: attempt, maxRetry: this.maxRetryCount });
+                this.reconnectTimer = setTimeout(() => {
+                    this.reconnectTimer = null;
+                    connect();
                 }, 2000);
-            }
-            this.emit("error", err);
-        });
+            });
+            client.live.on("error", (err) => {
+                console.error("DanmaClient error", err);
+            });
+        };
+        connect();
     }
     stop() {
+        this.stopped = true;
+        this.connectionGeneration += 1;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
         this.client?.close();
+        this.client = null;
     }
 }
 export default DanmaClient;

package/lib/index.js

@@ -13,6 +13,7 @@ function createRecorder(opts) {
         ...mitt(),
         ...opts,
         cache: null,
+        appendTimeline: null,
         availableStreams: [],
         availableSources: [],
         state: "idle",
@@ -87,10 +88,13 @@ const checkLiveStatusAndRecord = async function ({ getSavePath, isManualStart, b
             liveStartTime: new Date(),
             recordStartTime: new Date(),
         };
-        this.state = "idle";
+        this.emit("stateChange", { state: "idle" });
     }
     catch (error) {
-        this.state = "check-error";
+        this.emit("stateChange", {
+            state: "check-error",
+            msg: `检查失败，` + (error instanceof Error ? error.message : String(error)),
+        });
         throw error;
     }
     if (this.liveInfo.liveId === banLiveId) {
@@ -106,9 +110,29 @@ const checkLiveStatusAndRecord = async function ({ getSavePath, isManualStart, b
     // 检查标题是否包含关键词，如果包含则不自动录制
     if (utils.checkTitleKeywordsBeforeRecord(this.liveInfo.title, this, isManualStart))
         return null;
-    const liveInfo = await getInfo(this.channelId);
+    const liveInfo = await getInfo(this.channelId, { cookie: this.auth });
     const { owner, title, roomId, liveStartTime, recordStartTime } = liveInfo;
     this.liveInfo = liveInfo;
+    // 特殊直播间无法录制(付费/DRM 加密、大航海权限专属、密码房等)：识别后跳过并告知用户。
+    // - 付费直播流为 DRM(SAMPLE-AES + Widevine/FairPlay/com.bilidrm)加密，ffmpeg 无法解密；
+    // - 大航海/权限专属、密码房无观看权限时拿不到可用流。
+    // 如需强行尝试(例如后续接入其它录制方式)，可设置 recorder.recordCharge = true。
+    if (!liveInfo.canRecord && this.recordCharge !== true) {
+        this.emit("DebugLog", {
+            type: "error",
+            text: `检测到${liveInfo.liveTypeDesc}(room ${roomId})，无法录制，已跳过：${title}`,
+        });
+        // 通知上层：检测到无法录制的特殊直播(供推送通知使用，由 manager 按场次去重)
+        this.emit("ChargeLive", { channelId: this.channelId });
+        // 持续状态标识：特殊直播已跳过。仅在状态变化时 emit，避免每个检查周期重复写时间线
+        if (this.state !== "charge-skipped") {
+            this.emit("stateChange", {
+                state: "charge-skipped",
+                msg: `${liveInfo.liveTypeDesc}，已跳过录制`,
+            });
+        }
+        return null;
+    }
     const qualityRetryLeft = (await this.cache.get("qualityRetryLeft")) ?? this.qualityRetry;
     const strictQuality = utils.shouldUseStrictQuality(qualityRetryLeft, this.qualityRetry, isManualStart);
     let res;
@@ -127,10 +151,13 @@ const checkLiveStatusAndRecord = async function ({ getSavePath, isManualStart, b
     catch (err) {
         if (qualityRetryLeft > 0)
             await this.cache.set("qualityRetryLeft", qualityRetryLeft - 1);
-        this.state = "check-error";
+        this.emit("stateChange", {
+            state: "check-error",
+            msg: `检查失败，` + (err instanceof Error ? err.message : String(err)),
+        });
         throw err;
     }
-    this.state = "recording";
+    this.emit("stateChange", { state: "recording" });
     const { streamOptions, currentStream: stream, sources: availableSources, streams: availableStreams, } = res;
     this.availableStreams = availableStreams.map((s) => s.desc);
     this.availableSources = availableSources.map((s) => s.name);
@@ -193,6 +220,7 @@ const checkLiveStatusAndRecord = async function ({ getSavePath, isManualStart, b
         headers: {
             Referer: "https://live.bilibili.com/",
         },
+        proxy: this.proxy,
     }, onEnd, async () => {
         const info = await getInfo(this.channelId);
         return info;
@@ -254,7 +282,10 @@ const checkLiveStatusAndRecord = async function ({ getSavePath, isManualStart, b
             const title = msg?.body?.title ?? "";
             const hasTitleKeyword = utils.hasBlockedTitleKeywords(title, this.titleKeywords);
             if (hasTitleKeyword) {
-                this.state = "title-blocked";
+                this.emit("stateChange", {
+                    state: "title-blocked",
+                    msg: `停止录制，直播间标题 "${title}" 包含关键词 "${this.titleKeywords}"`,
+                });
                 this.emit("DebugLog", {
                     type: "common",
                     text: `检测到标题包含关键词，停止录制：直播间标题 "${title}" 包含关键词 "${this.titleKeywords}"`,
@@ -264,16 +295,32 @@ const checkLiveStatusAndRecord = async function ({ getSavePath, isManualStart, b
             }
         }
     });
+    danmaClient.on("open", () => {
+        this.appendTimeline({
+            text: "弹幕连接已建立",
+        });
+    });
+    danmaClient.on("close", () => {
+        this.appendTimeline({
+            text: "弹幕连接已关闭",
+        });
+    });
+    danmaClient.on("reconnect", ({ retryCount, maxRetry }) => {
+        this.appendTimeline({
+            text: `弹幕连接已断开，正在尝试重连... (重试次数: ${retryCount}/${maxRetry})`,
+        });
+        this.emit("DebugLog", {
+            type: "common",
+            text: `弹幕连接已断开，正在尝试重连... (重试次数: ${retryCount}/${maxRetry})`,
+        });
+    });
     if (enableDanmaListen) {
-        try {
-            danmaClient.start();
-        }
-        catch (err) {
+        void danmaClient.start().catch((err) => {
             this.emit("DebugLog", {
                 type: "error",
                 text: `弹幕连接失败，错误信息: ${String(err)}`,
             });
-        }
+        });
     }
     const downloaderArgs = downloader.getArguments();
     downloader.run();
@@ -285,7 +332,7 @@ const checkLiveStatusAndRecord = async function ({ getSavePath, isManualStart, b
     const stop = utils.singleton(async (reason) => {
         if (!this.recordHandle)
             return;
-        this.state = "stopping-record";
+        this.emit("stateChange", { state: "stopping-record" });
         intervalId && clearInterval(intervalId);
         try {
             danmaClient.stop();
@@ -302,7 +349,7 @@ const checkLiveStatusAndRecord = async function ({ getSavePath, isManualStart, b
         this.emit("RecordStop", { recordHandle: this.recordHandle, reason });
         this.recordHandle = undefined;
         this.liveInfo = undefined;
-        this.state = "idle";
+        this.emit("stateChange", { state: "idle" });
         this.cache.set("qualityRetryLeft", this.qualityRetry);
     });
     this.recordHandle = {

package/lib/stream.d.ts

@@ -14,7 +14,17 @@ export declare function getLiveStatus(channelId: string): Promise<{
     owner: string;
     title: string;
 }>;
-export declare function getInfo(channelId: string): Promise<{
+/**
+ * 直播类型(B站专属)：
+ * - normal:   普通直播，可正常录制
+ * - paid:     付费/充电直播，流为 DRM(SAMPLE-AES + Widevine/FairPlay/com.bilidrm)加密，无法录制
+ * - guard:    大航海/权限专属直播(舰长/提督/总督等)，无观看权限时拿不到流
+ * - password: 密码加密直播间，未验证密码拿不到流
+ */
+export type BiliLiveType = "normal" | "paid" | "guard" | "password";
+export declare function getInfo(channelId: string, opts?: {
+    cookie?: string;
+}): Promise<{
     living: boolean;
     owner: string;
     title: string;
@@ -26,6 +36,10 @@ export declare function getInfo(channelId: string): Promise<{
     liveStartTime: Date;
     recordStartTime: Date;
     area: string;
+    liveType: BiliLiveType;
+    liveTypeDesc: string;
+    canRecord: boolean;
+    isCharge: boolean;
 }>;
 export declare function getStream(opts: Pick<Recorder, "channelId" | "quality"> & {
     cookie?: string;

package/lib/stream.js

@@ -19,7 +19,9 @@ export async function getLiveStatus(channelId) {
     if (data) {
         const startTime = new Date(data.live_time);
         return {
-            living: data.live_status === 1 && !data.is_encrypted,
+            // living 仅反映主播是否在播(live_status===1)；加密/付费/权限等"房间特殊状态"
+            // 不并入 living，由 getInfo 的 liveType/canRecord 单独判定。
+            living: data.live_status === 1,
             liveId: utils.md5(`${channelId}-${startTime?.getTime()}`),
             owner: data.uname,
             title: data.title,
@@ -28,53 +30,115 @@ export async function getLiveStatus(channelId) {
     const roomInit = await getRoomInit(Number(channelId));
     const startTime = new Date(roomInit.live_time * 1000);
     return {
-        living: roomInit.live_status === 1 && !roomInit.encrypted,
+        living: roomInit.live_status === 1,
         liveId: utils.md5(`${roomInit.room_id}-${startTime?.getTime()}`),
         ...roomInit,
         owner: "",
         title: "",
     };
 }
-export async function getInfo(channelId) {
+const LIVE_TYPE_DESC = {
+    normal: "普通直播",
+    paid: "付费直播(DRM 加密)",
+    guard: "大航海/权限专属直播",
+    password: "密码加密直播",
+};
+export async function getInfo(channelId, opts = {}) {
     const roomInit = await getRoomInit(Number(channelId));
-    const { [roomInit.uid]: status } = await getStatusInfoByUIDs([roomInit.uid]);
+    // 判断 1：是否在直播。仅看 live_status，不混入加密/付费等房间特殊状态。
+    const living = roomInit.live_status === 1;
     const recordStartTime = new Date();
-    if (!status) {
-        // 未获取到直播间信息，可能是加密，尝试换一个接口
+    // 基础信息(主播名/标题/封面等)始终获取，供频道预览(离线也要展示)。
+    let owner = "";
+    let title = "";
+    let avatar = "";
+    let cover = "";
+    let area = "";
+    let liveStartTime = new Date(0);
+    const { [roomInit.uid]: status } = await getStatusInfoByUIDs([roomInit.uid]);
+    if (status) {
+        owner = status.uname;
+        title = status.title;
+        avatar = status.face;
+        cover = status.cover_from_user;
+        area = status.area_v2_parent_name;
+        liveStartTime = new Date(status.live_time * 1000);
+    }
+    else {
+        // 未获取到直播间信息(可能是加密房等)，换一个接口取基础信息
         const data = await getRoomBaseInfo(Number(channelId));
-        const status = data[channelId];
-        const liveStartTime = new Date(status.live_time);
-        return {
-            uid: roomInit.uid,
-            living: roomInit.live_status === 1 && !roomInit.encrypted,
-            owner: status.uname,
-            title: status.title,
-            liveStartTime: liveStartTime,
-            avatar: "",
-            cover: status.cover,
-            roomId: roomInit.room_id,
-            liveId: utils.md5(`${roomInit.room_id}-${liveStartTime?.getTime()}`),
-            recordStartTime,
-            area: status.parent_area_name,
-        };
+        const base = data[Number(channelId)];
+        if (base) {
+            owner = base.uname;
+            title = base.title;
+            cover = base.cover;
+            liveStartTime = new Date(base.live_time);
+        }
     }
-    const liveStartTime = new Date(status.live_time * 1000);
+    // 判断 2 + 3：直播类型与能否录制。仅在播时才探测流(不在播无需多余请求)。
+    // 判定优先级(自上而下，命中即止)：
+    //   1. 密码房   → 未验证密码拿不到流，优先判定，不再请求取流接口
+    //   2. 付费标记 → room_init 的 is_sp/special_type 在付费直播进行时翻 1，无需取流即可确认
+    //   3. 取流探测 → 上面都未命中时才请求 getRoomPlayInfo，区分 DRM付费 / 权限受限 / 普通可录
+    let liveType = "normal";
+    let canRecord = false;
+    if (living) {
+        const paidByRoomInit = roomInit.is_sp === 1 || roomInit.special_type === 1;
+        if (roomInit.encrypted) {
+            liveType = "password";
+        }
+        else if (paidByRoomInit) {
+            liveType = "paid";
+        }
+        else {
+            try {
+                const playInfo = await getRoomPlayInfo(Number(channelId), { cookie: opts.cookie });
+                // all_special_types 含 203 = B站播放器自身判定的 DRM 加密直播
+                const allSpecialTypes = playInfo.all_special_types ?? [];
+                const isDRM = Array.isArray(allSpecialTypes) && allSpecialTypes.includes(203);
+                const hasStream = (playInfo.playurl_info?.playurl?.stream?.length ?? 0) > 0;
+                if (isDRM) {
+                    liveType = "paid";
+                }
+                else if (!hasStream) {
+                    // 取流接口正常返回、却拿不到任何流 → 权限受限(舰长/大航海等专属直播)
+                    liveType = "guard";
+                }
+                else {
+                    liveType = "normal";
+                    canRecord = true;
+                }
+            }
+            catch {
+                // 取流接口异常(网络/瞬时错误)：不臆断为权限受限，按普通直播放行，
+                // 交由后续 getStream 重试并产生 check-error，避免误跳过导致漏录。
+                liveType = "normal";
+                canRecord = true;
+            }
+        }
+    }
+    const liveTypeDesc = LIVE_TYPE_DESC[liveType];
     return {
         uid: roomInit.uid,
-        living: roomInit.live_status === 1 && !roomInit.encrypted,
-        owner: status.uname,
-        title: status.title,
-        avatar: status.face,
-        cover: status.cover_from_user,
+        living,
+        liveType,
+        liveTypeDesc,
+        canRecord,
+        isCharge: liveType === "paid",
+        owner,
+        title,
+        avatar,
+        cover,
         roomId: roomInit.room_id,
-        liveStartTime: liveStartTime,
+        liveStartTime,
         liveId: utils.md5(`${roomInit.room_id}-${liveStartTime.getTime()}`),
         recordStartTime,
-        area: status.area_v2_parent_name,
+        area,
     };
 }
 async function getLiveInfo(roomIdOrShortId, opts) {
     const res = await getRoomPlayInfo(roomIdOrShortId, opts);
+    assert(res.playurl_info, "没有找到流");
     // https://github.com/FFmpeg/FFmpeg/commit/b76053d8bf322b197a9d07bd27bbdad14fd5bc15
     let conditons = [
         {
@@ -208,10 +272,6 @@ async function getLiveInfo(roomIdOrShortId, opts) {
 }
 export async function getStream(opts) {
     const roomId = Number(opts.channelId);
-    const roomInit = await getRoomInit(roomId);
-    if (roomInit.live_status !== 1) {
-        throw new Error("It must be called getStream when living");
-    }
     const qn = BiliQualities.includes(opts.quality) ? opts.quality : 10000;
     let liveInfo = await getLiveInfo(roomId, {
         qn: qn,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bililive-tools/bilibili-recorder",
-  "version": "1.16.1",
+  "version": "1.18.0",
   "description": "bililive-tools bilibili recorder implemention",
   "main": "./lib/index.js",
   "type": "module",
@@ -34,12 +34,12 @@
   "author": "renmu123",
   "license": "LGPL",
   "dependencies": {
-    "blive-message-listener": "^0.5.2",
+    "blive-message-listener": "^0.5.5",
     "mitt": "^3.0.1",
     "tiny-bilibili-ws": "^1.0.2",
     "lodash-es": "^4.17.21",
     "axios": "^1.15.0",
-    "@bililive-tools/manager": "^1.16.2"
+    "@bililive-tools/manager": "^1.17.0"
   },
   "scripts": {
     "build": "tsc",

package/lib/blive-message-listener/chunk-5NTNTWA4.d.ts

@@ -1 +0,0 @@
-export function listenAll(instance: any, roomId: any, handler: any): void;

package/lib/blive-message-listener/chunk-5NTNTWA4.js

@@ -1,821 +0,0 @@
-// src/parser/HEARTBEAT.ts
-var parser = (data) => {
-    return {
-        attention: data,
-    };
-};
-var HEARTBEAT = {
-    parser,
-    eventName: "heartbeat",
-    handlerName: "onAttentionChange",
-};
-// src/parser/LIVE.ts
-var parser2 = (data) => {
-    return {
-        live_platform: data.live_platform,
-        room_id: data.roomid,
-    };
-};
-var LIVE = {
-    parser: parser2,
-    eventName: "LIVE",
-    handlerName: "onLiveStart",
-};
-// src/parser/PREPARING.ts
-var parser3 = (data) => {
-    return {
-        room_id: parseInt(data.roomid),
-    };
-};
-var PREPARING = {
-    parser: parser3,
-    eventName: "PREPARING",
-    handlerName: "onLiveEnd",
-};
-// src/parser/ANCHOR_LOT_AWARD.ts
-var parser4 = (data, roomId) => {
-    const rawData = data.data;
-    return {
-        id: rawData.id,
-        award: {
-            image: rawData.award_image,
-            name: rawData.award_name,
-            virtual: rawData.award_type === 1,
-        },
-        winner: rawData.award_users.map((user) => ({
-            uid: user.uid,
-            uname: user.uname,
-            face: user.face,
-            level: user.level,
-            num: user.num,
-        })),
-    };
-};
-var ANCHOR_LOT_AWARD = {
-    parser: parser4,
-    eventName: "ANCHOR_LOT_AWARD",
-    handlerName: "onAnchorLotteryEnd",
-};
-// src/parser/ANCHOR_LOT_START.ts
-var parser5 = (data, roomId) => {
-    const rawData = data.data;
-    return {
-        id: rawData.id,
-        start_time: rawData.current_time,
-        duration: rawData.max_time,
-        award: {
-            image: rawData.award_image,
-            name: rawData.award_name,
-            num: rawData.award_num,
-            virtual: rawData.award_type === 1,
-            price_text: rawData.award_price_text || "",
-        },
-        require: {
-            danmu: rawData.danmu || "",
-            gift: rawData.gift_id
-                ? {
-                    id: `${rawData.gift_id}`,
-                    name: rawData.gift_name,
-                    num: rawData.gift_num,
-                    price: rawData.gift_price,
-                }
-                : null,
-            user: rawData.require_type
-                ? {
-                    type: ["follow", "medal", "guard"][rawData.require_type - 1],
-                    value: rawData.require_value,
-                    text: rawData.require_text,
-                }
-                : null,
-        },
-    };
-};
-var ANCHOR_LOT_START = {
-    parser: parser5,
-    eventName: "ANCHOR_LOT_START",
-    handlerName: "onAnchorLotteryStart",
-};
-// src/utils/color.ts
-var intToColorHex = (int) => {
-    const hex = int.toString(16);
-    return `#${hex.padStart(6, "0")}`;
-};
-// src/parser/DANMU_MSG.ts
-var parser6 = (data, roomId) => {
-    const rawData = data.info;
-    const content = rawData?.[1];
-    if (!content)
-        return;
-    const shouldParseInMessageEmoticon = /\[.*?\]/.test(content);
-    let inMessageEmoticon;
-    if (shouldParseInMessageEmoticon) {
-        const messageExtraInfo = JSON.parse(rawData[0][15].extra);
-        const emoctionDict = {};
-        if (messageExtraInfo.emots) {
-            inMessageEmoticon = Object.keys(messageExtraInfo.emots).reduce((acc, key) => {
-                const emoticon = messageExtraInfo.emots[key];
-                acc[key] = {
-                    id: emoticon.emoticon_unique,
-                    emoticon_id: emoticon.emoticon_id,
-                    height: emoticon.height,
-                    width: emoticon.width,
-                    url: emoticon.url,
-                    description: emoticon.descript,
-                };
-                return acc;
-            }, emoctionDict);
-        }
-    }
-    return {
-        user: {
-            uid: rawData[2][0],
-            uname: rawData[2][1],
-            badge: rawData[3].length
-                ? {
-                    active: rawData[3][7] !== 12632256,
-                    name: rawData[3][1],
-                    level: rawData[3][0],
-                    color: intToColorHex(rawData[3][4]),
-                    gradient: [
-                        intToColorHex(rawData[3][7]),
-                        intToColorHex(rawData[3][8]),
-                        intToColorHex(rawData[3][9]),
-                    ],
-                    anchor: {
-                        uid: rawData[3][12],
-                        uname: rawData[3][2],
-                        room_id: rawData[3][3],
-                        is_same_room: rawData[3][3] === roomId,
-                    },
-                }
-                : void 0,
-            identity: {
-                rank: rawData[4][4],
-                guard_level: rawData[7],
-                room_admin: rawData[2][2] === 1,
-            },
-        },
-        content,
-        type: rawData[0][1],
-        content_color: intToColorHex(rawData[0][3]),
-        timestamp: rawData[0][4],
-        lottery: rawData[0][9] !== 0,
-        emoticon: rawData[0][13]?.emoticon_unique
-            ? {
-                id: rawData[0][13].emoticon_unique,
-                height: rawData[0][13].height,
-                width: rawData[0][13].width,
-                url: rawData[0][13].url,
-            }
-            : void 0,
-        in_message_emoticon: inMessageEmoticon,
-    };
-};
-var DANMU_MSG = {
-    parser: parser6,
-    eventName: "DANMU_MSG",
-    handlerName: "onIncomeDanmu",
-};
-// src/parser/GUARD_BUY.ts
-var parser7 = (data) => {
-    const rawData = data.data;
-    return {
-        user: {
-            uid: rawData.uid,
-            uname: rawData.username,
-        },
-        gift_id: rawData.gift_id,
-        gift_name: rawData.gift_name,
-        guard_level: rawData.guard_level,
-        price: rawData.price,
-        start_time: rawData.start_time,
-        end_time: rawData.end_time,
-    };
-};
-var GUARD_BUY = {
-    parser: parser7,
-    eventName: "GUARD_BUY",
-    handlerName: "onGuardBuy",
-};
-// src/parser/INTERACT_WORD_ENTRY_EFFECT.ts
-var parserNormal = (data, roomId) => {
-    const rawData = data.data;
-    let actionType = "unknown";
-    if (rawData.msg_type === 1) {
-        actionType = "enter";
-    }
-    else if (rawData.msg_type === 2) {
-        actionType = "follow";
-    }
-    else if (rawData.msg_type === 3) {
-        actionType = "share";
-    }
-    return {
-        user: {
-            uid: rawData.uid,
-            uname: rawData.uname,
-            face: rawData?.face,
-            badge: rawData.fans_medal?.target_id
-                ? {
-                    active: !!rawData.fans_medal?.is_lighted,
-                    name: rawData.fans_medal?.medal_name,
-                    level: rawData.fans_medal?.medal_level,
-                    color: intToColorHex(rawData.fans_medal?.medal_color),
-                    gradient: [
-                        intToColorHex(rawData.fans_medal?.medal_color_start),
-                        intToColorHex(rawData.fans_medal?.medal_color_start),
-                        intToColorHex(rawData.fans_medal?.medal_color_end),
-                    ],
-                    anchor: {
-                        uid: rawData.fans_medal?.target_id,
-                        uname: "",
-                        room_id: rawData.fans_medal?.anchor_roomid,
-                        is_same_room: rawData.fans_medal?.anchor_roomid === roomId,
-                    },
-                }
-                : void 0,
-            identity: {
-                rank: 0,
-                guard_level: rawData.privilege_type,
-                room_admin: false,
-            },
-        },
-        action: actionType,
-        timestamp: Math.ceil(rawData.trigger_time / 1e6),
-    };
-};
-var parserGuard = (data, roomId) => {
-    const rawData = data.data;
-    const uname = /<%(.*)%>/.exec(rawData.copy_writing)?.[1] || "";
-    return {
-        user: {
-            uid: rawData.uid,
-            uname,
-            // 超长会有省略号
-            identity: {
-                rank: 0,
-                guard_level: rawData.privilege_type,
-                room_admin: false,
-            },
-        },
-        action: "enter",
-        timestamp: Math.ceil(rawData.trigger_time / 1e6),
-    };
-};
-var parserLike = (data, roomId) => {
-    const rawData = data.data;
-    return {
-        user: {
-            uid: rawData.uid,
-            uname: rawData.uname,
-            badge: rawData.fans_medal?.target_id
-                ? {
-                    active: rawData.fans_medal?.is_lighted,
-                    name: rawData.fans_medal?.medal_name,
-                    level: rawData.fans_medal?.medal_level,
-                    color: intToColorHex(rawData.fans_medal?.medal_color),
-                    gradient: [
-                        intToColorHex(rawData.fans_medal?.medal_color_start),
-                        intToColorHex(rawData.fans_medal?.medal_color_start),
-                        intToColorHex(rawData.fans_medal?.medal_color_end),
-                    ],
-                    anchor: {
-                        uid: rawData.fans_medal?.target_id,
-                        uname: "",
-                        room_id: rawData.fans_medal?.anchor_roomid,
-                        // 返回为 0
-                        is_same_room: rawData.fans_medal?.anchor_roomid === roomId,
-                    },
-                }
-                : void 0,
-        },
-        action: "like",
-        timestamp: Date.now(),
-    };
-};
-var parser8 = (data, roomId) => {
-    const msgType = data.cmd;
-    if (msgType === "ENTRY_EFFECT") {
-        return parserGuard(data, roomId);
-    }
-    if (msgType === "LIKE_INFO_V3_CLICK") {
-        return parserLike(data, roomId);
-    }
-    return parserNormal(data, roomId);
-};
-var INTERACT_WORD = {
-    parser: parser8,
-    eventName: "INTERACT_WORD",
-    handlerName: "onUserAction",
-};
-var ENTRY_EFFECT = {
-    parser: parser8,
-    eventName: "ENTRY_EFFECT",
-    handlerName: "onUserAction",
-};
-var LIKE_INFO_V3_CLICK = {
-    parser: parser8,
-    eventName: "LIKE_INFO_V3_CLICK",
-    handlerName: "onUserAction",
-};
-// src/parser/LIKE_INFO_V3_UPDATE.ts
-var parser9 = (data) => {
-    const rawData = data.data;
-    return {
-        count: rawData.click_count,
-    };
-};
-var LIKE_INFO_V3_UPDATE = {
-    parser: parser9,
-    eventName: "LIKE_INFO_V3_UPDATE",
-    handlerName: "onLikedChange",
-};
-// src/parser/ONLINE_RANK_COUNT.ts
-var parser10 = (data) => {
-    const rawData = data.data;
-    return {
-        count: rawData.count,
-    };
-};
-var ONLINE_RANK_COUNT = {
-    parser: parser10,
-    eventName: "ONLINE_RANK_COUNT",
-    handlerName: "onRankCountChange",
-};
-// src/parser/POPULARITY_RED_POCKET_START.ts
-var parser11 = (data, roomId) => {
-    const rawData = data.data;
-    return {
-        id: rawData.lot_id,
-        user: {
-            uid: rawData.sender_uid,
-            uname: rawData.sender_name,
-            face: rawData.sender_face,
-        },
-        start_time: rawData.start_time,
-        end_time: rawData.end_time,
-        duration: rawData.last_time,
-        danmu: rawData.danmu,
-        awards: rawData.awards,
-        total_price: rawData.total_price,
-        wait_num: rawData.wait_num,
-    };
-};
-var POPULARITY_RED_POCKET_START = {
-    parser: parser11,
-    eventName: "POPULARITY_RED_POCKET_START",
-    handlerName: "onRedPocketStart",
-};
-// src/parser/POPULARITY_RED_POCKET_WINNER_LIST.ts
-var parser12 = (data, roomId) => {
-    const rawData = data.data;
-    return {
-        id: rawData.lot_id,
-        total_num: rawData.total_num,
-        winner: rawData.winner_info.map((item) => ({
-            uid: item[0],
-            uname: item[1],
-            award_id: item[3],
-            ...rawData.awards[item[3]],
-        })),
-        awards: rawData.awards,
-    };
-};
-var POPULARITY_RED_POCKET_WINNER_LIST = {
-    parser: parser12,
-    eventName: "POPULARITY_RED_POCKET_WINNER_LIST",
-    handlerName: "onRedPocketEnd",
-};
-// src/parser/ROOM_ADMIN.ts
-var parser13 = (data, roomId) => {
-    const msgType = data.cmd;
-    const rawData = data;
-    return {
-        type: msgType === "room_admin_entrance" ? "set" : "revoke",
-        uid: rawData.uid,
-    };
-};
-var room_admin_entrance = {
-    parser: parser13,
-    eventName: "room_admin_entrance",
-    handlerName: "onRoomAdminSet",
-};
-var ROOM_ADMIN_REVOKE = {
-    parser: parser13,
-    eventName: "ROOM_ADMIN_REVOKE",
-    handlerName: "onRoomAdminSet",
-};
-// src/parser/ROOM_CHANGE.ts
-var parser14 = (data) => {
-    const rawData = data.data;
-    return {
-        title: rawData.title,
-        parent_area_id: rawData.parent_area_id,
-        parent_area_name: rawData.parent_area_name,
-        area_id: rawData.area_id,
-        area_name: rawData.area_name,
-    };
-};
-var ROOM_CHANGE = {
-    parser: parser14,
-    eventName: "ROOM_CHANGE",
-    handlerName: "onRoomInfoChange",
-};
-// src/parser/ROOM_SILENT.ts
-var parser15 = (data, roomId) => {
-    const msgType = data.cmd;
-    const rawData = data.data;
-    return {
-        type: msgType === "ROOM_SILENT_OFF" ? "off" : rawData.type,
-        level: rawData.level,
-        second: rawData.second,
-    };
-};
-var ROOM_SILENT_ON = {
-    parser: parser15,
-    eventName: "ROOM_SILENT_ON",
-    handlerName: "onRoomSilent",
-};
-var ROOM_SILENT_OFF = {
-    parser: parser15,
-    eventName: "ROOM_SILENT_OFF",
-    handlerName: "onRoomSilent",
-};
-// src/parser/SEND_GIFT.ts
-var parser16 = (data) => {
-    const rawData = data.data;
-    return {
-        user: {
-            uid: rawData.uid,
-            uname: rawData.uname,
-            face: rawData.face,
-            badge: rawData.medal_info?.medal_level
-                ? {
-                    active: rawData.medal_info.is_lighted === 1,
-                    name: rawData.medal_info.medal_name,
-                    level: rawData.medal_info.medal_level,
-                    color: intToColorHex(rawData.medal_info.medal_color),
-                    gradient: [
-                        intToColorHex(rawData.medal_info.medal_color_start),
-                        intToColorHex(rawData.medal_info.medal_color_start),
-                        intToColorHex(rawData.medal_info.medal_color_end),
-                    ],
-                    anchor: {
-                        uid: rawData.medal_info.target_id,
-                        uname: rawData.medal_info.anchor_uname,
-                        // maybe ''
-                        room_id: rawData.medal_info.anchor_roomid,
-                        // maybe 0
-                    },
-                }
-                : void 0,
-            identity: {
-                rank: 0,
-                guard_level: rawData.guard_level,
-                room_admin: false,
-            },
-        },
-        gift_id: rawData.giftId,
-        gift_name: rawData.giftName,
-        coin_type: rawData.coin_type,
-        price: rawData.price,
-        amount: rawData.num,
-        send_master: rawData.send_master?.uid
-            ? {
-                uid: rawData.send_master.uid,
-                uname: rawData.send_master.uname,
-                room_id: rawData.send_master.room_id,
-            }
-            : void 0,
-        // 礼物连击：
-        // data.combo_send 仅首次连击不为空；data.batch_combo_send 速度过快时可能为空；data.batch_combo_id 常驻存在
-        combo: rawData.batch_combo_id
-            ? {
-                batch_id: rawData.batch_combo_id,
-                combo_num: rawData.super_batch_gift_num,
-                total_price: rawData.combo_total_coin,
-            }
-            : void 0,
-    };
-};
-var SEND_GIFT = {
-    parser: parser16,
-    eventName: "SEND_GIFT",
-    handlerName: "onGift",
-};
-// src/parser/SUPER_CHAT_MESSAGE.ts
-var parser17 = (data, roomId) => {
-    const rawData = data.data;
-    const { medal_info, user_info } = data.data;
-    return {
-        id: rawData.id,
-        user: {
-            uid: rawData.uid,
-            uname: rawData.user_info.uname,
-            badge: medal_info
-                ? {
-                    active: medal_info.is_lighted === 1,
-                    name: medal_info.medal_name,
-                    level: medal_info.medal_level,
-                    color: medal_info.medal_color,
-                    anchor: {
-                        uid: medal_info.target_id,
-                        uname: medal_info.anchor_uname,
-                        room_id: medal_info.anchor_roomid,
-                        is_same_room: medal_info.anchor_roomid === roomId,
-                    },
-                }
-                : void 0,
-            identity: {
-                rank: 0,
-                guard_level: user_info.guard_level || 0,
-                room_admin: user_info.manager === 1,
-            },
-        },
-        content: rawData.message,
-        content_color: rawData.background_price_color,
-        price: rawData.price,
-        time: rawData.time,
-    };
-};
-var SUPER_CHAT_MESSAGE = {
-    parser: parser17,
-    eventName: "SUPER_CHAT_MESSAGE",
-    handlerName: "onIncomeSuperChat",
-};
-// src/parser/WARNING_CUT_OFF.ts
-var parser18 = (data, roomId) => {
-    const msgType = data.cmd;
-    const rawData = data;
-    return {
-        type: msgType === "WARNING" ? "warning" : "cut",
-        msg: rawData.msg,
-    };
-};
-var WARNING = {
-    parser: parser18,
-    eventName: "WARNING",
-    handlerName: "onRoomWarn",
-};
-var CUT_OFF = {
-    parser: parser18,
-    eventName: "CUT_OFF",
-    handlerName: "onRoomWarn",
-};
-// src/parser/WATCHED_CHANGE.ts
-var parser19 = (data) => {
-    const rawData = data.data;
-    return {
-        num: rawData.num,
-        text_small: rawData.text_small,
-    };
-};
-var WATCHED_CHANGE = {
-    parser: parser19,
-    eventName: "WATCHED_CHANGE",
-    handlerName: "onWatchedChange",
-};
-// src/utils/message.ts
-var normalizeDanmu = (msgType, body, rawBody) => {
-    const timestamp = Date.now();
-    const randomText = Math.floor(Math.random() * 1e4).toString();
-    const id = `${timestamp}:${msgType}:${body.user?.uid}:${randomText}`;
-    return {
-        id,
-        timestamp,
-        type: msgType,
-        body,
-        raw: rawBody,
-    };
-};
-// src/listener/index.ts
-var listenAll = (instance, roomId, handler) => {
-    if (!handler)
-        return;
-    const rawHandler = handler.raw || {};
-    const rawHandlerNames = new Set(Object.keys(rawHandler));
-    const isHandleRaw = rawHandlerNames.size > 0;
-    if (handler.onOpen) {
-        instance.on("open", () => {
-            handler.onOpen?.();
-        });
-    }
-    if (handler.onClose) {
-        instance.on("close", () => {
-            handler.onClose?.();
-        });
-    }
-    if (handler.onStartListen) {
-        instance.on("live", () => {
-            handler.onStartListen?.();
-        });
-    }
-    if (handler[HEARTBEAT.handlerName] || rawHandlerNames.has(HEARTBEAT.eventName)) {
-        rawHandlerNames.delete(HEARTBEAT.eventName);
-        instance.on(HEARTBEAT.eventName, (data) => {
-            isHandleRaw && rawHandler[HEARTBEAT.eventName]?.(data);
-            const parsedData = HEARTBEAT.parser(data);
-            handler[HEARTBEAT.handlerName]?.(normalizeDanmu(HEARTBEAT.eventName, parsedData, data));
-        });
-    }
-    if (handler[LIVE.handlerName] || rawHandlerNames.has(LIVE.eventName)) {
-        rawHandlerNames.delete(LIVE.eventName);
-        instance.on(LIVE.eventName, (data) => {
-            isHandleRaw && rawHandler[LIVE.eventName]?.(data.data);
-            const parsedData = LIVE.parser(data.data);
-            handler[LIVE.handlerName]?.(normalizeDanmu(LIVE.eventName, parsedData, data.data));
-        });
-    }
-    if (handler[PREPARING.handlerName] || rawHandlerNames.has(PREPARING.eventName)) {
-        rawHandlerNames.delete(LIVE.eventName);
-        instance.on(PREPARING.eventName, (data) => {
-            isHandleRaw && rawHandler[PREPARING.eventName]?.(data.data);
-            const parsedData = PREPARING.parser(data.data);
-            handler[PREPARING.handlerName]?.(normalizeDanmu(PREPARING.eventName, parsedData, data.data));
-        });
-    }
-    if (handler[ANCHOR_LOT_AWARD.handlerName] || rawHandlerNames.has(ANCHOR_LOT_AWARD.eventName)) {
-        rawHandlerNames.delete(ANCHOR_LOT_AWARD.eventName);
-        instance.on(ANCHOR_LOT_AWARD.eventName, (data) => {
-            isHandleRaw && rawHandler[ANCHOR_LOT_AWARD.eventName]?.(data.data);
-            const parsedData = ANCHOR_LOT_AWARD.parser(data.data, roomId);
-            handler[ANCHOR_LOT_AWARD.handlerName]?.(normalizeDanmu(ANCHOR_LOT_AWARD.eventName, parsedData, data.data));
-        });
-    }
-    if (handler[ANCHOR_LOT_START.handlerName] || rawHandlerNames.has(ANCHOR_LOT_START.eventName)) {
-        rawHandlerNames.delete(ANCHOR_LOT_START.eventName);
-        instance.on(ANCHOR_LOT_START.eventName, (data) => {
-            isHandleRaw && rawHandler[ANCHOR_LOT_START.eventName]?.(data.data);
-            const parsedData = ANCHOR_LOT_START.parser(data.data, roomId);
-            handler[ANCHOR_LOT_START.handlerName]?.(normalizeDanmu(ANCHOR_LOT_START.eventName, parsedData, data.data));
-        });
-    }
-    if (handler[DANMU_MSG.handlerName] || rawHandlerNames.has(DANMU_MSG.eventName)) {
-        rawHandlerNames.delete(DANMU_MSG.eventName);
-        instance.on(DANMU_MSG.eventName, (data) => {
-            isHandleRaw && rawHandler[DANMU_MSG.eventName]?.(data.data);
-            const parsedData = DANMU_MSG.parser(data.data, roomId);
-            if (parsedData) {
-                handler[DANMU_MSG.handlerName]?.(normalizeDanmu(DANMU_MSG.eventName, parsedData, data.data));
-            }
-        });
-    }
-    if (handler[GUARD_BUY.handlerName] || rawHandlerNames.has(GUARD_BUY.eventName)) {
-        rawHandlerNames.delete(GUARD_BUY.eventName);
-        instance.on(GUARD_BUY.eventName, (data) => {
-            isHandleRaw && rawHandler[GUARD_BUY.eventName]?.(data.data);
-            const parsedData = GUARD_BUY.parser(data.data);
-            handler[GUARD_BUY.handlerName]?.(normalizeDanmu(GUARD_BUY.eventName, parsedData, data.data));
-        });
-    }
-    if (handler[INTERACT_WORD.handlerName] ||
-        handler[ENTRY_EFFECT.handlerName] ||
-        handler[LIKE_INFO_V3_CLICK.handlerName] ||
-        rawHandlerNames.has(INTERACT_WORD.eventName) ||
-        rawHandlerNames.has(ENTRY_EFFECT.eventName) ||
-        rawHandlerNames.has(LIKE_INFO_V3_CLICK.eventName)) {
-        rawHandlerNames.delete(INTERACT_WORD.eventName);
-        rawHandlerNames.delete(ENTRY_EFFECT.eventName);
-        rawHandlerNames.delete(LIKE_INFO_V3_CLICK.eventName);
-        instance.on(INTERACT_WORD.eventName, (data) => {
-            isHandleRaw && rawHandler[INTERACT_WORD.eventName]?.(data.data);
-            const parsedData = INTERACT_WORD.parser(data.data, roomId);
-            handler[INTERACT_WORD.handlerName]?.(normalizeDanmu(INTERACT_WORD.eventName, parsedData, data.data));
-        });
-        instance.on(ENTRY_EFFECT.eventName, (data) => {
-            isHandleRaw && rawHandler[ENTRY_EFFECT.eventName]?.(data.data);
-            const parsedData = ENTRY_EFFECT.parser(data.data, roomId);
-            handler[ENTRY_EFFECT.handlerName]?.(normalizeDanmu(ENTRY_EFFECT.eventName, parsedData, data.data));
-        });
-        instance.on(LIKE_INFO_V3_CLICK.eventName, (data) => {
-            isHandleRaw && rawHandler[LIKE_INFO_V3_CLICK.eventName]?.(data.data);
-            const parsedData = LIKE_INFO_V3_CLICK.parser(data.data, roomId);
-            handler[LIKE_INFO_V3_CLICK.handlerName]?.(normalizeDanmu(LIKE_INFO_V3_CLICK.eventName, parsedData, data.data));
-        });
-    }
-    if (handler[LIKE_INFO_V3_UPDATE.handlerName] ||
-        rawHandlerNames.has(LIKE_INFO_V3_UPDATE.eventName)) {
-        rawHandlerNames.delete(LIKE_INFO_V3_UPDATE.eventName);
-        instance.on(LIKE_INFO_V3_UPDATE.eventName, (data) => {
-            isHandleRaw && rawHandler[LIKE_INFO_V3_UPDATE.eventName]?.(data.data);
-            const parsedData = LIKE_INFO_V3_UPDATE.parser(data.data);
-            handler[LIKE_INFO_V3_UPDATE.handlerName]?.(normalizeDanmu(LIKE_INFO_V3_UPDATE.eventName, parsedData, data.data));
-        });
-    }
-    if (handler[ONLINE_RANK_COUNT.handlerName] || rawHandlerNames.has(ONLINE_RANK_COUNT.eventName)) {
-        rawHandlerNames.delete(ONLINE_RANK_COUNT.eventName);
-        instance.on(ONLINE_RANK_COUNT.eventName, (data) => {
-            isHandleRaw && rawHandler[ONLINE_RANK_COUNT.eventName]?.(data.data);
-            const parsedData = ONLINE_RANK_COUNT.parser(data.data);
-            handler[ONLINE_RANK_COUNT.handlerName]?.(normalizeDanmu(ONLINE_RANK_COUNT.eventName, parsedData, data.data));
-        });
-    }
-    if (handler[POPULARITY_RED_POCKET_START.handlerName] ||
-        rawHandlerNames.has(POPULARITY_RED_POCKET_START.eventName)) {
-        rawHandlerNames.delete(POPULARITY_RED_POCKET_START.eventName);
-        instance.on(POPULARITY_RED_POCKET_START.eventName, (data) => {
-            isHandleRaw && rawHandler[POPULARITY_RED_POCKET_START.eventName]?.(data.data);
-            const parsedData = POPULARITY_RED_POCKET_START.parser(data.data, roomId);
-            handler[POPULARITY_RED_POCKET_START.handlerName]?.(normalizeDanmu(POPULARITY_RED_POCKET_START.eventName, parsedData, data.data));
-        });
-    }
-    if (handler[POPULARITY_RED_POCKET_WINNER_LIST.handlerName] ||
-        rawHandlerNames.has(POPULARITY_RED_POCKET_WINNER_LIST.eventName)) {
-        rawHandlerNames.delete(POPULARITY_RED_POCKET_WINNER_LIST.eventName);
-        instance.on(POPULARITY_RED_POCKET_WINNER_LIST.eventName, (data) => {
-            isHandleRaw && rawHandler[POPULARITY_RED_POCKET_WINNER_LIST.eventName]?.(data.data);
-            const parsedData = POPULARITY_RED_POCKET_WINNER_LIST.parser(data.data, roomId);
-            handler[POPULARITY_RED_POCKET_WINNER_LIST.handlerName]?.(normalizeDanmu(POPULARITY_RED_POCKET_WINNER_LIST.eventName, parsedData, data.data));
-        });
-    }
-    if (handler[room_admin_entrance.handlerName] ||
-        handler[ROOM_ADMIN_REVOKE.handlerName] ||
-        rawHandlerNames.has(room_admin_entrance.eventName) ||
-        rawHandlerNames.has(ROOM_SILENT_OFF.eventName)) {
-        rawHandlerNames.delete(room_admin_entrance.eventName);
-        rawHandlerNames.delete(ROOM_ADMIN_REVOKE.eventName);
-        instance.on(room_admin_entrance.eventName, (data) => {
-            isHandleRaw && rawHandler[room_admin_entrance.eventName]?.(data.data);
-            const parsedData = room_admin_entrance.parser(data.data, roomId);
-            handler[room_admin_entrance.handlerName]?.(normalizeDanmu(room_admin_entrance.eventName, parsedData, data.data));
-        });
-        instance.on(ROOM_ADMIN_REVOKE.eventName, (data) => {
-            isHandleRaw && rawHandler[ROOM_ADMIN_REVOKE.eventName]?.(data.data);
-            const parsedData = ROOM_ADMIN_REVOKE.parser(data.data, roomId);
-            handler[ROOM_ADMIN_REVOKE.handlerName]?.(normalizeDanmu(ROOM_ADMIN_REVOKE.eventName, parsedData, data.data));
-        });
-    }
-    if (handler[ROOM_CHANGE.handlerName] || rawHandlerNames.has(ROOM_CHANGE.eventName)) {
-        rawHandlerNames.delete(ROOM_CHANGE.eventName);
-        instance.on(ROOM_CHANGE.eventName, (data) => {
-            isHandleRaw && rawHandler[ROOM_CHANGE.eventName]?.(data.data);
-            const parsedData = ROOM_CHANGE.parser(data.data);
-            handler[ROOM_CHANGE.handlerName]?.(normalizeDanmu(ROOM_CHANGE.eventName, parsedData, data.data));
-        });
-    }
-    if (handler[ROOM_SILENT_ON.handlerName] ||
-        handler[ROOM_SILENT_OFF.handlerName] ||
-        rawHandlerNames.has(ROOM_SILENT_ON.eventName) ||
-        rawHandlerNames.has(ROOM_SILENT_OFF.eventName)) {
-        rawHandlerNames.delete(ROOM_SILENT_ON.eventName);
-        rawHandlerNames.delete(ROOM_SILENT_OFF.eventName);
-        instance.on(ROOM_SILENT_ON.eventName, (data) => {
-            isHandleRaw && rawHandler[ROOM_SILENT_ON.eventName]?.(data.data);
-            const parsedData = ROOM_SILENT_ON.parser(data.data, roomId);
-            handler[ROOM_SILENT_ON.handlerName]?.(normalizeDanmu(ROOM_SILENT_ON.eventName, parsedData, data.data));
-        });
-        instance.on(ROOM_SILENT_OFF.eventName, (data) => {
-            isHandleRaw && rawHandler[ROOM_SILENT_OFF.eventName]?.(data.data);
-            const parsedData = ROOM_SILENT_OFF.parser(data.data, roomId);
-            handler[ROOM_SILENT_OFF.handlerName]?.(normalizeDanmu(ROOM_SILENT_OFF.eventName, parsedData, data.data));
-        });
-    }
-    if (handler[SEND_GIFT.handlerName] || rawHandlerNames.has(SEND_GIFT.eventName)) {
-        rawHandlerNames.delete(SEND_GIFT.eventName);
-        instance.on(SEND_GIFT.eventName, (data) => {
-            isHandleRaw && rawHandler[SEND_GIFT.eventName]?.(data.data);
-            const parsedData = SEND_GIFT.parser(data.data);
-            handler[SEND_GIFT.handlerName]?.(normalizeDanmu(SEND_GIFT.eventName, parsedData, data.data));
-        });
-    }
-    if (handler[SUPER_CHAT_MESSAGE.handlerName] ||
-        rawHandlerNames.has(SUPER_CHAT_MESSAGE.eventName)) {
-        rawHandlerNames.delete(SUPER_CHAT_MESSAGE.eventName);
-        instance.on(SUPER_CHAT_MESSAGE.eventName, (data) => {
-            isHandleRaw && rawHandler[SUPER_CHAT_MESSAGE.eventName]?.(data.data);
-            const parsedData = SUPER_CHAT_MESSAGE.parser(data.data, roomId);
-            handler[SUPER_CHAT_MESSAGE.handlerName]?.(normalizeDanmu(SUPER_CHAT_MESSAGE.eventName, parsedData, data.data));
-        });
-    }
-    if (handler[WARNING.handlerName] ||
-        handler[CUT_OFF.handlerName] ||
-        rawHandlerNames.has(WARNING.eventName) ||
-        rawHandlerNames.has(CUT_OFF.eventName)) {
-        rawHandlerNames.delete(WARNING.eventName);
-        rawHandlerNames.delete(CUT_OFF.eventName);
-        instance.on(WARNING.eventName, (data) => {
-            isHandleRaw && rawHandler[WARNING.eventName]?.(data.data);
-            const parsedData = WARNING.parser(data.data, roomId);
-            handler[WARNING.handlerName]?.(normalizeDanmu(WARNING.eventName, parsedData, data.data));
-        });
-        instance.on(CUT_OFF.eventName, (data) => {
-            isHandleRaw && rawHandler[CUT_OFF.eventName]?.(data.data);
-            const parsedData = CUT_OFF.parser(data.data, roomId);
-            handler[CUT_OFF.handlerName]?.(normalizeDanmu(CUT_OFF.eventName, parsedData, data.data));
-        });
-    }
-    if (handler[WATCHED_CHANGE.handlerName] || rawHandlerNames.has(WATCHED_CHANGE.eventName)) {
-        rawHandlerNames.delete(WATCHED_CHANGE.eventName);
-        instance.on(WATCHED_CHANGE.eventName, (data) => {
-            isHandleRaw && rawHandler[WATCHED_CHANGE.eventName]?.(data.data);
-            const parsedData = WATCHED_CHANGE.parser(data.data);
-            handler[WATCHED_CHANGE.handlerName]?.(normalizeDanmu(WATCHED_CHANGE.eventName, parsedData, data.data));
-        });
-    }
-    for (const eventName of rawHandlerNames) {
-        instance.on(eventName, (data) => {
-            rawHandler[eventName]?.(data.data);
-        });
-    }
-};
-export { listenAll };

package/lib/blive-message-listener/index.d.ts

@@ -1,14 +0,0 @@
-export var GuardLevel: any;
-export function startListen(roomId: any, handler: any, options: any): {
-    live: KeepLiveTCP<object>;
-    roomId: number;
-    online: number;
-    closed: boolean;
-    close: () => boolean;
-    getAttention: () => Promise<number>;
-    getOnline: () => Promise<number>;
-    reconnect: () => void;
-    heartbeat: () => void;
-    send: (op: any, data: any) => void;
-};
-import { KeepLiveTCP } from "tiny-bilibili-ws";

package/lib/blive-message-listener/index.js

@@ -1,30 +0,0 @@
-import { listenAll } from "./chunk-5NTNTWA4.js";
-// src/index.ts
-import { KeepLiveTCP } from "tiny-bilibili-ws";
-// src/types/const.ts
-var GuardLevel = /* @__PURE__ */ ((GuardLevel2) => {
-    GuardLevel2[GuardLevel2["None"] = 0] = "None";
-    GuardLevel2[GuardLevel2["Zongdu"] = 1] = "Zongdu";
-    GuardLevel2[GuardLevel2["Tidu"] = 2] = "Tidu";
-    GuardLevel2[GuardLevel2["Jianzhang"] = 3] = "Jianzhang";
-    return GuardLevel2;
-})(GuardLevel || {});
-// src/index.ts
-var startListen = (roomId, handler, options) => {
-    const live = new KeepLiveTCP(roomId, options?.ws);
-    listenAll(live, roomId, handler);
-    const listenerInstance = {
-        live,
-        roomId: live.roomId,
-        online: live.online,
-        closed: live.closed,
-        close: () => live.close(),
-        getAttention: () => live.getOnline(),
-        getOnline: () => live.getOnline(),
-        reconnect: () => live.reconnect(),
-        heartbeat: () => live.heartbeat(),
-        send: (op, data) => live.send(op, data)
-    };
-    return listenerInstance;
-};
-export { GuardLevel, startListen };