koishi-plugin-bilibili-videolink-analysis 1.2.0 → 1.3.0

package/src/index.ts

@@ -1,5 +1,6 @@
 import { Schema, Logger, h, Context, Session } from "koishi";
 import { } from "koishi-plugin-puppeteer";
+import { BilibiliParser } from "./utils";
 
 const logger = new Logger('bilibili-videolink-analysis');
 
@@ -57,9 +58,9 @@ export interface Config {
   point?: [number, number];
   enable?: boolean;
   enablebilianalysis: boolean;
+  videoParseMode: string[];
   waitTip_Switch?: string | null;
-  linktextParsing: boolean;
-  VideoParsing_ToLink: '1' | '2' | '3' | '4' | '5';
+  videoParseComponents: string[];
   BVnumberParsing: boolean;
   MinimumTimeInterval: number;
   Minimumduration: number;
@@ -103,76 +104,70 @@ export const Config = Schema.intersect([
   }).description('视频解析 - 功能开关'),
   Schema.union([
     Schema.object({
-      enablebilianalysis: Schema.const(false).required(),
-    }),
-    Schema.intersect([
-      Schema.object({
-        enablebilianalysis: Schema.const(true),
-        // @ts-ignore // 摸了摸了
-        waitTip_Switch: Schema.union([
-          Schema.const(null).description('不返回文字提示'),
-          Schema.string().description('返回文字提示（请在右侧填写文字内容）').default('正在解析B站链接...'),
-        ]).description("是否返回等待提示。开启后，会发送`等待提示语`"),
-        linktextParsing: Schema.boolean().default(true).description("是否返回 视频图文数据 `开启后，才发送视频数据的图文解析。`"),
-        VideoParsing_ToLink: Schema.union([
-          Schema.const('1').description('不返回视频/视频直链'),
-          Schema.const('2').description('仅返回视频'),
-          Schema.const('3').description('仅返回视频直链'),
-          Schema.const('4').description('返回视频和视频直链'),
-          Schema.const('5').description('返回视频，仅在日志记录视频直链'),
-        ]).role('radio').default('2').description("是否返回` 视频/视频直链 `"),
-        BVnumberParsing: Schema.boolean().default(true).description("是否允许根据`独立的BV、AV号`解析视频 `开启后，可以通过视频的BV、AV号解析视频。` <br>  [触发说明见README](https://www.npmjs.com/package/koishi-plugin-bilibili-videolink-analysis)"),
-        MinimumTimeInterval: Schema.number().default(180).description("若干`秒`内 不再处理相同链接 `防止多bot互相触发 导致的刷屏/性能浪费`").min(1),
-      }),
-
-      Schema.object({
-        enablebilianalysis: Schema.const(true),
-        Minimumduration: Schema.number().default(0).description("允许解析的视频最小时长（分钟）`低于这个时长 就不会发视频内容`").min(0),
-        Minimumduration_tip: Schema.union([
-          Schema.const('return').description('不返回文字提示'),
-          Schema.object({
-            tipcontent: Schema.string().default('视频太短啦！不看不看~').description("文字提示内容"),
-            tipanalysis: Schema.boolean().default(true).description("是否进行图文解析（不会返回视频链接）"),
-          }).description('返回文字提示'),
-          Schema.const(null),
-        ]).description("对`过短视频`的文字提示内容").default(null),
-        Maximumduration: Schema.number().default(25).description("允许解析的视频最大时长（分钟）`超过这个时长 就不会发视频内容`").min(1),
-        Maximumduration_tip: Schema.union([
-          Schema.const('return').description('不返回文字提示'),
-          Schema.object({
-            tipcontent: Schema.string().default('视频太长啦！内容还是去B站看吧~').description("文字提示内容"),
-            tipanalysis: Schema.boolean().default(true).description("是否进行图文解析（不会返回视频链接）"),
-          }).description('返回文字提示'),
-          Schema.const(null),
-        ]).description("对`过长视频`的文字提示内容").default(null),
-      }).description("视频解析 - 内容限制"),
-
-      Schema.object({
-        parseLimit: Schema.number().default(3).description("单对话多链接解析上限").hidden(),
-        useNumeral: Schema.boolean().default(true).description("使用格式化数字").hidden(),
-        showError: Schema.boolean().default(false).description("当链接不正确时提醒发送者").hidden(),
-        bVideoIDPreference: Schema.union([
-          Schema.const("bv").description("BV 号"),
-          Schema.const("av").description("AV 号"),
-        ]).default("bv").description("ID 偏好").hidden(),
-
-        bVideo_area: Schema.string().role('textarea', { rows: [8, 16] })
-          .default("${标题} --- ${UP主}\n${简介}\n点赞：${点赞} --- 投币：${投币}\n收藏：${收藏} --- 转发：${转发}\n观看：${观看} --- 弹幕：${弹幕}\n${~~~}\n${封面}")
-          .description(`图文解析的返回格式<br>
+      enablebilianalysis: Schema.const(true),
+      waitTip_Switch: Schema.union([
+        Schema.const(null).description('不返回文字提示'),
+        Schema.string().description('返回文字提示（请在右侧填写文字内容）').default('正在解析B站链接...'),
+      ]).description("是否返回等待提示。开启后，会发送`等待提示语`"),
+      videoParseMode: Schema.array(Schema.union([
+        Schema.const('link').description('解析链接'),
+        Schema.const('card').description('解析哔哩哔哩分享卡片'),
+      ]))
+        .default(['link', 'card'])
+        .role('checkbox')
+        .description('选择解析来源'),
+      videoParseComponents: Schema.array(Schema.union([
+        Schema.const('log').description('记录日志'),
+        Schema.const('text').description('返回图文'),
+        Schema.const('link').description('返回视频直链'),
+        Schema.const('video').description('返回视频'),
+      ]))
+        .default(['text', 'video'])
+        .role('checkbox')
+        .description('选择要返回的内容组件'),
+      BVnumberParsing: Schema.boolean().default(true).description("是否允许根据`独立的BV、AV号`解析视频 `开启后，可以通过视频的BV、AV号解析视频。` <br>  [触发说明见README](https://www.npmjs.com/package/koishi-plugin-bilibili-videolink-analysis)"),
+      MinimumTimeInterval: Schema.number().default(180).description("若干`秒`内 不再处理相同链接 `防止多bot互相触发 导致的刷屏/性能浪费`").min(1),
+      Minimumduration: Schema.number().default(0).description("允许解析的视频最小时长（分钟）`低于这个时长 就不会发视频内容`").min(0),
+      Minimumduration_tip: Schema.union([
+        Schema.const('return').description('不返回文字提示'),
+        Schema.object({
+          tipcontent: Schema.string().default('视频太短啦！不看不看~').description("文字提示内容"),
+          tipanalysis: Schema.boolean().default(true).description("是否进行图文解析（不会返回视频链接）"),
+        }).description('返回文字提示'),
+        Schema.const(null),
+      ]).description("对`过短视频`的文字提示内容").default(null),
+      Maximumduration: Schema.number().default(25).description("允许解析的视频最大时长（分钟）`超过这个时长 就不会发视频内容`").min(1),
+      Maximumduration_tip: Schema.union([
+        Schema.const('return').description('不返回文字提示'),
+        Schema.object({
+          tipcontent: Schema.string().default('视频太长啦！内容还是去B站看吧~').description("文字提示内容"),
+          tipanalysis: Schema.boolean().default(true).description("是否进行图文解析（不会返回视频链接）"),
+        }).description('返回文字提示'),
+        Schema.const(null),
+      ]).description("对`过长视频`的文字提示内容").default(null),
+      parseLimit: Schema.number().default(3).description("单对话多链接解析上限").hidden(),
+      useNumeral: Schema.boolean().default(true).description("使用格式化数字").hidden(),
+      showError: Schema.boolean().default(false).description("当链接不正确时提醒发送者").hidden(),
+      bVideoIDPreference: Schema.union([
+        Schema.const("bv").description("BV 号"),
+        Schema.const("av").description("AV 号"),
+      ]).default("bv").description("ID 偏好").hidden(),
+      bVideo_area: Schema.string().role('textarea', { rows: [8, 16] })
+        .default("${标题} ${tab} ${UP主}\n${简介}\n点赞：${点赞} ${tab} 投币：${投币}\n收藏：${收藏} ${tab} 转发：${转发}\n观看：${观看} ${tab} 弹幕：${弹幕}\n${~~~}\n${封面}")
+        .description(`图文解析的返回格式<br>
 注意变量格式，以及变量名称。<br>比如 \`\${标题}\` 不可以变成\`\${标题123}\`，你可以直接删掉但是不能修改变量名称哦<br>
 当然变量也不能无中生有，下面的默认值内容 就是所有变量了，你仅可以删去变量 或者修改变量之外的格式。<br>
 · 特殊变量\`\${~~~}\`表示分割线，会把上下内容分为两个信息单独发送。\`\${tab}\`表示制表符。`),
-        bVideoShowLink: Schema.boolean().default(false).description("在末尾显示视频的链接地址 `开启可能会导致其他bot循环解析`"),
-        bVideoShowIntroductionTofixed: Schema.number().default(50).description("视频的`简介`最大的字符长度<br>超出部分会使用 `...` 代替"),
-      }).description("链接的图文解析设置"),
-
-      Schema.object({
-        isfigure: Schema.boolean().default(false).description("是否开启合并转发 `仅支持 onebot 适配器` 其他平台开启 无效").experimental(),
-        filebuffer: Schema.boolean().default(true).description("是否将视频链接下载后再发送 （以解决部分onebot协议端的问题）<br>否则使用视频直链发送").experimental(),
-        middleware: Schema.boolean().default(false).description("前置中间件模式"),
-        userAgent: Schema.string().description("所有 API 请求所用的 User-Agent").default("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36"),
-      }).description("调试设置"),
-    ]),
+      bVideoShowLink: Schema.boolean().default(false).description("在末尾显示视频的链接地址 `开启可能会导致其他bot循环解析`"),
+      bVideoShowIntroductionTofixed: Schema.number().default(50).description("视频的`简介`最大的字符长度<br>超出部分会使用 `...` 代替"),
+      isfigure: Schema.boolean().default(true).description("是否开启合并转发 `仅支持 onebot 适配器` 其他平台开启 无效").experimental(),
+      filebuffer: Schema.boolean().default(true).description("是否将视频链接下载后再发送 （以解决部分onebot协议端的问题）<br>否则使用视频直链发送").experimental(),
+      middleware: Schema.boolean().default(false).description("前置中间件模式"),
+      userAgent: Schema.string().description("所有 API 请求所用的 User-Agent").default("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36"),
+    }),
+    Schema.object({
+      enablebilianalysis: Schema.const(false).required(),
+    }),
   ]),
 
   Schema.object({
@@ -183,24 +178,43 @@ export const Config = Schema.intersect([
 ]);
 
 export function apply(ctx: Context, config: Config) {
-
-  // 记录上次处理链接的时间
-  const lastProcessedUrls: Record<string, number> = {};
+  const bilibiliParser = new BilibiliParser(ctx, config, logger);
 
   if (config.enablebilianalysis) {
     ctx.middleware(async (session, next) => {
+      // 尝试解析JSON卡片
+      let isCard = false;
+      try {
+        if (session.stripped.content.startsWith('<json data=')) {
+          isCard = true;
+        }
+      } catch (e) {
+        // Not a valid JSON card
+      }
+
+      if (isCard) {
+        if (!config.videoParseMode.includes('card')) {
+          return next();
+        }
+      } else {
+        if (!config.videoParseMode.includes('link')) {
+          return next();
+        }
+      }
+
       let sessioncontent = session.stripped.content;
+      ctx.logger.info(sessioncontent)
       if (config.BVnumberParsing) {
-        const bvUrls = convertBVToUrl(sessioncontent);
+        const bvUrls = bilibiliParser.convertBVToUrl(sessioncontent);
         if (bvUrls.length > 0) {
           sessioncontent += '\n' + bvUrls.join('\n');
         }
       }
-      const links = await isProcessLinks(sessioncontent); // 判断是否需要解析
+      const links = await bilibiliParser.isProcessLinks(sessioncontent); // 判断是否需要解析
       if (links) {
-        const ret = await extractLinks(session, links); // 提取链接
-        if (ret && !isLinkProcessedRecently(ret, session.channelId)) {
-          await processVideoFromLink(session, ret); // 解析视频并返回
+        const ret = await bilibiliParser.extractLinks(session, links); // 提取链接
+        if (ret && !bilibiliParser.isLinkProcessedRecently(ret, session.channelId)) {
+          await bilibiliParser.processVideoFromLink(session, ret); // 解析视频并返回
         }
       }
       return next();
@@ -275,10 +289,10 @@ display: none !important;
           }).filter(video => video.id)
         }, config.point) // 传递配置的 point 参数
 
-        logInfo(options)
-        logInfo(`共找到 ${videos.length} 个视频:`)
+        bilibiliParser.logInfo(options)
+        bilibiliParser.logInfo(`共找到 ${videos.length} 个视频:`)
         videos.forEach((video: any, index: number) => {
-          logInfo(`序号 ${index + 1}: ID - ${video.id}`)
+          bilibiliParser.logInfo(`序号 ${index + 1}: ID - ${video.id}`)
         })
 
 
@@ -294,11 +308,11 @@ display: none !important;
           width: 1440,
           height: viewportHeight
         })
-        logInfo("窗口：宽度：")
-        logInfo(1440)
+        bilibiliParser.logInfo("窗口：宽度：")
+        bilibiliParser.logInfo(1440)
 
-        logInfo("窗口：高度：")
-        logInfo(viewportHeight)
+        bilibiliParser.logInfo("窗口：高度：")
+        bilibiliParser.logInfo(viewportHeight)
         let msg: any;
 
         // 截图
@@ -326,556 +340,16 @@ display: none !important;
         // 返回用户选择的视频ID
         const chosenVideo = videos[choiceIndex]
 
-        logInfo(`渲染序号设置\noverlay.style.top = ${config.point[0]}% \noverlay.style.left = ${config.point[1]}%`)
-        logInfo(`用户选择了序号 ${choiceIndex + 1}: ID - ${chosenVideo.id}`)
+        bilibiliParser.logInfo(`渲染序号设置\noverlay.style.top = ${config.point[0]}% \noverlay.style.left = ${config.point[1]}%`)
+        bilibiliParser.logInfo(`用户选择了序号 ${choiceIndex + 1}: ID - ${chosenVideo.id}`)
 
         // 开启自动解析了
         if (config.enable) {
-          const ret = await extractLinks(session, [{ type: 'Video', id: chosenVideo.id }]); // 提取链接
-          if (ret && !isLinkProcessedRecently(ret, session.channelId)) {
-            await processVideoFromLink(session, ret, options); // 解析视频并返回
+          const ret = await bilibiliParser.extractLinks(session, [{ type: 'Video', id: chosenVideo.id }]); // 提取链接
+          if (ret && !bilibiliParser.isLinkProcessedRecently(ret, session.channelId)) {
+            await bilibiliParser.processVideoFromLink(session, ret, options); // 解析视频并返回
           }
         }
       })
   }
-
-  function logInfo(...args: any[]) {
-    if (config.loggerinfo) {
-      (logger.info as (...args: any[]) => void)(...args);
-    }
-  }
-
-  //  判断是否需要解析
-  async function isProcessLinks(sessioncontent: string) {
-    // 解析内容中的链接
-    const links = link_type_parser(sessioncontent);
-    if (links.length === 0) {
-      return false; // 如果没有找到链接，返回 false
-    }
-    return links; // 返回解析出的链接
-  }
-
-  //提取链接 
-  async function extractLinks(session: Session, links: { type: string; id: string }[]) {
-    let ret = "";
-    if (!config.isfigure) {
-      ret += h("quote", { id: session.messageId });
-    }
-    let countLink = 0;
-    let tp_ret: string;
-
-    // 循环检测链接类型
-    for (const element of links) {
-      if (countLink >= 1) ret += "\n";
-      if (countLink >= config.parseLimit) {
-        ret += "已达到解析上限…";
-        break;
-      }
-      tp_ret = await type_processer(element);
-      if (tp_ret == "") {
-        if (config.showError)
-          ret = "无法解析链接信息。可能是 ID 不存在，或该类型可能暂不支持。";
-        else
-          ret = null;
-      } else {
-        ret += tp_ret;
-      }
-      countLink++;
-    }
-    return ret;
-  }
-
-  //判断链接是否已经处理过
-  function isLinkProcessedRecently(ret: string, channelId: string) {
-    const lastretUrl = extractLastUrl(ret); // 提取 ret 最后一个 http 链接作为解析目标
-    const currentTime = Date.now();
-
-    //  channelId 作为 key 的一部分，分频道鉴别
-    const channelKey = `${channelId}:${lastretUrl}`;
-
-    if (lastretUrl && lastProcessedUrls[channelKey] && (currentTime - lastProcessedUrls[channelKey] < config.MinimumTimeInterval * 1000)) {
-      ctx.logger.info(`重复出现，略过处理：\n ${lastretUrl} (频道 ${channelId})`);
-
-      return true; // 已经处理过
-    }
-
-    // 更新该链接的最后处理时间，使用 channelKey
-    if (lastretUrl) {
-      lastProcessedUrls[channelKey] = currentTime;
-    }
-    return false; // 没有处理过
-  }
-
-  async function processVideoFromLink(session: Session, ret: string, options: { video?: boolean; audio?: boolean; link?: boolean } = { video: true }) {
-    const lastretUrl = extractLastUrl(ret);
-
-    let waitTipMsgId: string = null;
-    // 等待提示语单独发送
-    if (config.waitTip_Switch) {
-      const result = await session.send(`${h.quote(session.messageId)}${config.waitTip_Switch}`);
-      waitTipMsgId = Array.isArray(result) ? result[0] : result;
-    }
-
-    let videoElements: any[] = []; // 用于存储视频相关元素
-    let textElements: any[] = []; // 用于存储图文解析元素
-    let shouldPerformTextParsing = config.linktextParsing;
-
-    // 先进行图文解析
-    if (shouldPerformTextParsing) {
-      let fullText: string;
-      if (config.bVideoShowLink) {
-        fullText = ret; // 发送完整信息
-      } else {
-        // 去掉最后一个链接
-        fullText = ret.replace(lastretUrl, '');
-      }
-
-      // 分割文本
-      const textParts = fullText.split('${~~~}');
-
-      // 循环处理每个分割后的部分
-      for (const part of textParts) {
-        const trimmedPart = part.trim(); // 去除首尾空格
-        if (trimmedPart) { // 确保不是空字符串
-          const parsedElements = h.parse(trimmedPart);
-
-          // 创建 message 元素
-          const messageElement = h('message', {
-            userId: session.userId,
-            nickname: session.author?.nickname || session.username,
-          }, parsedElements);
-
-          // 添加 message 元素到 textElements
-          textElements.push(messageElement);
-        }
-      }
-    }
-
-    // 视频/链接解析
-    if (config.VideoParsing_ToLink) {
-      const fullAPIurl = `http://api.xingzhige.cn/API/b_parse/?url=${encodeURIComponent(lastretUrl)}`;
-
-      try {
-        const responseData: any = await ctx.http.get(fullAPIurl);
-
-        if (responseData.code === 0 && responseData.msg === "video" && responseData.data) {
-          const { bvid, cid, video } = responseData.data;
-          const bilibiliUrl = `https://api.bilibili.com/x/player/playurl?fnval=80&cid=${cid}&bvid=${bvid}`;
-          const playData: any = await ctx.http.get(bilibiliUrl);
-
-          logInfo(bilibiliUrl);
-
-          if (playData.code === 0 && playData.data && playData.data.dash && playData.data.dash.duration) {
-            const videoDurationSeconds = playData.data.dash.duration;
-            const videoDurationMinutes = videoDurationSeconds / 60;
-
-            // 检查视频是否太短
-            if (videoDurationMinutes < config.Minimumduration) {
-
-              // 根据 Minimumduration_tip 的值决定行为
-              if (config.Minimumduration_tip === 'return') {
-                // 不返回文字提示，直接返回
-                return;
-              } else if (typeof config.Minimumduration_tip === 'object' && config.Minimumduration_tip !== null) {
-                // 返回文字提示
-                if (config.Minimumduration_tip.tipcontent) {
-                  if (config.Minimumduration_tip.tipanalysis) {
-                    videoElements.push(h.text(config.Minimumduration_tip.tipcontent));
-                  } else {
-                    await session.send(config.Minimumduration_tip.tipcontent);
-                  }
-                }
-
-                // 决定是否进行图文解析
-                shouldPerformTextParsing = config.Minimumduration_tip.tipanalysis === true;
-
-                // 如果不进行图文解析，清空已准备的文本元素
-                if (!shouldPerformTextParsing) {
-                  textElements = [];
-                }
-              }
-            }
-            // 检查视频是否太长
-            else if (videoDurationMinutes > config.Maximumduration) {
-
-              // 根据 Maximumduration_tip 的值决定行为
-              if (config.Maximumduration_tip === 'return') {
-                // 不返回文字提示，直接返回
-                return;
-              } else if (typeof config.Maximumduration_tip === 'object' && config.Maximumduration_tip !== null) {
-                // 返回文字提示
-                if (config.Maximumduration_tip.tipcontent) {
-                  if (config.Maximumduration_tip.tipanalysis) {
-                    videoElements.push(h.text(config.Maximumduration_tip.tipcontent));
-                  } else {
-                    await session.send(config.Maximumduration_tip.tipcontent);
-                  }
-                }
-
-                // 决定是否进行图文解析
-                shouldPerformTextParsing = config.Maximumduration_tip.tipanalysis === true;
-
-                // 如果不进行图文解析，清空已准备的文本元素
-                if (!shouldPerformTextParsing) {
-                  textElements = [];
-                }
-              }
-            } else {
-              // 视频时长在允许范围内，处理视频
-              let videoData = video.url;  // 使用新变量名，避免覆盖原始URL
-              logInfo(videoData);
-
-              if (config.filebuffer) {
-                try {
-                  const videoFileBuffer: any = await ctx.http.file(video.url);
-                  logInfo(videoFileBuffer);
-
-                  // 检查文件类型
-                  if (videoFileBuffer && videoFileBuffer.data) {
-                    // 将ArrayBuffer转换为Buffer
-                    const buffer = Buffer.from(videoFileBuffer.data);
-
-                    // 获取MIME类型
-                    const mimeType = videoFileBuffer.type || videoFileBuffer.mime || 'video/mp4';
-
-                    // 创建data URI
-                    const base64Data = buffer.toString('base64');
-                    videoData = `data:${mimeType};base64,${base64Data}`;
-
-                    logInfo("成功使用 ctx.http.file 将视频URL 转换为data URI格式");
-                  } else {
-                    logInfo("文件数据无效，使用原始URL");
-                  }
-                } catch (error) {
-                  logger.error("获取视频文件失败:", error);
-                  // 出错时继续使用原始URL
-                }
-              }
-
-              if (videoData) {
-                if (options.link) {
-                  // 如果是链接选项，仍然使用原始URL
-                  videoElements.push(h.text(video.url));
-                } else if (options.audio) {
-                  videoElements.push(h.audio(videoData));
-                } else {
-                  switch (config.VideoParsing_ToLink) {
-                    case '1':
-                      break;
-                    case '2':
-                      videoElements.push(h.video(videoData));
-                      break;
-                    case '3':
-                      videoElements.push(h.text(video.url));
-                      break;
-                    case '4':
-                      videoElements.push(h.text(video.url));
-                      videoElements.push(h.video(videoData));
-                      break;
-                    case '5':
-                      logger.info(video.url);
-                      videoElements.push(h.video(videoData));
-                      break;
-                    default:
-                      break;
-                  }
-                }
-              } else {
-                throw new Error("解析视频直链失败");
-              }
-
-            }
-          } else {
-            throw new Error("获取播放数据失败");
-          }
-        } else {
-          throw new Error("解析视频信息失败或非视频类型内容");
-        }
-      } catch (error) {
-        logger.error("请求解析 API 失败或处理出错:", error);
-      }
-    }
-
-    // 准备发送的所有元素
-    let allElements = [...textElements, ...videoElements];
-
-    if (allElements.length === 0) {
-      return;
-    }
-
-    // 合并转发处理
-    if (config.isfigure && (session.platform === "onebot" || session.platform === "red")) {
-      logInfo(`使用合并转发，正在合并消息。`);
-
-      // 创建 figure 元素
-      const figureContent = h('figure', {
-        children: allElements
-      });
-
-      if (config.loggerinfofulljson) {
-        logInfo(JSON.stringify(figureContent, null, 2));
-      }
-
-      // 发送合并转发消息
-      await session.send(figureContent);
-    } else {
-      // 没有启用合并转发，按顺序发送所有元素
-      for (const element of allElements) {
-        await session.send(element);
-      }
-    }
-
-    logInfo(`机器人已发送完整消息。`);
-    if (waitTipMsgId) {
-      await session.bot.deleteMessage(session.channelId, waitTipMsgId);
-    }
-    return;
-  }
-
-  // 提取最后一个URL
-  function extractLastUrl(text: string): string | null {
-    const urlPattern = /https?:\/\/[^\s]+/g;
-    const urls = text.match(urlPattern);
-    return urls ? urls.pop() : null;
-  }
-
-  // 检测BV / AV 号并转换为URL
-  function convertBVToUrl(text: string): string[] {
-    const bvPattern = /(?:^|\s)(BV\w{10})(?:\s|$)/g;
-    const avPattern = /(?:^|\s)(av\d+)(?:\s|$)/g;
-    const matches: string[] = [];
-    let match: RegExpExecArray;
-
-    // 查找 BV 号
-    while ((match = bvPattern.exec(text)) !== null) {
-      matches.push(`https://www.bilibili.com/video/${match[1]}`);
-    }
-
-    // 查找 AV 号
-    while ((match = avPattern.exec(text)) !== null) {
-      matches.push(`https://www.bilibili.com/video/${match[1]}`);
-    }
-
-    return matches;
-  }
-
-  function numeral(number: number): string | number {
-    if (config.useNumeral) {
-      if (number >= 10000 && number < 100000000) {
-        return (number / 10000).toFixed(1) + "万";
-      }
-      else if (number >= 100000000) {
-        return (number / 100000000).toFixed(1) + "亿";
-      }
-      else {
-        return number.toString();
-      }
-    }
-    else {
-      return number;
-    }
-  }
-
-  /**
-   * 解析 ID 类型
-   * @param id 视频 ID
-   * @returns type: ID 类型, id: 视频 ID
-   */
-  function vid_type_parse(id: string): { type: string | null; id: string | null } {
-    var idRegex = [
-      {
-        pattern: /av([0-9]+)/i,
-        type: "av",
-      },
-      {
-        pattern: /bv([0-9a-zA-Z]+)/i,
-        type: "bv",
-      },
-    ];
-    for (const rule of idRegex) {
-      var match = id.match(rule.pattern);
-      if (match) {
-        return {
-          type: rule.type,
-          id: match[1],
-        };
-      }
-    }
-    return {
-      type: null,
-      id: null,
-    };
-  }
-
-  /**
-   * 根据视频 ID 查找视频信息
-   * @param id 视频 ID
-   * @returns 视频信息 Json
-   */
-  async function fetch_video_info(id: string): Promise<any> {
-    var ret: any;
-    const vid = vid_type_parse(id);
-    switch (vid["type"]) {
-      case "av":
-        ret = await ctx.http.get("https://api.bilibili.com/x/web-interface/view?aid=" + vid["id"], {
-          headers: {
-            "User-Agent": config.userAgent,
-          },
-        });
-        break;
-      case "bv":
-        ret = await ctx.http.get("https://api.bilibili.com/x/web-interface/view?bvid=" + vid["id"], {
-          headers: {
-            "User-Agent": config.userAgent,
-          },
-        });
-        break;
-      default:
-        ret = null;
-        break;
-    }
-    return ret;
-  }
-
-  /**
-   * 生成视频信息
-   * @param id 视频 ID
-   * @returns 文字视频信息
-   */
-  async function gen_context(id: string): Promise<string | null> {
-    const info = await fetch_video_info(id);
-    if (!info || !info["data"])
-      return null;
-
-    let description = info["data"]["desc"];
-    // 根据配置处理简介
-    const maxLength = config.bVideoShowIntroductionTofixed;
-    if (description.length > maxLength) {
-      description = description.substring(0, maxLength) + '...';
-    }
-    // 定义占位符对应的数据
-    const placeholders: Record<string, string> = {
-      '${标题}': info["data"]["title"],
-      '${UP主}': info["data"]["owner"]["name"],
-      '${封面}': `<img src="${info["data"]["pic"]}"/>`,
-      '${简介}': description, // 使用处理后的简介
-      '${点赞}': `${numeral(info["data"]["stat"]["like"])}`,
-      '${投币}': `${numeral(info["data"]["stat"]["coin"])}`,
-      '${收藏}': `${numeral(info["data"]["stat"]["favorite"])}`,
-      '${转发}': `${numeral(info["data"]["stat"]["share"])}`,
-      '${观看}': `${numeral(info["data"]["stat"]["view"])}`,
-      '${弹幕}': `${numeral(info["data"]["stat"]["danmaku"])}`,
-      '${tab}': `<pre>\t</pre>`
-    };
-
-    // 根据配置项中的格式替换占位符
-    let ret = config.bVideo_area;
-    for (const [placeholder, value] of Object.entries(placeholders)) {
-      ret = ret.replace(new RegExp(placeholder.replace(/\$/g, '\\$'), 'g'), value);
-    }
-
-    // 根据 ID 偏好添加视频链接
-    switch (config.bVideoIDPreference) {
-      case "bv":
-        ret += `\nhttps://www.bilibili.com/video/${info["data"]["bvid"]}`;
-        break;
-      case "av":
-        ret += `\nhttps://www.bilibili.com/video/av${info["data"]["aid"]}`;
-        break;
-      default:
-        break;
-    }
-
-    return ret;
-  }
-
-  /**
-  * 链接类型解析
-  * @param content 传入消息
-  * @returns type: "链接类型", id :"内容ID"
-  */
-  function link_type_parser(content: string): { type: string; id: string }[] {
-    // 先替换转义斜杠
-    content = content.replace(/\\\//g, '/');
-    var linkRegex = [
-      {
-        pattern: /bilibili\.com\/video\/([ab]v[0-9a-zA-Z]+)/gim,
-        type: "Video",
-      },
-      {
-        pattern: /b23\.tv(?:\\)?\/([0-9a-zA-Z]+)/gim,
-        type: "Short",
-      },
-      {
-        pattern: /bili(?:22|23|33)\.cn\/([0-9a-zA-Z]+)/gim,
-        type: "Short",
-      },
-      {
-        pattern: /bili2233\.cn\/([0-9a-zA-Z]+)/gim,
-        type: "Short",
-      },
-    ];
-    var ret: { type: string; id: string }[] = [];
-    for (const rule of linkRegex) {
-      var match: RegExpExecArray;
-      let lastID: string;
-      while ((match = rule.pattern.exec(content)) !== null) {
-        if (lastID == match[1])
-          continue;
-        ret.push({
-          type: rule.type,
-          id: match[1],
-        });
-        lastID = match[1];
-      }
-    }
-    return ret;
-  }
-
-  /**
-  * 类型执行器
-  * @param element 链接列表
-  * @returns 解析来的文本
-  */
-  async function type_processer(element: { type: string; id: string }): Promise<string> {
-    var ret = "";
-    switch (element["type"]) {
-      case "Video":
-        const video_info = await gen_context(element["id"]);
-        if (video_info != null)
-          ret += video_info;
-        break;
-
-      case "Short":
-        const typed_link = link_type_parser(await get_redir_url(element["id"]));
-        for (const element of typed_link) {
-          const final_info = await type_processer(element);
-          if (final_info != null)
-            ret += final_info;
-          break;
-        }
-        break;
-    }
-    return ret;
-  }
-
-  /**
-  * 根据短链接重定向获取正常链接
-  * @param id 短链接 ID
-  * @returns 正常链接
-  */
-  async function get_redir_url(id: string): Promise<string | null> {
-    var data = await ctx.http.get("https://b23.tv/" + id, {
-      redirect: "manual",
-      headers: {
-        "User-Agent": config.userAgent,
-      },
-    });
-    const match = data.match(/<a\s+(?:[^>]*?\s+)?href="([^"]*)"/i);
-    if (match)
-      return match[1];
-    else
-      return null;
-  }
-
 }