@floating-live/bilibili 0.15.2 → 0.16.0

package/utils/fp2.d.ts

@@ -0,0 +1,7 @@
+export declare const x64Add: (m: any[], n: any[]) => number[];
+export declare const x64Multiply: (m: any[], n: number[]) => number[];
+export declare const x64Rotl: (m: any[], n: number) => any[];
+export declare const x64LeftShift: (m: any[], n: number) => any[];
+export declare const x64Xor: (m: any[], n: any[]) => number[];
+export declare const x64Fmix: (h: any[]) => any[];
+export declare const x64hash128: (key: string, seed: number) => string;

package/utils/fp2.js

@@ -0,0 +1,234 @@
+/// MurmurHash3 related functions
+//
+// Given two 64bit ints (as an array of two 32bit ints) returns the two
+// added together as a 64bit int (as an array of two 32bit ints).
+//
+export const x64Add = function (m, n) {
+    m = [m[0] >>> 16, m[0] & 0xffff, m[1] >>> 16, m[1] & 0xffff];
+    n = [n[0] >>> 16, n[0] & 0xffff, n[1] >>> 16, n[1] & 0xffff];
+    var o = [0, 0, 0, 0];
+    o[3] += m[3] + n[3];
+    o[2] += o[3] >>> 16;
+    o[3] &= 0xffff;
+    o[2] += m[2] + n[2];
+    o[1] += o[2] >>> 16;
+    o[2] &= 0xffff;
+    o[1] += m[1] + n[1];
+    o[0] += o[1] >>> 16;
+    o[1] &= 0xffff;
+    o[0] += m[0] + n[0];
+    o[0] &= 0xffff;
+    return [(o[0] << 16) | o[1], (o[2] << 16) | o[3]];
+};
+//
+// Given two 64bit ints (as an array of two 32bit ints) returns the two
+// multiplied together as a 64bit int (as an array of two 32bit ints).
+//
+export const x64Multiply = function (m, n) {
+    m = [m[0] >>> 16, m[0] & 0xffff, m[1] >>> 16, m[1] & 0xffff];
+    n = [n[0] >>> 16, n[0] & 0xffff, n[1] >>> 16, n[1] & 0xffff];
+    var o = [0, 0, 0, 0];
+    o[3] += m[3] * n[3];
+    o[2] += o[3] >>> 16;
+    o[3] &= 0xffff;
+    o[2] += m[2] * n[3];
+    o[1] += o[2] >>> 16;
+    o[2] &= 0xffff;
+    o[2] += m[3] * n[2];
+    o[1] += o[2] >>> 16;
+    o[2] &= 0xffff;
+    o[1] += m[1] * n[3];
+    o[0] += o[1] >>> 16;
+    o[1] &= 0xffff;
+    o[1] += m[2] * n[2];
+    o[0] += o[1] >>> 16;
+    o[1] &= 0xffff;
+    o[1] += m[3] * n[1];
+    o[0] += o[1] >>> 16;
+    o[1] &= 0xffff;
+    o[0] += m[0] * n[3] + m[1] * n[2] + m[2] * n[1] + m[3] * n[0];
+    o[0] &= 0xffff;
+    return [(o[0] << 16) | o[1], (o[2] << 16) | o[3]];
+};
+//
+// Given a 64bit int (as an array of two 32bit ints) and an int
+// representing a number of bit positions, returns the 64bit int (as an
+// array of two 32bit ints) rotated left by that number of positions.
+//
+export const x64Rotl = function (m, n) {
+    n %= 64;
+    if (n === 32) {
+        return [m[1], m[0]];
+    }
+    else if (n < 32) {
+        return [
+            (m[0] << n) | (m[1] >>> (32 - n)),
+            (m[1] << n) | (m[0] >>> (32 - n)),
+        ];
+    }
+    else {
+        n -= 32;
+        return [
+            (m[1] << n) | (m[0] >>> (32 - n)),
+            (m[0] << n) | (m[1] >>> (32 - n)),
+        ];
+    }
+};
+//
+// Given a 64bit int (as an array of two 32bit ints) and an int
+// representing a number of bit positions, returns the 64bit int (as an
+// array of two 32bit ints) shifted left by that number of positions.
+//
+export const x64LeftShift = function (m, n) {
+    n %= 64;
+    if (n === 0) {
+        return m;
+    }
+    else if (n < 32) {
+        return [(m[0] << n) | (m[1] >>> (32 - n)), m[1] << n];
+    }
+    else {
+        return [m[1] << (n - 32), 0];
+    }
+};
+//
+// Given two 64bit ints (as an array of two 32bit ints) returns the two
+// xored together as a 64bit int (as an array of two 32bit ints).
+//
+export const x64Xor = function (m, n) {
+    return [m[0] ^ n[0], m[1] ^ n[1]];
+};
+//
+// Given a block, returns murmurHash3's final x64 mix of that block.
+// (`[0, h[0] >>> 1]` is a 33 bit unsigned right shift. This is the
+// only place where we need to right shift 64bit ints.)
+//
+export const x64Fmix = function (h) {
+    h = x64Xor(h, [0, h[0] >>> 1]);
+    h = x64Multiply(h, [0xff51afd7, 0xed558ccd]);
+    h = x64Xor(h, [0, h[0] >>> 1]);
+    h = x64Multiply(h, [0xc4ceb9fe, 0x1a85ec53]);
+    h = x64Xor(h, [0, h[0] >>> 1]);
+    return h;
+};
+//
+// Given a string and an optional seed as an int, returns a 128 bit
+// hash using the x64 flavor of MurmurHash3, as an unsigned hex.
+//
+export const x64hash128 = function (key, seed) {
+    key = key || "";
+    seed = seed || 0;
+    var remainder = key.length % 16;
+    var bytes = key.length - remainder;
+    var h1 = [0, seed];
+    var h2 = [0, seed];
+    var k1 = [0, 0];
+    var k2 = [0, 0];
+    var c1 = [0x87c37b91, 0x114253d5];
+    var c2 = [0x4cf5ad43, 0x2745937f];
+    for (var i = 0; i < bytes; i = i + 16) {
+        k1 = [
+            (key.charCodeAt(i + 4) & 0xff) |
+                ((key.charCodeAt(i + 5) & 0xff) << 8) |
+                ((key.charCodeAt(i + 6) & 0xff) << 16) |
+                ((key.charCodeAt(i + 7) & 0xff) << 24),
+            (key.charCodeAt(i) & 0xff) |
+                ((key.charCodeAt(i + 1) & 0xff) << 8) |
+                ((key.charCodeAt(i + 2) & 0xff) << 16) |
+                ((key.charCodeAt(i + 3) & 0xff) << 24),
+        ];
+        k2 = [
+            (key.charCodeAt(i + 12) & 0xff) |
+                ((key.charCodeAt(i + 13) & 0xff) << 8) |
+                ((key.charCodeAt(i + 14) & 0xff) << 16) |
+                ((key.charCodeAt(i + 15) & 0xff) << 24),
+            (key.charCodeAt(i + 8) & 0xff) |
+                ((key.charCodeAt(i + 9) & 0xff) << 8) |
+                ((key.charCodeAt(i + 10) & 0xff) << 16) |
+                ((key.charCodeAt(i + 11) & 0xff) << 24),
+        ];
+        k1 = x64Multiply(k1, c1);
+        k1 = x64Rotl(k1, 31);
+        k1 = x64Multiply(k1, c2);
+        h1 = x64Xor(h1, k1);
+        h1 = x64Rotl(h1, 27);
+        h1 = x64Add(h1, h2);
+        h1 = x64Add(x64Multiply(h1, [0, 5]), [0, 0x52dce729]);
+        k2 = x64Multiply(k2, c2);
+        k2 = x64Rotl(k2, 33);
+        k2 = x64Multiply(k2, c1);
+        h2 = x64Xor(h2, k2);
+        h2 = x64Rotl(h2, 31);
+        h2 = x64Add(h2, h1);
+        h2 = x64Add(x64Multiply(h2, [0, 5]), [0, 0x38495ab5]);
+    }
+    k1 = [0, 0];
+    k2 = [0, 0];
+    switch (remainder) {
+        case 15:
+            k2 = x64Xor(k2, x64LeftShift([0, key.charCodeAt(i + 14)], 48));
+        // fallthrough
+        case 14:
+            k2 = x64Xor(k2, x64LeftShift([0, key.charCodeAt(i + 13)], 40));
+        // fallthrough
+        case 13:
+            k2 = x64Xor(k2, x64LeftShift([0, key.charCodeAt(i + 12)], 32));
+        // fallthrough
+        case 12:
+            k2 = x64Xor(k2, x64LeftShift([0, key.charCodeAt(i + 11)], 24));
+        // fallthrough
+        case 11:
+            k2 = x64Xor(k2, x64LeftShift([0, key.charCodeAt(i + 10)], 16));
+        // fallthrough
+        case 10:
+            k2 = x64Xor(k2, x64LeftShift([0, key.charCodeAt(i + 9)], 8));
+        // fallthrough
+        case 9:
+            k2 = x64Xor(k2, [0, key.charCodeAt(i + 8)]);
+            k2 = x64Multiply(k2, c2);
+            k2 = x64Rotl(k2, 33);
+            k2 = x64Multiply(k2, c1);
+            h2 = x64Xor(h2, k2);
+        // fallthrough
+        case 8:
+            k1 = x64Xor(k1, x64LeftShift([0, key.charCodeAt(i + 7)], 56));
+        // fallthrough
+        case 7:
+            k1 = x64Xor(k1, x64LeftShift([0, key.charCodeAt(i + 6)], 48));
+        // fallthrough
+        case 6:
+            k1 = x64Xor(k1, x64LeftShift([0, key.charCodeAt(i + 5)], 40));
+        // fallthrough
+        case 5:
+            k1 = x64Xor(k1, x64LeftShift([0, key.charCodeAt(i + 4)], 32));
+        // fallthrough
+        case 4:
+            k1 = x64Xor(k1, x64LeftShift([0, key.charCodeAt(i + 3)], 24));
+        // fallthrough
+        case 3:
+            k1 = x64Xor(k1, x64LeftShift([0, key.charCodeAt(i + 2)], 16));
+        // fallthrough
+        case 2:
+            k1 = x64Xor(k1, x64LeftShift([0, key.charCodeAt(i + 1)], 8));
+        // fallthrough
+        case 1:
+            k1 = x64Xor(k1, [0, key.charCodeAt(i)]);
+            k1 = x64Multiply(k1, c1);
+            k1 = x64Rotl(k1, 31);
+            k1 = x64Multiply(k1, c2);
+            h1 = x64Xor(h1, k1);
+        // fallthrough
+    }
+    h1 = x64Xor(h1, [0, key.length]);
+    h2 = x64Xor(h2, [0, key.length]);
+    h1 = x64Add(h1, h2);
+    h2 = x64Add(h2, h1);
+    h1 = x64Fmix(h1);
+    h2 = x64Fmix(h2);
+    h1 = x64Add(h1, h2);
+    h2 = x64Add(h2, h1);
+    return (("00000000" + (h1[0] >>> 0).toString(16)).slice(-8) +
+        ("00000000" + (h1[1] >>> 0).toString(16)).slice(-8) +
+        ("00000000" + (h2[0] >>> 0).toString(16)).slice(-8) +
+        ("00000000" + (h2[1] >>> 0).toString(16)).slice(-8));
+};

package/utils/index.d.ts

@@ -0,0 +1 @@
+export * from "./request";

package/utils/index.js

@@ -0,0 +1 @@
+export * from "./request";

package/utils/lsid.d.ts

@@ -0,0 +1 @@
+export declare function generateLsid(): string;

package/utils/lsid.js

@@ -0,0 +1,15 @@
+// 模拟Rust的random_string!宏
+function randomString(len, charset) {
+    const chars = charset.split("");
+    const charsetLength = chars.length;
+    return Array.from({ length: len }, () => chars[Math.floor(Math.random() * charsetLength)]).join("");
+}
+// 主函数
+export function generateLsid() {
+    const randomPart = randomString(8, "0123456789ABCDEF" // 保持全大写十六进制特征
+    );
+    const timestampPart = Date.now()
+        .toString(16) // 转换为十六进制
+        .toUpperCase(); // 保持与Rust的:X格式一致
+    return `${randomPart}_${timestampPart}`;
+}

package/utils/randomImage.d.ts

@@ -0,0 +1,2 @@
+/** 生成随机的base64图片数据 */
+export declare function generateRandomPngBase64(): string;

package/utils/randomImage.js

@@ -0,0 +1,107 @@
+// Generated by Deepseek
+/** 生成随机的base64图片数据 */
+export function generateRandomPngBase64() {
+    // 生成带过滤头的随机像素数据
+    const pixelData = new Uint8Array(20 * (20 * 4 + 1));
+    for (let y = 0, offset = 0; y < 20; y++) {
+        pixelData[offset++] = 0; // 过滤类型
+        for (let x = 0; x < 20; x++) {
+            pixelData[offset++] = Math.floor(Math.random() * 256); // R
+            pixelData[offset++] = Math.floor(Math.random() * 256); // G
+            pixelData[offset++] = Math.floor(Math.random() * 256); // B
+            pixelData[offset++] = 255; // A
+        }
+    }
+    // 计算Adler32校验和
+    const computeAdler32 = (data) => {
+        let s1 = 1, s2 = 0;
+        for (const byte of data) {
+            s1 = (s1 + byte) % 65521;
+            s2 = (s2 + s1) % 65521;
+        }
+        return (s2 << 16) | s1;
+    };
+    // 构造Deflate流
+    const deflateStream = new Uint8Array([
+        0x78,
+        0x01, // Zlib头
+        0x00, // BFINAL=0，BTYPE=00（非最后块）
+        0x54,
+        0x06, // LEN=1620
+        0xab,
+        0xf9, // NLEN=~1620
+        ...pixelData,
+        ...new Uint8Array([
+            // Adler32
+            (computeAdler32(pixelData) >> 24) & 0xff,
+            (computeAdler32(pixelData) >> 16) & 0xff,
+            (computeAdler32(pixelData) >> 8) & 0xff,
+            computeAdler32(pixelData) & 0xff,
+        ]),
+    ]);
+    // 计算CRC32
+    const computeCRC32 = (data) => {
+        let crc = 0xffffffff;
+        const table = new Uint32Array(256);
+        for (let i = 0; i < 256; i++) {
+            let c = i;
+            for (let j = 0; j < 8; j++) {
+                c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+            }
+            table[i] = c;
+        }
+        for (const byte of data) {
+            crc = table[(crc ^ byte) & 0xff] ^ (crc >>> 8);
+        }
+        return crc ^ 0xffffffff;
+    };
+    // 创建PNG块
+    const createChunk = (type, data) => {
+        const typeBytes = new TextEncoder().encode(type);
+        const length = new Uint8Array(4);
+        length[0] = (data.length >> 24) & 0xff;
+        length[1] = (data.length >> 16) & 0xff;
+        length[2] = (data.length >> 8) & 0xff;
+        length[3] = data.length & 0xff;
+        const chunkData = new Uint8Array([...typeBytes, ...data]);
+        const crc = computeCRC32(chunkData);
+        const crcBytes = new Uint8Array(4);
+        crcBytes[0] = (crc >> 24) & 0xff;
+        crcBytes[1] = (crc >> 16) & 0xff;
+        crcBytes[2] = (crc >> 8) & 0xff;
+        crcBytes[3] = crc & 0xff;
+        return new Uint8Array([...length, ...chunkData, ...crcBytes]);
+    };
+    // 构建PNG结构
+    const signature = new Uint8Array([
+        0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
+    ]);
+    const ihdrData = new Uint8Array([
+        0x00,
+        0x00,
+        0x00,
+        0x14, // 宽度20
+        0x00,
+        0x00,
+        0x00,
+        0x14, // 高度20
+        0x08, // 位深度
+        0x06, // 颜色类型（RGBA）
+        0x00, // 压缩方法
+        0x00, // 滤波方法
+        0x00, // 隔行扫描
+    ]);
+    const ihdrChunk = createChunk("IHDR", ihdrData);
+    const idatChunk = createChunk("IDAT", deflateStream);
+    const iendChunk = createChunk("IEND", new Uint8Array(0));
+    // 合并所有数据
+    const pngData = new Uint8Array([
+        ...signature,
+        ...ihdrChunk,
+        ...idatChunk,
+        ...iendChunk,
+    ]);
+    // 转换为Base64
+    const base64 = btoa(String.fromCharCode(...pngData));
+    return `data:image/png;base64,${base64}`;
+}

package/utils/request.d.ts

@@ -0,0 +1,32 @@
+import { FpInfo } from "./fingerprint";
+import { RoomBaseInfo } from "../types";
+export declare function getCookie(headers: Headers): string;
+export declare function parseCookieString(str: string): Record<string, string>;
+/** 生成登录二维码 */
+export declare function qrcodeGenerate(options?: FetchOptions): Promise<{
+    url: any;
+    key: any;
+}>;
+/** 生成登录二维码 */
+export declare function requestFingerSpi(options?: FetchOptions): Promise<Record<"b_3" | "b_4", string>>;
+/** 检测登录二维码 */
+export declare function checkLoginQRcode(key: string, options?: FetchOptions): Promise<[number, string?]>;
+/** 获取并激活buvid的cookie */
+export declare function getActivatedBuvidCookie(fp: FpInfo | null | undefined, options: FetchOptions): Promise<Record<"buvid3" | "_uuid" | "buvid_fp" | "b_lsid", string>>;
+/** 获取指纹相关Cookies */
+export declare function getFingerprintCookie(fp: FpInfo, options: FetchOptions): {
+    _uuid: string;
+    buvid_fp: string;
+    b_lsid: string;
+};
+/** 激活buvid */
+export declare function requestExClimbWuzhi(payload: string, options: FetchOptions): void;
+export declare function getRoomBaseInfo(room_id: number, options?: FetchOptions): Promise<RoomBaseInfo | undefined>;
+export interface FetchOptions {
+    /** 自定义fetch函数(适用于请求中转等情况) */
+    fetch?: (input: string, init?: RequestInit) => Promise<Response>;
+    /** 用户代理字段 */
+    userAgent?: string;
+    /** cookie字段 */
+    cookie?: string;
+}

package/utils/request.js

@@ -0,0 +1,181 @@
+import { Cookies, customFetch, requestBuvidCookie, } from "bilibili-live-danmaku";
+import { fpGet, generateFakeFpInfo, getExClimbWuzhiPayload, } from "./fingerprint";
+import { generateRandomPngBase64 } from "./randomImage";
+import { x64hash128 } from "./fp2";
+import { generateUuid } from "./uuid";
+import { generateLsid } from "./lsid";
+export function getCookie(headers) {
+    const cookies = [];
+    headers.forEach((val, key) => {
+        if (key == "set-cookie") {
+            const [c] = val.split(";");
+            cookies.push(c);
+        }
+    });
+    const cookie = cookies.join("; ");
+    return cookie;
+}
+export function parseCookieString(str) {
+    const cookie = {};
+    str.split(";").forEach((item) => {
+        if (!item) {
+            return;
+        }
+        const arr = item.split("=");
+        const key = arr[0]?.trim();
+        const val = arr[1]?.trim();
+        cookie[key] = val;
+    });
+    return cookie;
+}
+/** 生成登录二维码 */
+export async function qrcodeGenerate(options) {
+    const res = await customFetch(options, "https://passport.bilibili.com/x/passport-login/web/qrcode/generate").then((res) => res.json());
+    return {
+        url: res.data.url,
+        key: res.data.qrcode_key,
+    };
+}
+/** 生成登录二维码 */
+export async function requestFingerSpi(options) {
+    const res = await customFetch(options, "https://api.bilibili.com/x/frontend/finger/spi").then((res) => res.json());
+    return res.data;
+}
+/** 检测登录二维码 */
+export async function checkLoginQRcode(key, options) {
+    const res = await customFetch(options, `https://passport.bilibili.com/x/passport-login/web/qrcode/poll?qrcode_key=${key}`);
+    const { code, message } = (await res.json()).data;
+    if (code == 86101) {
+        // 未扫码
+        return [1];
+    }
+    else if (code == 86090) {
+        // 等待确认
+        return [2];
+    }
+    else if (code == 0) {
+        const cookie = getCookie(res.headers);
+        return [0, cookie];
+    }
+    else if (code == 86038) {
+        // 二维码失效
+        return [-1];
+    }
+    else {
+        // 其他错误
+        console.log(`${code} ${message}`);
+        throw message;
+    }
+}
+function wait(t) {
+    return new Promise((res, rej) => {
+        const to = setTimeout(() => {
+            res(undefined);
+            clearTimeout(t);
+        }, t);
+    });
+}
+/** 获取并激活buvid的cookie */
+export async function getActivatedBuvidCookie(fp, options) {
+    const cookies = new Cookies();
+    cookies.append(await requestBuvidCookie({
+        ...options,
+        cookie: cookies.toString(),
+    }));
+    const { b_4 } = await requestFingerSpi({
+        ...options,
+        cookie: cookies.toString(),
+    });
+    cookies.set("buvid4", b_4);
+    if (!fp) {
+        fp = generateFakeFpInfo({
+            canvas: generateRandomPngBase64(),
+            webgl: generateRandomPngBase64(),
+            userAgent: options.userAgent ||
+                "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/135.0.0.0 Safari/537.36 Edg/135.0.0.0",
+            platform: "Win32",
+        });
+    }
+    cookies.append(getFingerprintCookie(fp, {
+        ...options,
+        cookie: cookies.toString(),
+    }));
+    // await wait(2000);
+    const payload = getExClimbWuzhiPayload(fp, {
+        uuid: cookies.get("_uuid"),
+        timestamp: Date.now().toString(),
+        browser_resolution: fpGet(fp, "availableScreenResolution").join("x"),
+        abtest: `{"b_ut":null,"home_version":"V8","in_new_ab":true,"ab_version":{"for_ai_home_version":"V8","enable_web_push":"DISABLE","ad_style_version":"NEW","enable_feed_channel":"ENABLE","enable_ai_floor_api":"DISABLE"},"ab_split_num":{"for_ai_home_version":54,"enable_web_push":10,"ad_style_version":54,"enable_feed_channel":54,"enable_ai_floor_api":137},"uniq_page_id":"${Math.floor(Math.random() * 2000000000000)}","is_modern":true}`,
+    });
+    requestExClimbWuzhi(JSON.stringify(payload), {
+        ...options,
+        cookie: cookies.toString(),
+    });
+    const cookieRecord = {};
+    cookies.forEach((val, k) => {
+        cookieRecord[k] = val;
+    });
+    return cookieRecord;
+}
+/** 获取指纹相关Cookies */
+export function getFingerprintCookie(fp, options) {
+    const cookies = new Cookies(options.cookie);
+    let _uuid = cookies.get("_uuid");
+    let buvid_fp = cookies.get("buvid_fp");
+    let b_lsid = cookies.get("b_lsid");
+    if (!_uuid) {
+        _uuid = generateUuid();
+        cookies.set("_uuid", _uuid);
+    }
+    if (!buvid_fp) {
+        const fpString = fp
+            .map((e) => {
+            return e.value;
+        })
+            .join("");
+        buvid_fp = x64hash128(fpString, 31);
+        cookies.set("buvid_fp", buvid_fp);
+    }
+    if (!b_lsid) {
+        b_lsid = generateLsid();
+        cookies.set("b_lsid", b_lsid);
+    }
+    return {
+        _uuid,
+        buvid_fp,
+        b_lsid,
+    };
+}
+/** 激活buvid */
+export function requestExClimbWuzhi(payload, options) {
+    customFetch(options, "https://api.bilibili.com/x/internal/gaia-gateway/ExClimbWuzhi", {
+        method: "POST",
+        body: payload,
+        credentials: "include",
+        headers: {
+            Accept: "*/*",
+            "Accept-Encoding": "gzip, deflate, br, zstd",
+            "Accept-Language": "zh-CN,zh;q=0.9",
+            "Content-Type": "application/json;charset=UTF-8",
+            Origin: "https://www.bilibili.com",
+            priority: "u=1, i",
+            Referer: "https://www.bilibili.com/",
+            "Sec-Ch-Ua": `"Microsoft Edge";v="135", "Not-A.Brand";v="8", "Chromium";v="135"`,
+            "Sec-Ch-Mobile": "?0",
+            "Sec-Ch-Platform": `"Windows"`,
+            "Sec-Ch-Dest": "empty",
+            "Sec-Ch-Mode": "cors",
+            "Sec-Fetch-Site": "same-site",
+        },
+    }).then((res) => res.json());
+}
+export function getRoomBaseInfo(room_id, options) {
+    return customFetch(options, `https://api.live.bilibili.com/xlive/web-room/v1/index/getRoomBaseInfo?room_ids=${room_id}&req_biz=video`)
+        .then((res) => res.json())
+        .then((data) => data.data)
+        .then((data) => {
+        for (const k in data.by_room_ids) {
+            return data.by_room_ids[k];
+        }
+    });
+}

package/utils/uuid.d.ts

@@ -0,0 +1 @@
+export declare function generateUuid(): string;

package/utils/uuid.js

@@ -0,0 +1,45 @@
+// Refactored by Deepseek
+// from `https://github.com/SocialSisterYi/bilibili-API-collect/issues/933#issue-2073916390`
+// Copyright (c) 2024 Hantong Chen(cxw620). MIT license.
+// RE from `https://s1.hdslb.com/bfs/seed/log/report/log-reporter.js`
+// 工具函数代替Rust宏
+const DIGIT_MAP = [
+    "1",
+    "2",
+    "3",
+    "4",
+    "5",
+    "6",
+    "7",
+    "8",
+    "9",
+    "A",
+    "B",
+    "C",
+    "D",
+    "E",
+    "F",
+    "10", // 保持原始数据不变
+];
+// 代替random_choice!宏
+function randomChoice(...args) {
+    // 参数解析
+    const hasSeparator = typeof args[args.length - 2] === "string";
+    const [choiceSet, separator, lengths] = hasSeparator
+        ? [args.pop(), args.pop(), args]
+        : [args.pop(), undefined, args];
+    // 生成随机段
+    const segments = lengths.map((length) => Array.from({ length }, () => choiceSet[Math.floor(Math.random() * choiceSet.length)]).join(""));
+    return separator ? segments.join(separator) : segments.join("");
+}
+// 代替now!宏
+function getTimestamp() {
+    return Date.now() % 100000;
+}
+// 代替UuidInfoc结构体
+export function generateUuid() {
+    const t = getTimestamp().toString().padStart(5, "0");
+    // 生成符合原始格式的各个部分
+    const parts = [randomChoice(8, 4, 4, 4, 12, "-", DIGIT_MAP), t, "infoc"];
+    return parts.join("");
+}

package/index.ts

@@ -1,5 +0,0 @@
-export * from "./plugin";
-export * from "./room";
-export * from "./parser";
-export * from "./types";
-export * from "./utils";