diff --git a/.gitignore b/.gitignore
index af0aceb..f633812 100644
--- a/.gitignore
+++ b/.gitignore
@@ -13,4 +13,5 @@ images
 logs
 *.sklearn
 config/*.story.yml
-config/story.yml
\ No newline at end of file
+config/story.yml
+model/*.pth
\ No newline at end of file
diff --git a/README.md b/README.md
index 00ef854..e85e1e5 100644
--- a/README.md
+++ b/README.md
@@ -99,3 +99,35 @@ interface CommonResponse<T> {
 - 非必要，请不要随意宣传本项目。
 - 虽然曾经无数个 QQ 相关的项目都死了，但是基本的 API 端口算是传承了下来。拉格朗日的返回类型，请参考 [go-cqhttp 帮助中心 - API 篇](https://docs.go-cqhttp.org/api/) 中的内容。
 
+---
+
+## 启动
+
+```bash
+# 1. 启动 拉格朗日
+tsc
+pm2 start dist/main.js --name Lagrange.onebot
+pm2 start rag/main.py --name rag
+```
+
+---
+
+## 测试命令
+
+### 重训练 embedding -> intent 分类层
+
+```bash
+curl -X POST http://127.0.0.1:8081/intent/retrain-embedding-mapping
+```
+
+### 获取意图
+
+```bash
+curl -X POST -H "Content-Type: application/json" -d '{"query": "真的开线程是要tcl指令去改的"}' http://127.0.0.1:8081/intent/get-intent-recogition
+```
+
+### 获取向量数据库中的 topk
+
+```bash
+curl -X POST -H "Content-Type: application/json" -d '{"query": "这个插件有什么比较好的文档吗？"}' http://127.0.0.1:8081/vecdb/similarity_search_with_score
+```
\ No newline at end of file
diff --git a/bot/api/llm.ts b/bot/api/llm.ts
new file mode 100644
index 0000000..6dc1a05
--- /dev/null
+++ b/bot/api/llm.ts
@@ -0,0 +1,70 @@
+// 配置大模型 请求参数
+
+import axios from "axios";
+import { logger } from "lagrange.onebot";
+
+interface LlmMessageItem {
+    role: 'user' | 'assistant',
+    content: string
+}
+
+class ErineLLM {
+    apiKey: string = process.env.BAIDU_API_KEY;
+    secretKey: string = process.env.BAIDU_SECRET_KEY;
+    accessToken: string = '';
+    constructor() {
+        if (this.apiKey === '') {
+            throw Error('百度 api_key 为空');
+        }
+
+        if (this.secretKey === '') {
+            throw Error('百度 secret_key 为空');
+        }
+        
+        this.getAccessToken();
+    }
+
+    public async getAccessToken() {
+        const url = `https://aip.baidubce.com/oauth/2.0/token?grant_type=client_credentials&client_id=${this.apiKey}&client_secret=${this.secretKey}`;
+        const payload = "";
+        const headers = {
+            'Content-Type': 'application/json',
+            'Accept': 'application/json'
+        };
+        const { data } = await axios.post(url, payload, { headers });
+        const accessToken = data.access_token;
+        if (accessToken) {
+            this.accessToken = accessToken;
+            logger.info('成功获取大模型访问令牌');
+        } else {
+            logger.error('大模型令牌获取失败：' + JSON.stringify(data))
+        }
+    }
+
+    public async answer(message: LlmMessageItem[]): Promise<string | undefined> {
+        if (message.length % 2 === 0) {
+            logger.error('大模型的 message 长度必须是奇数，目前为 ' + message.length);
+            return undefined;
+        }
+        const url = 'https://aip.baidubce.com/rpc/2.0/ai_custom/v1/wenxinworkshop/chat/ernie-lite-8k?access_token=' + this.accessToken;
+        
+        const payload = {
+            messages: message,
+            system: '你是锦恢开发的用于进行问答的 QA 机器人。主要负责解决 Digital IDE 用户群的答疑问题'
+        }
+        const headers = {
+            'Content-Type': 'application/json'
+        }
+
+        const { data } = await axios.post(url, payload, { headers });
+        const result = data.result;
+        if (result) {
+            return result;
+        } else {
+            logger.error('大模型返回结果有误： ' + JSON.stringify(data));
+            return undefined;
+        }
+    }
+}
+
+export const llm = new ErineLLM();
\ No newline at end of file
diff --git a/bot/api/request.ts b/bot/api/request.ts
index 29df34d..28d70e1 100644
--- a/bot/api/request.ts
+++ b/bot/api/request.ts
@@ -4,6 +4,8 @@ import * as fs from 'fs';
 import * as yaml from 'yaml';
 import axios from 'axios';
 
+
+// 配置 向量数据库 的请求参数
 // 得到配置文件，组装基础路由
 const vecdbBuffer = fs.readFileSync('./config/vecdb.yml', 'utf-8');
 const vecdbConfig = yaml.parse(vecdbBuffer);
@@ -37,6 +39,7 @@ vecdbRequests.interceptors.response.use(
     }
 );
 
+
 export {
     vecdbRequests,
 
diff --git a/bot/api/vecdb.ts b/bot/api/vecdb.ts
index d20c7cd..d6cae0a 100644
--- a/bot/api/vecdb.ts
+++ b/bot/api/vecdb.ts
@@ -47,7 +47,8 @@ export interface apiGetIntentRecogitionRequest {
 
 export interface apiGetIntentRecogitionData {
     id: number,
-    name: string
+    name: string,
+    uncertainty: number
 }
 
 export interface apiIntentRetrainRequest {
diff --git a/bot/main.ts b/bot/main.ts
index 1f8ed93..2306710 100644
--- a/bot/main.ts
+++ b/bot/main.ts
@@ -1,8 +1,8 @@
 import * as fs from 'fs';
 
 import { server } from 'lagrange.onebot';
-import './test';
-import './digital-ide';
+import './services/test';
+import './services/digital-ide';
 
 const buffer = fs.readFileSync('./app/publish/appsettings.json', 'utf-8');
 const config = JSON.parse(buffer);
diff --git a/bot/plugins.ts b/bot/plugins/image.ts
similarity index 100%
rename from bot/plugins.ts
rename to bot/plugins/image.ts
diff --git a/bot/digital-ide.ts b/bot/services/digital-ide.ts
similarity index 100%
rename from bot/digital-ide.ts
rename to bot/services/digital-ide.ts
diff --git a/bot/services/intent.ts b/bot/services/intent.ts
new file mode 100644
index 0000000..ca88409
--- /dev/null
+++ b/bot/services/intent.ts
@@ -0,0 +1,71 @@
+import { mapper, plugins, LagrangeContext, PrivateMessage, GroupMessage, Send, logger } from 'lagrange.onebot'
+import { llm } from '../api/llm';
+import { apiQueryVecdb, apiQueryVecdbDataItem } from '../api/vecdb';
+
+interface IntentResult {
+    id: number,
+    name: string,
+    uncertainty: number
+}
+
+function makePrompt(messages: apiQueryVecdbDataItem[]): string {
+    const texts = ['你是一个很聪明的AI，下面是你的知识库和参考内容，请根据参考内容回答上述的问题：'];
+    for (const msg of messages) {
+        texts.push(msg.content);
+    }
+    return texts.join('\n');
+}
+
+async function useRagLLM(c: LagrangeContext<GroupMessage>, intentResult: IntentResult) {
+    const texts = [];
+    for (const msg of c.message.message) {
+        if (msg.type === 'text') {
+            texts.push(msg.data.text);
+        }
+    }
+
+
+    const { data } = await apiQueryVecdb({ query: texts.join(' '), k: 3 });
+    if (data.code === 200) {
+        const messages: apiQueryVecdbDataItem[] = data.data.filter(m => m.score <= 0.8);
+        if (messages.length === 0) {
+            c.sendMessage('未在数据库中检索到相关内容。');
+        } else {
+            const query = makePrompt(messages);
+            const res = await llm.answer([
+                {
+                    role: 'user',
+                    content: query
+                }
+            ]);
+            if (typeof res === 'string') {
+                const links = messages.map(m => m.source);
+                
+                const reference = ['参考链接：', ...links].join('\n');
+                const anwser = res + '\n\n' + reference;
+                c.sendMessage(anwser);
+            }
+        }
+
+    } else {
+        logger.error('apiQueryVecdb 接口访问失败: ' + JSON.stringify(data));
+        return false;
+    }
+}
+
+export async function handleGroupIntent(c: LagrangeContext<GroupMessage>, intentResult: IntentResult) {
+    switch (intentResult.name) {
+        case 'usage':
+            return await useRagLLM(c, intentResult);
+            break;
+        case 'bug':
+            return await useRagLLM(c, intentResult);
+            break;
+
+        case 'others':
+            break;
+        
+        default:
+            break;
+    }
+}
\ No newline at end of file
diff --git a/bot/services/test.ts b/bot/services/test.ts
new file mode 100644
index 0000000..f942aab
--- /dev/null
+++ b/bot/services/test.ts
@@ -0,0 +1,51 @@
+import '../plugins/image';
+
+import { mapper, plugins, LagrangeContext, PrivateMessage, GroupMessage, Send } from 'lagrange.onebot'
+
+import { apiGetIntentRecogition, apiQueryVecdb } from '../api/vecdb';
+
+import { handleGroupIntent } from './intent';
+
+export class Impl {
+    @mapper.onPrivateUser(1193466151)
+    @plugins.use('echo')
+    @plugins.use('pm')
+    @plugins.use('wget-image')
+    async handleJinhui(c: LagrangeContext<PrivateMessage>) {
+        c.sendMessage([{
+            type: 'image',
+            data: {
+                file: 'file:///data/zhelonghuang/project/rag-llm/images/bird.png',
+                timeout: 10000
+            }
+        }])
+        c.finishSession();
+    }
+
+    @mapper.onGroup(956419963, { at: false })
+    async handleTestGroup(c: LagrangeContext<GroupMessage>) {
+        const texts = [];
+        const message = c.message;
+        for (const msg of message.message) {
+            if (msg.type === 'text') {
+                texts.push(msg.data.text);
+            }
+        }
+        const reply: Send.Default[] = [];
+        const axiosRes = await apiGetIntentRecogition({ query: texts.join('\n') });
+        const res = axiosRes.data;
+        if (res.code == 200) {
+            const intentResult = res.data;
+
+            // 如果 不确定性 太高，就将意图修改为 
+            if (intentResult.uncertainty >= 0.33) {
+                intentResult.name = 'others';
+            }
+            const uncertainty = Math.round(intentResult.uncertainty * 1000) / 1000;
+            c.sendMessage(`【意图: ${intentResult.name} 不确定度: ${uncertainty}】`);
+            handleGroupIntent(c, intentResult);
+        } else {
+            c.sendMessage('RAG 系统目前离线');
+        }
+    }
+}
diff --git a/bot/test.ts b/bot/test.ts
deleted file mode 100644
index ade46a9..0000000
--- a/bot/test.ts
+++ /dev/null
@@ -1,28 +0,0 @@
-import './plugins';
-
-import { mapper, plugins, LagrangeContext, PrivateMessage, GroupMessage, Send } from 'lagrange.onebot'
-
-import { apiQueryVecdb } from './api/vecdb';
-
-export class Impl {
-    @mapper.onPrivateUser(1193466151)
-    @plugins.use('echo')
-    @plugins.use('pm')
-    @plugins.use('wget-image')
-    async handleJinhui(c: LagrangeContext<PrivateMessage>) {
-        c.sendMessage([{
-            type: 'image',
-            data: {
-                file: 'file:///data/zhelonghuang/project/rag-llm/images/bird.png',
-                timeout: 10000
-            }
-        }])
-        c.finishSession();
-    }
-
-    @mapper.onGroup(956419963, { at: false })
-    async handleTestGroup(c: LagrangeContext<GroupMessage>) {
-        console.log(c.message.message);
-        console.log(c.message.raw_message);
-    }
-}
diff --git a/debug.log b/debug.log
new file mode 100644
index 0000000..2c706e6
--- /dev/null
+++ b/debug.log
@@ -0,0 +1 @@
+{"query": "真的开线程是要tcl指令去改的"}
\ No newline at end of file
diff --git a/notebook/experiment.ipynb b/notebook/experiment.ipynb
index e99d162..8b46834 100644
--- a/notebook/experiment.ipynb
+++ b/notebook/experiment.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -19,7 +19,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [
     {
@@ -43,7 +43,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -52,7 +52,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
@@ -89,6 +89,49 @@
        "  'command not found: python',\n",
        "  'path top.v is not a hdlFile 请问报这个错误大概是啥原因啊',\n",
        "  '咖啡喝不了，喝了胃不舒服',\n",
+       "  '兄弟们有没有C语言绘图库推荐',\n",
+       "  '在企业里面最大的问题是碰见傻逼怎么办？',\n",
+       "  '如何使用 digital ide 这个插件？',\n",
+       "  '我早上开着机去打论文 回来发现我电脑切换到Linux了',\n",
+       "  '我在Windows下遇到的只要问题就是对于C程序，包管理和编译管理器偶尔会不认识彼此但除此之外，都很安稳（win11除外）',\n",
+       "  '不能理解在生产环境用arch的人。。',\n",
+       "  '请问一下xilinx fpga开发在win和linux平台哪个好？',\n",
+       "  '好羡慕你们可以开发自己喜欢的东西',\n",
+       "  '???',\n",
+       "  '？？？',\n",
+       "  '我人麻了',\n",
+       "  '艹',\n",
+       "  '我人傻了',\n",
+       "  '我tm',\n",
+       "  'tnnd',\n",
+       "  'funny mud goup',\n",
+       "  '衣服混起来洗，有一件深色的掉色了，现在我一盆白T恤全变成泥土色了',\n",
+       "  '这可是陪伴了我六七年的衣服啊',\n",
+       "  '唉神金',\n",
+       "  '为啥要用手机号码啊',\n",
+       "  '本人于今日12时点了4瓶500ml无糖可乐，收到四瓶888ml',\n",
+       "  '我是小趴菜',\n",
+       "  '我也想组乐队 www',\n",
+       "  '这个乐队谱，我看哭了',\n",
+       "  '我的手机最大的用处就是当一个麦克风+相机',\n",
+       "  '那你可能更适合iPhone，不过稍微贵点，入门级别5-6k，好一点的得8k-1w',\n",
+       "  'F和弦弹不起来太真实了 hhh',\n",
+       "  '草，这一套，比我买过的所有电子产品加起来还贵',\n",
+       "  '奶茶点少糖，游泳，打乒乓球，结果最近还胖了4斤',\n",
+       "  '你感觉有必要搞一个全局的数据库之类的么，比如日程插件和聊天插件可能都会用到用户的一些信息，如果不共享就要写两套用户处理逻辑',\n",
+       "  '确切说，前期他在外放声音看庆余年',\n",
+       "  '因为这是养蛊的虚拟机，放了些国产垃圾软件，得用国产流氓之王才能镇得住他们',\n",
+       "  '真的开线程是要tcl指令去改的',\n",
+       "  '下个版本核心就是LSP设计了',\n",
+       "  '后面研究下怎么玩这个插件',\n",
+       "  '得上 Dirichlet 分布做一下不确定性拟合了',\n",
+       "  '用群友的数据训了一下，bias有点大',\n",
+       "  '我觉得关键时刻可以防身',\n",
+       "  '我记得windows默认max是2吧',\n",
+       "  '再过几年毛利大叔就变成毛利老弟了',\n",
+       "  '我也感觉自己老的好快',\n",
+       "  '？？？',\n",
+       "  '我的反撤回还能用',\n",
        "  '关于波形显示的一些建议',\n",
        "  '采用iverilog生成的VCD貌似无法解析仿真数据',\n",
        "  '【v0.3.2】模块调用后netlist生成错误，且仿真报错',\n",
@@ -152,103 +195,146 @@
        "  '[0.3.0 beta] Bitwidth of 1-bit signal is incorrectly recognized as \"Unknown\" in auto instantiation and auto document',\n",
        "  '[0.3.3 beta] 含参数模型的例化存在问题以及拓展快捷键失效的问题',\n",
        "  \"[0.3.2]数值悬停提示不支持'_'语法\"],\n",
-       " [1,\n",
-       "  2,\n",
-       "  3,\n",
-       "  5,\n",
+       " [0,\n",
        "  1,\n",
-       "  5,\n",
-       "  5,\n",
        "  2,\n",
+       "  6,\n",
+       "  0,\n",
+       "  6,\n",
+       "  6,\n",
+       "  1,\n",
+       "  0,\n",
+       "  0,\n",
+       "  0,\n",
+       "  2,\n",
+       "  6,\n",
+       "  0,\n",
+       "  6,\n",
+       "  0,\n",
+       "  6,\n",
+       "  0,\n",
+       "  6,\n",
+       "  6,\n",
+       "  6,\n",
+       "  6,\n",
+       "  6,\n",
+       "  0,\n",
+       "  0,\n",
+       "  1,\n",
+       "  6,\n",
+       "  6,\n",
+       "  6,\n",
+       "  0,\n",
+       "  6,\n",
+       "  0,\n",
+       "  6,\n",
+       "  0,\n",
+       "  6,\n",
+       "  6,\n",
+       "  6,\n",
+       "  0,\n",
+       "  6,\n",
+       "  4,\n",
+       "  4,\n",
+       "  4,\n",
+       "  4,\n",
+       "  4,\n",
+       "  4,\n",
+       "  4,\n",
+       "  4,\n",
+       "  4,\n",
+       "  4,\n",
+       "  4,\n",
+       "  6,\n",
+       "  5,\n",
+       "  5,\n",
+       "  4,\n",
+       "  4,\n",
+       "  6,\n",
+       "  6,\n",
+       "  4,\n",
+       "  6,\n",
+       "  6,\n",
+       "  6,\n",
+       "  6,\n",
+       "  5,\n",
+       "  6,\n",
+       "  6,\n",
+       "  6,\n",
+       "  6,\n",
+       "  6,\n",
+       "  6,\n",
+       "  6,\n",
+       "  6,\n",
+       "  6,\n",
+       "  4,\n",
+       "  6,\n",
+       "  3,\n",
+       "  1,\n",
+       "  1,\n",
+       "  3,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
        "  1,\n",
        "  1,\n",
        "  1,\n",
        "  3,\n",
-       "  5,\n",
-       "  1,\n",
-       "  5,\n",
-       "  1,\n",
-       "  5,\n",
-       "  1,\n",
-       "  5,\n",
-       "  5,\n",
-       "  5,\n",
-       "  5,\n",
-       "  5,\n",
        "  1,\n",
        "  1,\n",
-       "  2,\n",
-       "  5,\n",
-       "  5,\n",
-       "  5,\n",
        "  1,\n",
-       "  5,\n",
-       "  4,\n",
-       "  2,\n",
-       "  2,\n",
-       "  4,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  4,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  4,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  4,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2,\n",
-       "  2])"
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
+       "  3,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
+       "  3,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1,\n",
+       "  1])"
       ]
      },
-     "execution_count": 4,
+     "execution_count": 5,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -267,16 +353,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "(94, 768)"
+       "(137, 768)"
       ]
      },
-     "execution_count": 5,
+     "execution_count": 6,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -289,7 +375,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -299,22 +385,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x7fee22b00690>"
+       "<matplotlib.legend.Legend at 0x7fd0305bbbd0>"
       ]
      },
-     "execution_count": 7,
+     "execution_count": 8,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -334,7 +420,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
@@ -346,7 +432,7 @@
        "LogisticRegression()"
       ]
      },
-     "execution_count": 8,
+     "execution_count": 9,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -359,16 +445,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "array([5])"
+       "'others'"
       ]
      },
-     "execution_count": 9,
+     "execution_count": 10,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -376,12 +462,13 @@
    "source": [
     "test_sentence = ['咖啡喝不了，喝了胃不舒服']\n",
     "test_embedding = model.embed_documents(test_sentence)\n",
-    "log_model.predict(test_embedding)"
+    "res = log_model.predict(test_embedding)[0]\n",
+    "engine.id2intent[res]"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
@@ -390,7 +477,7 @@
        "['../model/embedding_mapping.sklearn']"
       ]
      },
-     "execution_count": 10,
+     "execution_count": 11,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -402,35 +489,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 12,
    "metadata": {},
    "outputs": [],
    "source": [
     "log_model = joblib.load('../model/embedding_mapping.sklearn')"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "array([5])"
-      ]
-     },
-     "execution_count": 12,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "test_sentence = ['咖啡喝不了，喝了胃不舒服']\n",
-    "test_embedding = model.embed_documents(test_sentence)\n",
-    "log_model.predict(test_embedding)"
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": 13,
@@ -438,11 +503,8 @@
    "outputs": [
     {
      "data": {
-      "text/html": [
-       "<style>#sk-container-id-2 {color: black;}#sk-container-id-2 pre{padding: 0;}#sk-container-id-2 div.sk-toggleable {background-color: white;}#sk-container-id-2 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-2 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-2 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-2 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-2 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-2 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-2 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-2 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-2 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-2 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-2 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-2 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-2 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-2 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-2 div.sk-item {position: relative;z-index: 1;}#sk-container-id-2 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-2 div.sk-item::before, #sk-container-id-2 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-2 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-2 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-2 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-2 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-2 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-2 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-2 div.sk-label-container {text-align: center;}#sk-container-id-2 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-2 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-2\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>SVC()</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-2\" type=\"checkbox\" checked><label for=\"sk-estimator-id-2\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">SVC</label><div class=\"sk-toggleable__content\"><pre>SVC()</pre></div></div></div></div></div>"
-      ],
       "text/plain": [
-       "SVC()"
+       "'others'"
       ]
      },
      "execution_count": 13,
@@ -451,33 +513,274 @@
     }
    ],
    "source": [
-    "from sklearn.svm import SVC\n",
+    "test_sentence = ['咖啡喝不了，喝了胃不舒服']\n",
+    "test_embedding = model.embed_documents(test_sentence)\n",
+    "res = log_model.predict(test_embedding)[0]\n",
+    "engine.id2intent[res]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 尝试使用 EDL\n",
     "\n",
-    "svm = SVC()\n",
-    "svm.fit(embedding, labels)"
+    "使用证据网络增加不确定性计算，详细可看： [EDL（Evidential Deep Learning） 原理与代码实现](https://kirigaya.cn/blog/article?seq=154)\n",
+    "\n",
+    "损失函数\n",
+    "\n",
+    "$$\n",
+    "\\mathcal L(\\theta) = \\sum_{i=1}^N \\mathcal L_i(\\theta) +\\lambda_t \\sum_{i=1}^N \\mathrm{KL}\\left(D(p_i|\\tilde{\\alpha}_i) || D(p_i | \\bold 1)\\right)\n",
+    "$$"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 15,
    "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "import torch\n",
+    "import torch.nn as nn\n",
+    "import torch.nn.functional as F\n",
+    "import tqdm\n",
+    "\n",
+    "class SimpleERNN(nn.Module):\n",
+    "    in_dim: int\n",
+    "    out_dim: int\n",
+    "    alpha_kl: float\n",
+    "    def __init__(self, in_dim: int, out_dim: int, focal: int, alpha_kl: float):\n",
+    "        super().__init__()\n",
+    "        self.in_dim = in_dim\n",
+    "        self.out_dim = out_dim\n",
+    "        self.alpha_kl = alpha_kl\n",
+    "        self.focal = focal\n",
+    "        self.classifier = nn.Sequential(\n",
+    "            nn.Linear(in_dim, out_dim),\n",
+    "            nn.ELU(),\n",
+    "        )\n",
+    "    \n",
+    "    def forward(self, inputs: torch.FloatTensor) -> tuple[torch.FloatTensor, torch.FloatTensor]:\n",
+    "        logits = self.classifier(inputs)\n",
+    "        evidence = torch.exp(logits)\n",
+    "        prob = F.normalize(evidence + 1, p=1, dim=1)\n",
+    "        return evidence, prob\n",
+    "\n",
+    "    def criterion(self, evidence: torch.FloatTensor, label: torch.LongTensor) -> torch.FloatTensor:\n",
+    "        if len(label.shape) == 1:\n",
+    "            label = F.one_hot(label, self.out_dim)\n",
+    "        alpha = evidence + 1\n",
+    "        alpha_0 = alpha.sum(1).unsqueeze(-1).repeat(1, self.out_dim)\n",
+    "        loss_ece = torch.sum(label * (torch.digamma(alpha_0) - torch.digamma(alpha)), dim=1)\n",
+    "        loss_ece = torch.mean(loss_ece)\n",
+    "        if self.alpha_kl > 0:\n",
+    "            tilde_alpha = label + (1 - label) * alpha\n",
+    "            uncertainty_alpha = torch.ones_like(tilde_alpha).cuda()\n",
+    "            estimate_dirichlet = torch.distributions.Dirichlet(tilde_alpha)\n",
+    "            uncertainty_dirichlet = torch.distributions.Dirichlet(uncertainty_alpha)\n",
+    "            kl = torch.distributions.kl_divergence(estimate_dirichlet, uncertainty_dirichlet)\n",
+    "            loss_kl = torch.mean(kl)\n",
+    "        else:\n",
+    "            loss_kl = 0\n",
+    "        return loss_ece + self.alpha_kl * loss_kl    "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 100/100 [00:00<00:00, 240.91it/s]\n"
+     ]
+    }
+   ],
+   "source": [
+    "in_dim = embedding.shape[1]\n",
+    "out_dim = max(labels) + 1\n",
+    "enn_model = SimpleERNN(in_dim, out_dim, 0, 0)\n",
+    "optimizer = torch.optim.AdamW(enn_model.parameters(), lr=1e-3)\n",
+    "\n",
+    "bs = 64\n",
+    "sample_num = len(embedding)\n",
+    "sample_indice = np.arange(sample_num)\n",
+    "bs_num = int(np.ceil(sample_num / bs))\n",
+    "\n",
+    "training_losses = []\n",
+    "\n",
+    "for i in tqdm.trange(100):\n",
+    "    alpha_kl = min(0.9, i / 10)\n",
+    "    np.random.shuffle(sample_indice)    \n",
+    "    train_loss = 0\n",
+    "    for bs_i in range(bs_num):\n",
+    "        start = bs_i * bs\n",
+    "        end = min(sample_num, start + bs)\n",
+    "        data_indice = sample_indice[start: end]\n",
+    "        data = torch.FloatTensor(embedding[data_indice])\n",
+    "        label = torch.LongTensor(labels[data_indice])\n",
+    "        evidence, prob = enn_model(data)\n",
+    "        loss = enn_model.criterion(evidence, label)\n",
+    "        train_loss += loss.item()\n",
+    "        \n",
+    "        optimizer.zero_grad()\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "\n",
+    "    training_losses.append(train_loss / bs_num)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "['../model/embedding_mapping.sklearn']"
+       "[<matplotlib.lines.Line2D at 0x7f7dec58da50>]"
       ]
      },
-     "execution_count": 15,
+     "execution_count": 66,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.plot(training_losses)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# torch.save(enn_model.state_dict(), '../model/intent.enn.pth')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<All keys matched successfully>"
+      ]
+     },
+     "execution_count": 16,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "# test_sentence = ['咖啡喝不了，喝了胃不舒服']\n",
-    "# test_embedding = model.embed_documents(test_sentence)\n",
-    "# svm.predict(test_embedding)\n",
-    "# joblib.dump(log_model, '../model/embedding_mapping.sklearn')"
+    "in_dim = embedding.shape[1]\n",
+    "out_dim = max(labels) + 1\n",
+    "enn_model = SimpleERNN(in_dim, out_dim, 0, 0)\n",
+    "state_dict = torch.load('../model/intent.enn.pth')\n",
+    "enn_model.load_state_dict(state_dict)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(tensor([0.2663]),\n",
+       " tensor([[0.1731, 0.2171, 0.0566, 0.0640, 0.0702, 0.0589, 0.3601]]),\n",
+       " tensor([[0.1351, 0.1791, 0.0185, 0.0259, 0.0321, 0.0209, 0.3221]]))"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "embd = model.embed_documents(['其实是计划给linux适配的，linux和mac都是posix接口，那不是自然就适配mac了吗'])\n",
+    "embd = torch.FloatTensor(embd)\n",
+    "with torch.no_grad():\n",
+    "    evidence, prob = enn_model(embd)\n",
+    "\n",
+    "e = evidence\n",
+    "alpha = e + 1\n",
+    "S = alpha.sum(1)\n",
+    "b = e / S\n",
+    "u = out_dim / S\n",
+    "u, prob, b"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'model' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[1], line 22\u001b[0m\n\u001b[1;32m      1\u001b[0m test_suite \u001b[38;5;241m=\u001b[39m [\n\u001b[1;32m      2\u001b[0m     { \u001b[38;5;124m'\u001b[39m\u001b[38;5;124minput\u001b[39m\u001b[38;5;124m'\u001b[39m: \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m如何使用 digital ide 这个插件？\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mexpect\u001b[39m\u001b[38;5;124m'\u001b[39m: \u001b[38;5;124m'\u001b[39m\u001b[38;5;124musage\u001b[39m\u001b[38;5;124m'\u001b[39m },\n\u001b[1;32m      3\u001b[0m     { \u001b[38;5;124m'\u001b[39m\u001b[38;5;124minput\u001b[39m\u001b[38;5;124m'\u001b[39m: \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m我今天打开 vscode，发现 自动补全失效了，我是哪里没有配置好吗？\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mexpect\u001b[39m\u001b[38;5;124m'\u001b[39m: \u001b[38;5;124m'\u001b[39m\u001b[38;5;124musage,bug\u001b[39m\u001b[38;5;124m'\u001b[39m },\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m     19\u001b[0m     { \u001b[38;5;124m'\u001b[39m\u001b[38;5;124minput\u001b[39m\u001b[38;5;124m'\u001b[39m: \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m？？？\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mexpect\u001b[39m\u001b[38;5;124m'\u001b[39m: \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mexpression\u001b[39m\u001b[38;5;124m'\u001b[39m },\n\u001b[1;32m     20\u001b[0m ]\n\u001b[1;32m     21\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m test \u001b[38;5;129;01min\u001b[39;00m test_suite:\n\u001b[0;32m---> 22\u001b[0m     embd \u001b[38;5;241m=\u001b[39m \u001b[43mmodel\u001b[49m\u001b[38;5;241m.\u001b[39membed_documents([test[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124minput\u001b[39m\u001b[38;5;124m'\u001b[39m]])\n\u001b[1;32m     23\u001b[0m     embd \u001b[38;5;241m=\u001b[39m torch\u001b[38;5;241m.\u001b[39mFloatTensor(embd)\n\u001b[1;32m     24\u001b[0m     \u001b[38;5;28;01mwith\u001b[39;00m torch\u001b[38;5;241m.\u001b[39mno_grad():\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'model' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "test_suite = [\n",
+    "    { 'input': '如何使用 digital ide 这个插件？', 'expect': 'usage' },\n",
+    "    { 'input': '我今天打开 vscode，发现 自动补全失效了，我是哪里没有配置好吗？', 'expect': 'usage,bug' },\n",
+    "    { 'input': 'path top.v is not a hdlFile 请问报这个错误大概是啥原因啊', 'expect': 'usage,bug' },\n",
+    "    { 'input': '我同学在学习强国看到小麦收割了，然后就买相应的股就赚了', 'expect': 'others' },\n",
+    "    { 'input': '我平时写代码就喜欢喝茶', 'expect': 'others' },\n",
+    "    { 'input': '请问报这个错误大概是啥原因啊', 'expect': 'usage,bug' },\n",
+    "    { 'input': '感觉现在啥都在往AI靠', 'expect': 'others' },\n",
+    "    { 'input': '别人设置的肯定有点不合适自己的', 'expect': 'others' },\n",
+    "    { 'input': '在企业里面最大的问题是碰见傻逼怎么办？', 'expect': 'others' },\n",
+    "    { 'input': '几乎完全不喝牛奶2333', 'expect': 'others' },\n",
+    "    { 'input': 'command not found: python', 'expect': 'usage,bug,others' },\n",
+    "    { 'input': '兄弟们有没有C语言绘图库推荐', 'expect': 'usage' },\n",
+    "    { 'input': '我早上开着机去打论文 回来发现我电脑切换到Linux了', 'expect': 'usage,bug,others' },\n",
+    "    { 'input': '我在Windows下遇到的只要问题就是对于C程序，包管理和编译管理器偶尔会不认识彼此但除此之外，都很安稳（win11除外）', 'expect': 'usage,others' },\n",
+    "    { 'input': '我的反撤回还能用', 'expect': 'others' },\n",
+    "    { 'input': '因为这是养蛊的虚拟机，放了些国产垃圾软件，得用国产流氓之王才能镇得住他们', 'expect': 'others' },\n",
+    "    { 'input': '你咋装了个360', 'expect': 'others' },\n",
+    "    { 'input': '？？？', 'expect': 'expression' },\n",
+    "]\n",
+    "for test in test_suite:\n",
+    "    embd = model.embed_documents([test['input']])\n",
+    "    embd = torch.FloatTensor(embd)\n",
+    "    with torch.no_grad():\n",
+    "        evidence, prob = enn_model(embd)\n",
+    "\n",
+    "    e = evidence\n",
+    "    alpha = e + 1\n",
+    "    S = alpha.sum(1)\n",
+    "    b = e / S\n",
+    "    u = out_dim / S\n",
+    "    pre_label = prob.argmax(1)\n",
+    "    name = engine.id2intent[pre_label[0].item()]\n",
+    "    ok = '√' if name in test['expect'] else '×'\n",
+    "    print(name, test['expect'], ok, u)\n"
    ]
   }
  ],
diff --git a/notebook/vecdb.ipynb b/notebook/vecdb.ipynb
index 10c23a1..ef8e868 100644
--- a/notebook/vecdb.ipynb
+++ b/notebook/vecdb.ipynb
@@ -19,23 +19,33 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/data/zhelonghuang/miniconda3/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
+      "  from .autonotebook import tqdm as notebook_tqdm\n",
+      "/data/zhelonghuang/miniconda3/lib/python3.11/site-packages/huggingface_hub/file_download.py:1132: FutureWarning: `resume_download` is deprecated and will be removed in version 1.0.0. Downloads always resume when possible. If you want to force a new download, use `force_download=True`.\n",
+      "  warnings.warn(\n"
+     ]
+    },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "整理得到 304 个文档\n",
-      "分块得到 1273 个文档\n",
-      "数据库已存储到 blog-vecdb 中\n"
+      "分块得到 1276 个文档\n",
+      "数据库已存储到 ../blog-vecdb 中\n"
      ]
     }
    ],
    "source": [
     "embedding = HuggingFaceEmbeddings(model_name='maidalun1020/bce-embedding-base_v1')\n",
     "\n",
-    "db_persistent_dir = 'blog-vecdb'\n",
+    "db_persistent_dir = '../blog-vecdb'\n",
     "\n",
     "if os.path.exists(db_persistent_dir):\n",
     "    db = FAISS.load_local(db_persistent_dir, embedding, allow_dangerous_deserialization=True)\n",
@@ -60,7 +70,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [
     {
@@ -74,7 +84,7 @@
        "  0.71963197)]"
       ]
      },
-     "execution_count": 6,
+     "execution_count": 3,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -88,21 +98,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[(Document(page_content='除了b站的两个教程外，建议多出文档以及示例工程，一个刚接触FPGA但有不熟悉vivado的萌新就指望这个加快学习进度了\\n请问B站教程标题是啥？我搜digital-ide啥也搜不到\\n请问B站教程标题是啥？我搜digital-ide啥也搜不到\\n《Digital-IDE使用教程(一个DDS的实现)》\\n《Digital-IDE应用之FM调制解调》\\n请问B站教程标题是啥？我搜digital-ide啥也搜不到\\n《Digital-IDE使用教程(一个DDS的实现)》 《Digital-IDE应用之FM调制解调》\\n好的谢谢\\n那个教程是好早之前我出的了，新的版本一直不稳定，今年稳定之后会出后续教程。\\nDigital IDE 的使用教程可以看\\n官方文档为 https://sterben.nitcloud.cn/zh/ 但是目前文档不是很完善。', metadata={'source': '../docs/digital-issue/issue-47/issue.md', 'start_index': 0}),\n",
-       "  0.64211607),\n",
+       "[(Document(page_content='问题标题 基础教程太少\\n除了b站的两个教程外，建议多出文档以及示例工程，一个刚接触FPGA但有不熟悉vivado的萌新就指望这个加快学习进度了\\n请问B站教程标题是啥？我搜digital-ide啥也搜不到\\n请问B站教程标题是啥？我搜digital-ide啥也搜不到\\n《Digital-IDE使用教程(一个DDS的实现)》\\n《Digital-IDE应用之FM调制解调》\\n请问B站教程标题是啥？我搜digital-ide啥也搜不到\\n《Digital-IDE使用教程(一个DDS的实现)》 《Digital-IDE应用之FM调制解调》\\n好的谢谢\\n那个教程是好早之前我出的了，新的版本一直不稳定，今年稳定之后会出后续教程。\\nDigital IDE 的使用教程可以看\\n官方文档为 https://sterben.nitcloud.cn/zh/ 但是目前文档不是很完善。', metadata={'source': '../docs/digital-issue/issue-47/issue.md', 'start_index': 0}),\n",
+       "  0.63593847),\n",
        " (Document(page_content='home: true\\nheroImage: /icon.png\\ndescription: Vscode 平台上的 ASIC & FPGA 开发扩展\\nactionText: 快速开始 🐳\\nactionLink: /zh/guide/introduction\\nfeatures:\\n- title: ✨ HDL 语言支持\\n  details: 支持 verilog, vhdl, systemverilog, tcl 脚本等\\n- title: 🎯 项目管理\\n  details: 在你的项目中查看结构化的 HDL 文件\\n- title: 🛠️ 额外的工具\\n  details: FSM, Netlist, 一键仿真, 文档化，让你的编程体验更加舒坦。\\n\\n::: slot footer\\nMIT Licensed | Copyright © 2018-present Digital-EDA\\n:::', metadata={'source': '../docs/digital-document/index.md', 'start_index': 0}),\n",
        "  0.7582667),\n",
        " (Document(page_content='TODO\\n\\n找到所有 vcd item 的 type 类型，可参考：https://pyvcd.readthedocs.io/en/latest/vcd.common.html\\n\\nbug\\n\\n详见飞书文档：https://nc-ai-lab.feishu.cn/wiki/Z4AxwU1SdilATAk7GuvcYkIDnwh\\n\\n流程\\n\\n目前需要为Digital-IDE设计一个render用于显示VCD文件。\\n\\nIEEE 1364定义VCD(value change dump)文件是含已选变量（信号）的值变化信息存储文件。\\n\\nwavedrom在GitHub上开发过vcd和hdl的wavedrom脚本格式，可以用于进行DIDE的vcd可视化的二次开发，目前发现，为了实现vcd文件，基本的仓库主要是下面这两个：\\n\\nJS层与一个简单的前端：https://github.com/wavedrom/vcdrom\\n\\nwasm 解析：https://github.com/wavedrom/vcd\\n\\n打算基于这两个仓库二次开发一个好用的vcd渲染模块，再加入DIDE中。\\n\\n开发思路\\n\\nvcd 的渲染器分为如下几步进行开发。\\n\\nmermaid\\ngraph LR\\na(读取)-->b(渲染)-->c(解析)\\n\\nVCD 读取和解析并不难，难在如何快速安全地读取，对于一些长时间的模拟和仿真而言， vcd 文件可能会非常大。因此，vcd 需要分块读取，分块解析，为了避免这些不必要的麻烦，我使用了 https://github.com/wavedrom/vcdrom 这个项目的后端进行修改。\\n\\nwasm 解析器\\n\\n原项目写得过于紧凑，并不适合进行修改，因此需要修改一部分代码。\\n\\n整合项目在 ： https://github.com/Digital-EDA/digital-vcd-parser', metadata={'source': '../docs/kirigaya.cn/72.md', 'start_index': 0}),\n",
        "  0.83628875)]"
       ]
      },
-     "execution_count": 8,
+     "execution_count": 4,
      "metadata": {},
      "output_type": "execute_result"
     }
diff --git a/package.json b/package.json
index 606b334..bf761a6 100644
--- a/package.json
+++ b/package.json
@@ -18,22 +18,22 @@
         "@types/node": "^20.12.12",
         "axios": "^1.7.2",
         "fs": "^0.0.1-security",
-        "lagrange.onebot": "^1.0.0",
+        "lagrange.onebot": "^1.0.2",
         "ws": "^8.17.0",
         "yaml": "^2.4.2"
     },
     "devDependencies": {
+        "@sinonjs/referee-sinon": "^12.0.0",
         "@types/ws": "^8.5.10",
         "chai": "4.3.4",
-        "serve": "^14.2.3",
-        "typescript": "^5.4.5",
+        "jsverify": "^0.8.4",
+        "knuth-shuffle": "^1.0.8",
         "mocha": "^10.4.0",
         "require-uncached": "^2.0.0",
+        "serve": "^14.2.3",
         "shelljs": "^0.8.5",
         "should": "^13.2.3",
         "sinon": "^18.0.0",
-        "jsverify": "^0.8.4",
-        "knuth-shuffle": "^1.0.8",
-        "@sinonjs/referee-sinon": "^12.0.0"
+        "typescript": "^5.4.5"
     }
 }
diff --git a/prompt/core.py b/prompt/core.py
index e4f3d9f..37f5ff9 100644
--- a/prompt/core.py
+++ b/prompt/core.py
@@ -73,7 +73,7 @@ class PromptEngine:
                 if children is None:
                     children = []
                 
-                if name not in self.intent2id:
+                if name != 'root' and name not in self.intent2id:
                     assign_id = len(self.intent2id)
                     self.intent2id[name] = assign_id
                     self.id2intent[assign_id] = name
@@ -267,4 +267,4 @@ class TreeIntent(ABC):
 if __name__ == '__main__':
     prompt_engine = PromptEngine('./config/story.yml')
     prompt_engine.merge_stories_from_yml('./config/github-issue.story.yml')
-    print(len(prompt_engine.stories))
\ No newline at end of file
+    print(prompt_engine.id2intent)
\ No newline at end of file
diff --git a/rag/__init__.py b/rag/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/rag/api/__init__.py b/rag/api/__init__.py
new file mode 100644
index 0000000..d878c73
--- /dev/null
+++ b/rag/api/__init__.py
@@ -0,0 +1,11 @@
+from .admin import logger, app
+from .config import necessary_files
+from .constant import StatusCode, MsgCode
+
+__all__ = [
+    logger,
+    app,
+    necessary_files,
+    StatusCode,
+    MsgCode
+]
\ No newline at end of file
diff --git a/rag/admin.py b/rag/api/admin.py
similarity index 93%
rename from rag/admin.py
rename to rag/api/admin.py
index 378fbba..58352e7 100644
--- a/rag/admin.py
+++ b/rag/api/admin.py
@@ -12,4 +12,4 @@ logger.add(
     format="{time:YYYY-MM-DD HH:mm:ss} | {level} | {message}"
 )
 
-app = Flask(__file__)
\ No newline at end of file
+app = Flask(__file__)
diff --git a/rag/configs.py b/rag/api/config.py
similarity index 80%
rename from rag/configs.py
rename to rag/api/config.py
index caeaede..9f00e48 100644
--- a/rag/configs.py
+++ b/rag/api/config.py
@@ -1,9 +1,8 @@
-
 necessary_files = {
     'vecdb-config': './config/vecdb.yml',
     'intent-story': './config/story.yml',
     'issue-story': './config/github-issue.story.yml',
     'blog-vecdb-data': './blog-vecdb/index.faiss',
     'blog-vecdb-model': './blog-vecdb/index.pkl',
-    'intent-classifier': './model/embedding_mapping.sklearn'
+    'intent-classifier': './model/intent.enn.pth'
 }
\ No newline at end of file
diff --git a/rag/constant.py b/rag/api/constant.py
similarity index 100%
rename from rag/constant.py
rename to rag/api/constant.py
diff --git a/rag/db/__init__.py b/rag/db/__init__.py
new file mode 100644
index 0000000..8db4dd7
--- /dev/null
+++ b/rag/db/__init__.py
@@ -0,0 +1,6 @@
+from .embedding import db, embedding
+
+__all__ = [
+    db,
+    embedding
+]
\ No newline at end of file
diff --git a/rag/embedding.py b/rag/db/embedding.py
similarity index 100%
rename from rag/embedding.py
rename to rag/db/embedding.py
diff --git a/rag/main.py b/rag/main.py
index ca93f27..288d84d 100644
--- a/rag/main.py
+++ b/rag/main.py
@@ -1,9 +1,11 @@
 import os
+import sys
+sys.path.append(os.path.abspath('.'))
 
-from admin import app, logger
-from intent import *
-from vecdb import *
-from configs import necessary_files
+from rag.api.admin import app, logger
+from rag.api.config import necessary_files
+from rag.services.intent import *
+from rag.services.vecdb import *
 
 def assert_resource(path: str):
     assert os.path.exists(path), '{} 不存在'.format(file)
@@ -14,9 +16,11 @@ for file in necessary_files.values():
 if __name__ == '__main__':
     from gevent import pywsgi
     import yaml
+    
     config: dict = yaml.load(open('./config/vecdb.yml'), Loader=yaml.Loader)
     addr = config.get('addr', '127.0.0.1')
     port = int(config.get('port', 8081))
+    
     server = pywsgi.WSGIServer((addr, port), app)
     logger.info('RAG 系统运行在 http://{}:{}'.format(addr, port))
     server.serve_forever()
\ No newline at end of file
diff --git a/rag/model/__init__.py b/rag/model/__init__.py
new file mode 100644
index 0000000..450746d
--- /dev/null
+++ b/rag/model/__init__.py
@@ -0,0 +1,5 @@
+from .enn import LinearEnn
+
+__all__ = [
+    LinearEnn
+]
\ No newline at end of file
diff --git a/rag/model/enn.py b/rag/model/enn.py
new file mode 100644
index 0000000..09c649a
--- /dev/null
+++ b/rag/model/enn.py
@@ -0,0 +1,88 @@
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+
+class LinearEnn(nn.Module):
+    in_dim: int
+    out_dim: int
+    alpha_kl: float
+    def __init__(self, in_dim: int, out_dim: int, focal: int, alpha_kl: float):
+        super().__init__()
+        self.in_dim = in_dim
+        self.out_dim = out_dim
+        self.alpha_kl = alpha_kl
+        self.focal = focal
+        self.classifier = nn.Sequential(
+            nn.Linear(in_dim, out_dim),
+            nn.ELU(),
+        )
+    
+    def forward(self, inputs: torch.FloatTensor) -> tuple[torch.FloatTensor, torch.FloatTensor]:
+        logits = self.classifier(inputs)
+        evidence = torch.exp(logits)
+        prob = F.normalize(evidence + 1, p=1, dim=1)
+        return evidence, prob
+
+    def criterion(self, evidence: torch.FloatTensor, label: torch.LongTensor) -> torch.FloatTensor:
+        if len(label.shape) == 1:
+            label = F.one_hot(label, self.out_dim)
+        alpha = evidence + 1
+        alpha_0 = alpha.sum(1).unsqueeze(-1).repeat(1, self.out_dim)
+        loss_ece = torch.sum(label * (torch.digamma(alpha_0) - torch.digamma(alpha)), dim=1)
+        loss_ece = torch.mean(loss_ece)
+        if self.alpha_kl > 0:
+            tilde_alpha = label + (1 - label) * alpha
+            uncertainty_alpha = torch.ones_like(tilde_alpha).cuda()
+            estimate_dirichlet = torch.distributions.Dirichlet(tilde_alpha)
+            uncertainty_dirichlet = torch.distributions.Dirichlet(uncertainty_alpha)
+            kl = torch.distributions.kl_divergence(estimate_dirichlet, uncertainty_dirichlet)
+            loss_kl = torch.mean(kl)
+        else:
+            loss_kl = 0
+        return loss_ece + self.alpha_kl * loss_kl
+
+    def predict(self, inputs: torch.FloatTensor | list[list[float]] | np.ndarray) -> tuple[torch.FloatTensor, torch.FloatTensor]:
+        """
+        返回每个类别的预测概率 和 当前的预测的不确定度 uncertainty
+        """
+        if not isinstance(inputs, torch.FloatTensor):
+            inputs = torch.FloatTensor(inputs)
+        with torch.no_grad():
+            evidence, prob = self.forward(inputs)
+            alpha = evidence + 1
+            S = alpha.sum(dim=1)
+            u = self.out_dim / S
+            
+        return prob, u
+
+
+def train_enn(enn_model: LinearEnn, embedding: np.ndarray | torch.FloatTensor, labels: np.ndarray | torch.LongTensor, bs: int = 64, lr: float = 1e-3, epoch: int = 100):
+    optimizer = torch.optim.AdamW(enn_model.parameters(), lr=lr)
+
+    sample_num = len(embedding)
+    sample_indice = np.arange(sample_num)
+    bs_num = int(np.ceil(sample_num / bs))
+
+    training_losses = []
+
+    for i in range(epoch):
+        alpha_kl = min(0.9, i / 10)
+        np.random.shuffle(sample_indice)    
+        train_loss = 0
+        for bs_i in range(bs_num):
+            start = bs_i * bs
+            end = min(sample_num, start + bs)
+            data_indice = sample_indice[start: end]
+            data = torch.FloatTensor(embedding[data_indice])
+            label = torch.LongTensor(labels[data_indice])
+            evidence, prob = enn_model(data)
+            loss = enn_model.criterion(evidence, label)
+            train_loss += loss.item()
+            
+            optimizer.zero_grad()
+            loss.backward()
+            optimizer.step()
+
+        training_losses.append(train_loss / bs_num)
\ No newline at end of file
diff --git a/rag/services/__init__.py b/rag/services/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/rag/intent.py b/rag/services/intent.py
similarity index 74%
rename from rag/intent.py
rename to rag/services/intent.py
index 26328dc..e287fc2 100644
--- a/rag/intent.py
+++ b/rag/services/intent.py
@@ -2,12 +2,14 @@ from flask import Flask, request, jsonify
 import numpy as np
 import joblib
 import json
-from sklearn.linear_model import LogisticRegression
+import torch
 
-from embedding import embedding
-from constant import StatusCode, MsgCode
-from admin import app
-from configs import necessary_files
+
+from rag.db.embedding import embedding
+from rag.api.constant import StatusCode, MsgCode
+from rag.api.admin import app
+from rag.api.config import necessary_files
+from rag.model.enn import LinearEnn, train_enn
 
 import sys
 import os
@@ -17,16 +19,22 @@ from prompt import PromptEngine
 
 class IntentRecogition:
     def __init__(self) -> None:
-        self.embed_intent_classificator = joblib.load(necessary_files['intent-classifier'])
         self.engine = PromptEngine(necessary_files['intent-story'])
+        self.classifier = LinearEnn(in_dim=768, out_dim=7, focal=0, alpha_kl=0)
+        self.classifier.load_state_dict(torch.load(necessary_files['intent-classifier']))
     
     def get_intent_recogition(self, query: str) -> dict:
         query_embed = embedding.embed_documents([query])
-        result_id = self.embed_intent_classificator.predict(query_embed)[0]
-        result_id = int(result_id)
+        prob, u = self.classifier.predict(query_embed)
+        
+        result_id = prob.argmax(dim=1)
+        u = u.item()
+        
+        result_id = int(result_id.item())
         return {
-            'id': result_id,
-            'name': self.engine.id2intent[result_id]
+            'id': int(result_id),
+            'name': self.engine.id2intent[result_id],
+            'uncertainty': float(u)
         }
 
 intent_recogition = IntentRecogition()
@@ -34,7 +42,7 @@ intent_recogition = IntentRecogition()
 @app.route('/intent/reload-embedding-mapping', methods=['post'])
 def reload_embedding_mapping():
     try:
-        intent_recogition.embed_intent_classificator = joblib.load(necessary_files['intent-classifier'])
+        intent_recogition.classifier.load_state_dict(torch.load(necessary_files['intent-classifier']))
     except Exception as e:
         response = jsonify({
             'code': StatusCode.process_error.value,
@@ -56,21 +64,18 @@ def reload_embedding_mapping():
 def retrain_embedding_mapping():
     engine = PromptEngine(necessary_files['intent-story'])
     engine.merge_stories_from_yml(necessary_files['issue-story'])
-    model = LogisticRegression()
     sentences = []
     labels = []
     for story in engine.stories:
         sentences.append(story.message)
         labels.append(engine.intent2id[story.intent])
-    
     try:
         labels = np.array(labels)
         embed = embedding.embed_documents(sentences)
-        model.fit(embed, labels)
+        enn_model = intent_recogition.classifier
+        train_enn(enn_model, embed, labels, bs=64, lr=1e-3, epoch=100)
+        torch.save(enn_model.state_dict(), necessary_files['intent-classifier'])
         
-        intent_recogition.engine = engine
-        intent_recogition.embed_intent_classificator = model
-        joblib.dump(model, necessary_files['intent-classifier'])    
     except Exception as e:
         response = jsonify({
             'code': StatusCode.process_error.value,
@@ -80,7 +85,6 @@ def retrain_embedding_mapping():
         response.status_code = StatusCode.success.value
         return response
 
-
     response = jsonify({
         'code': StatusCode.success.value,
         'data': 'save data to ' + necessary_files['intent-classifier'],
diff --git a/rag/vecdb.py b/rag/services/vecdb.py
similarity index 88%
rename from rag/vecdb.py
rename to rag/services/vecdb.py
index 885cc84..9932657 100644
--- a/rag/vecdb.py
+++ b/rag/services/vecdb.py
@@ -1,10 +1,10 @@
 from flask import Flask, request, jsonify
 import json
 
-from embedding import db
-from constant import StatusCode, MsgCode
-from url_mapping import urlmapping
-from admin import app
+from rag.api.admin import app
+from rag.db.embedding import db
+from rag.api.constant import StatusCode, MsgCode
+from rag.utils.url_mapping import urlmapping
 
 @app.route('/vecdb/similarity_search_with_score', methods=['post'])
 def post_similarity_search_with_score():
@@ -31,13 +31,14 @@ def post_similarity_search_with_score():
         source = meta.get('source', '')
         if len(source) > 0:
             source = urlmapping.url_from_mapping(source)
+            
         result_data.append({
             'content': page_content.strip(),
             'meta': meta,
             'source': source,
             'score': float(score)
         })
-
+    
     response = jsonify({
         'code': StatusCode.success.value,
         'data': result_data,
diff --git a/rag/utils/__init__.py b/rag/utils/__init__.py
new file mode 100644
index 0000000..95db8bf
--- /dev/null
+++ b/rag/utils/__init__.py
@@ -0,0 +1,3 @@
+from .url_mapping import urlmapping
+
+__all__ = [ urlmapping ]
\ No newline at end of file
diff --git a/rag/url_mapping.py b/rag/utils/url_mapping.py
similarity index 82%
rename from rag/url_mapping.py
rename to rag/utils/url_mapping.py
index bd6b274..2d2ad9f 100644
--- a/rag/url_mapping.py
+++ b/rag/utils/url_mapping.py
@@ -13,6 +13,7 @@ class UrlMappingRegister:
         return lambda func: register(start, func)
     
     def url_from_mapping(self, source: str) -> str:
+        source = source.lstrip('.').lstrip('/')
         for pattern in self.startsWith_patterns:
             func = self.startsWith_patterns[pattern]
             if source.startswith(pattern):
@@ -32,6 +33,7 @@ def kirigaya_cn(source: str) -> str:
     template = f'https://kirigaya.cn/blog/article?seq={article_id}'
     return template
 
+
 # 样例： docs/digital-document/guide/quick-start.md
 # 目标： https://sterben.nitcloud.cn/zh/guide/quick-start.html
 @urlmapping.startsWith('docs/digital-document')
@@ -42,6 +44,16 @@ def digital_document(source: str) -> str:
     return router
 
 
+# 样例： docs/digital-issue/issue-2/issue.md
+# 目标： https://github.com/Digital-EDA/Digital-IDE/issues/2
+@urlmapping.startsWith('docs/digital-issue')
+def digital_document(source: str) -> str:
+    parts = source.split('/')
+    issue_id = parts[2].split('-')[-1]
+    router = f'https://github.com/Digital-EDA/Digital-IDE/issues/{issue_id}'
+    return router
+
+
 if __name__ == '__main__':
     print(kirigaya_cn('docs/kirigaya.cn/129.md'))
     print(kirigaya_cn('docs/kirigaya.cn/21.md'))
diff --git a/test/suite/rag.test.js b/test/suite/rag.test.js
index a27a3ef..14749bb 100644
--- a/test/suite/rag.test.js
+++ b/test/suite/rag.test.js
@@ -41,7 +41,7 @@ suite('test intent recogition', () => {
         { input: '我的反撤回还能用', expect: 'others' },
         { input: '因为这是养蛊的虚拟机，放了些国产垃圾软件，得用国产流氓之王才能镇得住他们', expect: 'others' },
         { input: '你咋装了个360', expect: 'others' },
-        { input: '？？？', expect: 'others' },
+        { input: '？？？', expect: 'expression,others' },
     ];
 
     for (const s of intent_suites) {
diff --git a/yarn.lock b/yarn.lock
index 6628a92..0fd6d60 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -4,7 +4,7 @@
 
 "@pm2/agent@~2.0.0":
   version "2.0.3"
-  resolved "https://registry.npmjs.org/@pm2/agent/-/agent-2.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/@pm2/agent/-/agent-2.0.3.tgz#6b47fda837f185864767fe1e048f61d1de31fc45"
   integrity sha512-xkqqCoTf5VsciMqN0vb9jthW7olVAi4KRFNddCc7ZkeJZ3i8QwZANr4NSH2H5DvseRFHq7MiPspRY/EWAFWWTg==
   dependencies:
     async "~3.2.0"
@@ -23,7 +23,7 @@
 
 "@pm2/io@~6.0.0":
   version "6.0.0"
-  resolved "https://registry.npmjs.org/@pm2/io/-/io-6.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/@pm2/io/-/io-6.0.0.tgz#ad7222e7c6975664028fe727ff7b67e9b661eacc"
   integrity sha512-sKUEgZoQ5/jRwTyMB1I7u2wXL6dG0j/F/M4ANJ7dJCApfW8nWC0RElMW2siEKvZ79iplIPAaWV27oyBoerEflw==
   dependencies:
     async "~2.6.1"
@@ -37,7 +37,7 @@
 
 "@pm2/js-api@~0.8.0":
   version "0.8.0"
-  resolved "https://registry.npmjs.org/@pm2/js-api/-/js-api-0.8.0.tgz"
+  resolved "https://registry.yarnpkg.com/@pm2/js-api/-/js-api-0.8.0.tgz#d1b8aff562dd34befa3cb30fe28e08c9f9743abc"
   integrity sha512-nmWzrA/BQZik3VBz+npRcNIu01kdBhWL0mxKmP1ciF/gTcujPTQqt027N9fc1pK9ERM8RipFhymw7RcmCyOEYA==
   dependencies:
     async "^2.6.3"
@@ -48,7 +48,7 @@
 
 "@pm2/pm2-version-check@latest":
   version "1.0.4"
-  resolved "https://registry.npmjs.org/@pm2/pm2-version-check/-/pm2-version-check-1.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/@pm2/pm2-version-check/-/pm2-version-check-1.0.4.tgz#cf97fbb14b0eca95430ca05eedccbd2683806e43"
   integrity sha512-SXsM27SGH3yTWKc2fKR4SYNxsmnvuBQ9dd6QHtEWmiZ/VqaOYPAIlS8+vMcn27YLtAEBGvNRSh3TPNvtjZgfqA==
   dependencies:
     debug "^4.3.1"
@@ -122,7 +122,7 @@
 
 "@tootallnate/quickjs-emscripten@^0.23.0":
   version "0.23.0"
-  resolved "https://registry.npmjs.org/@tootallnate/quickjs-emscripten/-/quickjs-emscripten-0.23.0.tgz"
+  resolved "https://registry.yarnpkg.com/@tootallnate/quickjs-emscripten/-/quickjs-emscripten-0.23.0.tgz#db4ecfd499a9765ab24002c3b696d02e6d32a12c"
   integrity sha512-C5Mc6rdnsaJDjO3UpGW/CQTHtCKaYlScZTly4JIu97Jxo/odCiH0ITnDXSJPTOrEKk/ycSZ0AOgTmkDtkOsvIA==
 
 "@types/node@*", "@types/node@^20.12.12":
@@ -154,7 +154,7 @@ accepts@~1.3.5:
 
 agent-base@^7.0.2, agent-base@^7.1.0, agent-base@^7.1.1:
   version "7.1.1"
-  resolved "https://registry.npmjs.org/agent-base/-/agent-base-7.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/agent-base/-/agent-base-7.1.1.tgz#bdbded7dfb096b751a2a087eeeb9664725b2e317"
   integrity sha512-H0TSyFNDMomMNJQBn8wFV5YC/2eJ+VXECwOadZJT554xP6cODZHPX3H9QMQECxvrgiSOP1pHjy1sMWQVYJOUOA==
   dependencies:
     debug "^4.3.4"
@@ -171,14 +171,14 @@ ajv@8.12.0:
 
 amp-message@~0.1.1:
   version "0.1.2"
-  resolved "https://registry.npmjs.org/amp-message/-/amp-message-0.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/amp-message/-/amp-message-0.1.2.tgz#a78f1c98995087ad36192a41298e4db49e3dfc45"
   integrity sha512-JqutcFwoU1+jhv7ArgW38bqrE+LQdcRv4NxNw0mp0JHQyB6tXesWRjtYKlDgHRY2o3JE5UTaBGUK8kSWUdxWUg==
   dependencies:
     amp "0.3.1"
 
 amp@0.3.1, amp@~0.3.1:
   version "0.3.1"
-  resolved "https://registry.npmjs.org/amp/-/amp-0.3.1.tgz"
+  resolved "https://registry.yarnpkg.com/amp/-/amp-0.3.1.tgz#6adf8d58a74f361e82c1fa8d389c079e139fc47d"
   integrity sha512-OwIuC4yZaRogHKiuU5WlMR5Xk/jAcpPtawWL05Gj8Lvm2F6mwoJt4O/bHI+DHwG79vWd+8OFYM4/BzYqyRd3qw==
 
 ansi-align@^3.0.1:
@@ -195,7 +195,7 @@ ansi-colors@4.1.1:
 
 ansi-colors@^4.1.1:
   version "4.1.3"
-  resolved "https://registry.npmjs.org/ansi-colors/-/ansi-colors-4.1.3.tgz"
+  resolved "https://registry.yarnpkg.com/ansi-colors/-/ansi-colors-4.1.3.tgz#37611340eb2243e70cc604cad35d63270d48781b"
   integrity sha512-/6w/C21Pm1A7aZitlI5Ni/2J6FFQN8i1Cvz3kHABAAbw93v/NlvKdVOqz7CCWz/3iv/JplRSEEZ83XION15ovw==
 
 ansi-regex@^5.0.1:
@@ -250,21 +250,21 @@ assertion-error@^1.1.0:
 
 ast-types@^0.13.4:
   version "0.13.4"
-  resolved "https://registry.npmjs.org/ast-types/-/ast-types-0.13.4.tgz"
+  resolved "https://registry.yarnpkg.com/ast-types/-/ast-types-0.13.4.tgz#ee0d77b343263965ecc3fb62da16e7222b2b6782"
   integrity sha512-x1FCFnFifvYDDzTaLII71vG5uvDwgtmDTEVWAxrgeiR8VjMONcCXJx7E+USjDtHlwFmt9MysbqgF9b9Vjr6w+w==
   dependencies:
     tslib "^2.0.1"
 
 async@^2.6.3, async@~2.6.1:
   version "2.6.4"
-  resolved "https://registry.npmjs.org/async/-/async-2.6.4.tgz"
+  resolved "https://registry.yarnpkg.com/async/-/async-2.6.4.tgz#706b7ff6084664cd7eae713f6f965433b5504221"
   integrity sha512-mzo5dfJYwAn29PeiJ0zvwTo04zj8HDJj0Mn8TD7sno7q12prdbnasKJHhkm2c1LgrhlJ0teaea8860oxi51mGA==
   dependencies:
     lodash "^4.17.14"
 
 async@^3.2.0, async@~3.2.0:
   version "3.2.5"
-  resolved "https://registry.npmjs.org/async/-/async-3.2.5.tgz"
+  resolved "https://registry.yarnpkg.com/async/-/async-3.2.5.tgz#ebd52a8fdaf7a2289a24df399f8d8485c8a46b66"
   integrity sha512-baNZyqaaLhyLVKm/DlvdW051MSgO6b8eVfIezl9E5PqWxFgzLm/wQntEW4zOytVburDEr0JlALEpdOFwvErLsg==
 
 asynckit@^0.4.0:
@@ -295,7 +295,7 @@ balanced-match@^1.0.0:
 
 basic-ftp@^5.0.2:
   version "5.0.5"
-  resolved "https://registry.npmjs.org/basic-ftp/-/basic-ftp-5.0.5.tgz"
+  resolved "https://registry.yarnpkg.com/basic-ftp/-/basic-ftp-5.0.5.tgz#14a474f5fffecca1f4f406f1c26b18f800225ac0"
   integrity sha512-4Bcg1P8xhUuqcii/S0Z9wiHIrQVPMermM1any+MX5GeGD7faD3/msQUDGLol9wOcz4/jbg/WJnGqoJF6LiBdtg==
 
 binary-extensions@^2.0.0:
@@ -305,12 +305,12 @@ binary-extensions@^2.0.0:
 
 blessed@0.1.81:
   version "0.1.81"
-  resolved "https://registry.npmjs.org/blessed/-/blessed-0.1.81.tgz"
+  resolved "https://registry.yarnpkg.com/blessed/-/blessed-0.1.81.tgz#f962d687ec2c369570ae71af843256e6d0ca1129"
   integrity sha512-LoF5gae+hlmfORcG1M5+5XZi4LBmvlXTzwJWzUlPryN/SJdSflZvROM2TwkT0GMpq7oqT48NRd4GS7BiVBc5OQ==
 
 bodec@^0.1.0:
   version "0.1.0"
-  resolved "https://registry.npmjs.org/bodec/-/bodec-0.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/bodec/-/bodec-0.1.0.tgz#bc851555430f23c9f7650a75ef64c6a94c3418cc"
   integrity sha512-Ylo+MAo5BDUq1KA3f3R/MFhh+g8cnHmo8bz3YPGhI1znrMaf77ol1sfvYJzsw3nTE+Y2GryfDxBaR+AqpAkEHQ==
 
 boxen@7.0.0:
@@ -356,7 +356,7 @@ browser-stdout@1.3.1:
 
 buffer-from@^1.0.0:
   version "1.1.2"
-  resolved "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/buffer-from/-/buffer-from-1.1.2.tgz#2b146a6fd72e80b4f55d255f35ed59a3a9a41bd5"
   integrity sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==
 
 bytes@3.0.0:
@@ -418,7 +418,7 @@ chalk-template@0.4.0:
 
 chalk@3.0.0, chalk@~3.0.0:
   version "3.0.0"
-  resolved "https://registry.npmjs.org/chalk/-/chalk-3.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/chalk/-/chalk-3.0.0.tgz#3f73c2bf526591f574cc492c51e2456349f844e4"
   integrity sha512-4D3B6Wf41KOYRFdszmDqMCGq5VV/uMAB273JILmO+3jAlh8X4qDtdtgCR3fxtbLEMzSx22QdhnDcJvu2u1fVwg==
   dependencies:
     ansi-styles "^4.1.0"
@@ -444,7 +444,7 @@ chalk@^5.0.1:
 
 charm@~0.1.1:
   version "0.1.2"
-  resolved "https://registry.npmjs.org/charm/-/charm-0.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/charm/-/charm-0.1.2.tgz#06c21eed1a1b06aeb67553cdc53e23274bac2296"
   integrity sha512-syedaZ9cPe7r3hoQA9twWYKu5AIyCswN5+szkmPBe9ccdLrj4bYaCnLVPTLd2kgVRc7+zoX4tyPgRnFKCj5YjQ==
 
 check-error@^1.0.2:
@@ -471,7 +471,7 @@ chokidar@3.5.3:
 
 chokidar@^3.5.3:
   version "3.6.0"
-  resolved "https://registry.npmjs.org/chokidar/-/chokidar-3.6.0.tgz"
+  resolved "https://registry.yarnpkg.com/chokidar/-/chokidar-3.6.0.tgz#197c6cc669ef2a8dc5e7b4d97ee4e092c3eb0d5b"
   integrity sha512-7VT13fmjotKpGipCW9JEQAusEPE+Ei8nl6/g4FBAmIm0GOOLMua9NDDo/DWp0ZAxCr3cPq5ZpBqmPAQgDda2Pw==
   dependencies:
     anymatch "~3.1.2"
@@ -491,7 +491,7 @@ cli-boxes@^3.0.0:
 
 cli-tableau@^2.0.0:
   version "2.0.1"
-  resolved "https://registry.npmjs.org/cli-tableau/-/cli-tableau-2.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/cli-tableau/-/cli-tableau-2.0.1.tgz#baa78d83e08a2d7ab79b7dad9406f0254977053f"
   integrity sha512-he+WTicka9cl0Fg/y+YyxcN6/bfQ/1O3QmgxRXDhABKqLzvoOSM4fMzp39uMyLBulAFuywD2N7UaoQE7WaADxQ==
   dependencies:
     chalk "3.0.0"
@@ -535,7 +535,7 @@ combined-stream@^1.0.8:
 
 commander@2.15.1:
   version "2.15.1"
-  resolved "https://registry.npmjs.org/commander/-/commander-2.15.1.tgz"
+  resolved "https://registry.yarnpkg.com/commander/-/commander-2.15.1.tgz#df46e867d0fc2aec66a34662b406a9ccafff5b0f"
   integrity sha512-VlfT9F3V0v+jr4yxPc5gg9s62/fIVWsd2Bk2iD435um1NlGMYdVCq+MjcXnhYq2icNOizHr1kK+5TI6H0Hy0ag==
 
 compressible@~2.0.16:
@@ -570,7 +570,7 @@ content-disposition@0.5.2:
 
 croner@~4.1.92:
   version "4.1.97"
-  resolved "https://registry.npmjs.org/croner/-/croner-4.1.97.tgz"
+  resolved "https://registry.yarnpkg.com/croner/-/croner-4.1.97.tgz#6e373dc7bb3026fab2deb0d82685feef20796766"
   integrity sha512-/f6gpQuxDaqXu+1kwQYSckUglPaOrHdbIlBAu0YuW8/Cdb45XwXYNUBXg3r/9Mo6n540Kn/smKcZWko5x99KrQ==
 
 cross-spawn@^7.0.3:
@@ -584,7 +584,7 @@ cross-spawn@^7.0.3:
 
 culvert@^0.1.2:
   version "0.1.2"
-  resolved "https://registry.npmjs.org/culvert/-/culvert-0.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/culvert/-/culvert-0.1.2.tgz#9502f5f0154a2d5a22a023e79f71cc936fa6ef6f"
   integrity sha512-yi1x3EAWKjQTreYWeSd98431AV+IEE0qoDyOoaHJ7KJ21gv6HtBXHVLX74opVSGqcR8/AbjJBHAHpcOy2bj5Gg==
 
 d@1, d@^1.0.1, d@^1.0.2:
@@ -597,17 +597,17 @@ d@1, d@^1.0.1, d@^1.0.2:
 
 data-uri-to-buffer@^6.0.2:
   version "6.0.2"
-  resolved "https://registry.npmjs.org/data-uri-to-buffer/-/data-uri-to-buffer-6.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/data-uri-to-buffer/-/data-uri-to-buffer-6.0.2.tgz#8a58bb67384b261a38ef18bea1810cb01badd28b"
   integrity sha512-7hvf7/GW8e86rW0ptuwS3OcBGDjIi6SZva7hCyWC0yYry2cOPmLIjXAUHI6DK2HsnwJd9ifmt57i8eV2n4YNpw==
 
 dayjs@~1.11.5:
   version "1.11.11"
-  resolved "https://registry.npmjs.org/dayjs/-/dayjs-1.11.11.tgz"
+  resolved "https://registry.yarnpkg.com/dayjs/-/dayjs-1.11.11.tgz#dfe0e9d54c5f8b68ccf8ca5f72ac603e7e5ed59e"
   integrity sha512-okzr3f11N6WuqYtZSvm+F776mB41wRZMhKP+hc34YdW+KmtYYK9iqvHSwo2k9FEH3fhGXvOPV6yz2IcSrfRUDg==
 
 dayjs@~1.8.24:
   version "1.8.36"
-  resolved "https://registry.npmjs.org/dayjs/-/dayjs-1.8.36.tgz"
+  resolved "https://registry.yarnpkg.com/dayjs/-/dayjs-1.8.36.tgz#be36e248467afabf8f5a86bae0de0cdceecced50"
   integrity sha512-3VmRXEtw7RZKAf+4Tv1Ym9AGeo8r8+CjDi26x+7SYQil1UqtqdaokhzoEJohqlzt0m5kacJSDhJQkG/LWhpRBw==
 
 debug@2.6.9:
@@ -619,7 +619,7 @@ debug@2.6.9:
 
 debug@4, debug@^4.1.1, debug@^4.3.1, debug@^4.3.4, debug@~4.3.1:
   version "4.3.5"
-  resolved "https://registry.npmjs.org/debug/-/debug-4.3.5.tgz"
+  resolved "https://registry.yarnpkg.com/debug/-/debug-4.3.5.tgz#e83444eceb9fedd4a1da56d671ae2446a01a6e1e"
   integrity sha512-pt0bNEmneDIvdL1Xsd9oDQ/wrQRkXDT4AUWlNZNPKvW5x/jyO9VFXkJUP07vQ2upmw5PlaITaPKc31jK13V+jg==
   dependencies:
     ms "2.1.2"
@@ -633,7 +633,7 @@ debug@4.3.4:
 
 debug@^3.2.6:
   version "3.2.7"
-  resolved "https://registry.npmjs.org/debug/-/debug-3.2.7.tgz"
+  resolved "https://registry.yarnpkg.com/debug/-/debug-3.2.7.tgz#72580b7e9145fb39b6676f9c5e5fb100b934179a"
   integrity sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ==
   dependencies:
     ms "^2.1.1"
@@ -666,7 +666,7 @@ define-data-property@^1.1.4:
 
 degenerator@^5.0.0:
   version "5.0.1"
-  resolved "https://registry.npmjs.org/degenerator/-/degenerator-5.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/degenerator/-/degenerator-5.0.1.tgz#9403bf297c6dad9a1ece409b37db27954f91f2f5"
   integrity sha512-TllpMR/t0M5sqCXfj85i4XaAzxmS5tVA16dqvdkMwGmzI+dXLXnw3J+3Vdv7VKw+ThlTMboK6i9rnZ6Nntj5CQ==
   dependencies:
     ast-types "^0.13.4"
@@ -705,7 +705,7 @@ emoji-regex@^9.2.2:
 
 enquirer@2.3.6:
   version "2.3.6"
-  resolved "https://registry.npmjs.org/enquirer/-/enquirer-2.3.6.tgz"
+  resolved "https://registry.yarnpkg.com/enquirer/-/enquirer-2.3.6.tgz#2a7fe5dd634a1e4125a975ec994ff5456dc3734d"
   integrity sha512-yjNnPr315/FjS4zIsUxYguYUPP2e1NK4d7E7ZOLiyYCcbFBiTMyID+2wvm2w6+pZ/odMA7cRkjhsPbltwBOrLg==
   dependencies:
     ansi-colors "^4.1.1"
@@ -761,7 +761,7 @@ escape-string-regexp@4.0.0, escape-string-regexp@^4.0.0:
 
 escodegen@^2.1.0:
   version "2.1.0"
-  resolved "https://registry.npmjs.org/escodegen/-/escodegen-2.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/escodegen/-/escodegen-2.1.0.tgz#ba93bbb7a43986d29d6041f99f5262da773e2e17"
   integrity sha512-2NlIDTwUWJN0mRPQOdtQBzbUHvdGY2P1VXSyU83Q3xKxM7WHX2Ql8dKq782Q9TgQUNOLEzEYu9bzLNj1q88I5w==
   dependencies:
     esprima "^4.0.1"
@@ -782,17 +782,17 @@ esniff@^2.0.1:
 
 esprima@^4.0.1:
   version "4.0.1"
-  resolved "https://registry.npmjs.org/esprima/-/esprima-4.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/esprima/-/esprima-4.0.1.tgz#13b04cdb3e6c5d19df91ab6987a8695619b0aa71"
   integrity sha512-eGuFFw7Upda+g4p+QHvnW0RyTX/SVeJBDM/gCtMARO0cLuT2HcEKnTPvhjV6aGeqrCB/sbNop0Kszm0jsaWU4A==
 
 estraverse@^5.2.0:
   version "5.3.0"
-  resolved "https://registry.npmjs.org/estraverse/-/estraverse-5.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-5.3.0.tgz#2eea5290702f26ab8fe5370370ff86c965d21123"
   integrity sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==
 
 esutils@^2.0.2:
   version "2.0.3"
-  resolved "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/esutils/-/esutils-2.0.3.tgz#74d2eb4de0b8da1293711910d50775b9b710ef64"
   integrity sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==
 
 event-emitter@^0.3.5:
@@ -805,17 +805,17 @@ event-emitter@^0.3.5:
 
 eventemitter2@5.0.1, eventemitter2@~5.0.1:
   version "5.0.1"
-  resolved "https://registry.npmjs.org/eventemitter2/-/eventemitter2-5.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/eventemitter2/-/eventemitter2-5.0.1.tgz#6197a095d5fb6b57e8942f6fd7eaad63a09c9452"
   integrity sha512-5EM1GHXycJBS6mauYAbVKT1cVs7POKWb2NXD4Vyt8dDqeZa7LaDK1/sjtL+Zb0lzTpSNil4596Dyu97hz37QLg==
 
 eventemitter2@^6.3.1:
   version "6.4.9"
-  resolved "https://registry.npmjs.org/eventemitter2/-/eventemitter2-6.4.9.tgz"
+  resolved "https://registry.yarnpkg.com/eventemitter2/-/eventemitter2-6.4.9.tgz#41f2750781b4230ed58827bc119d293471ecb125"
   integrity sha512-JEPTiaOt9f04oa6NOkc4aH+nVp5I3wEjpHbIPqfgCdD5v5bUzy7xQqwcVO2aDQgOWhI28da57HksMrzK9HlRxg==
 
 eventemitter2@~0.4.14:
   version "0.4.14"
-  resolved "https://registry.npmjs.org/eventemitter2/-/eventemitter2-0.4.14.tgz"
+  resolved "https://registry.yarnpkg.com/eventemitter2/-/eventemitter2-0.4.14.tgz#8f61b75cde012b2e9eb284d4545583b5643b61ab"
   integrity sha512-K7J4xq5xAD5jHsGM5ReWXRTFa3JRGofHiMcVgQ8PRwgWxzjHpMWCIzsmyf60+mh8KLsqYPcjUMa0AC4hd6lPyQ==
 
 execa@^5.1.1:
@@ -842,7 +842,7 @@ ext@^1.7.0:
 
 extrareqp2@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/extrareqp2/-/extrareqp2-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/extrareqp2/-/extrareqp2-1.0.0.tgz#aaf8ad1495d723f71276b0eab041c061aa21f035"
   integrity sha512-Gum0g1QYb6wpPJCVypWP3bbIuaibcFiJcpuPM10YSXp/tzqi84x9PJageob+eN4xVRIOto4wjSGNLyMD54D2xA==
   dependencies:
     follow-redirects "^1.14.0"
@@ -854,7 +854,7 @@ fast-deep-equal@^3.1.1:
 
 fast-json-patch@^3.0.0-1:
   version "3.1.1"
-  resolved "https://registry.npmjs.org/fast-json-patch/-/fast-json-patch-3.1.1.tgz"
+  resolved "https://registry.yarnpkg.com/fast-json-patch/-/fast-json-patch-3.1.1.tgz#85064ea1b1ebf97a3f7ad01e23f9337e72c66947"
   integrity sha512-vf6IHUX2SBcA+5/+4883dsIjpBTqmfBjmYiWK1savxQmFk4JfBMLa7ynTYOs1Rolp/T1betJxHiGD3g1Mn8lUQ==
 
 fast-url-parser@1.1.3:
@@ -866,7 +866,7 @@ fast-url-parser@1.1.3:
 
 fclone@1.0.11, fclone@~1.0.11:
   version "1.0.11"
-  resolved "https://registry.npmjs.org/fclone/-/fclone-1.0.11.tgz"
+  resolved "https://registry.yarnpkg.com/fclone/-/fclone-1.0.11.tgz#10e85da38bfea7fc599341c296ee1d77266ee640"
   integrity sha512-GDqVQezKzRABdeqflsgMr7ktzgF9CyS+p2oe0jJqUY6izSSbhPIQJDpoU4PtGcD7VPM9xh/dVrTu6z1nwgmEGw==
 
 fill-range@^7.1.1:
@@ -921,7 +921,7 @@ fs-extra@^10.0.0:
 
 fs-extra@^11.2.0:
   version "11.2.0"
-  resolved "https://registry.npmjs.org/fs-extra/-/fs-extra-11.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-11.2.0.tgz#e70e17dfad64232287d01929399e0ea7c86b0e5b"
   integrity sha512-PmDi3uwK5nFuXh7XDTlVnS17xJS7vW36is2+w3xcv8SVxiB4NyATf4ctkVY5bkSjX0Y4nbvZCq1/EjtEyr9ktw==
   dependencies:
     graceful-fs "^4.2.0"
@@ -976,7 +976,7 @@ get-stream@^6.0.0:
 
 get-uri@^6.0.1:
   version "6.0.3"
-  resolved "https://registry.npmjs.org/get-uri/-/get-uri-6.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/get-uri/-/get-uri-6.0.3.tgz#0d26697bc13cf91092e519aa63aa60ee5b6f385a"
   integrity sha512-BzUrJBS9EcUb4cFol8r4W3v1cPsSyajLSthNkz5BxbpDcHN5tIrM10E2eNvfnvBn3DaT3DUgx0OpsBKkaOpanw==
   dependencies:
     basic-ftp "^5.0.2"
@@ -986,12 +986,12 @@ get-uri@^6.0.1:
 
 git-node-fs@^1.0.0:
   version "1.0.0"
-  resolved "https://registry.npmjs.org/git-node-fs/-/git-node-fs-1.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/git-node-fs/-/git-node-fs-1.0.0.tgz#49b215e242ebe43aa4c7561bbba499521752080f"
   integrity sha512-bLQypt14llVXBg0S0u8q8HmU7g9p3ysH+NvVlae5vILuUvs759665HvmR5+wb04KjHyjFcDRxdYb4kyNnluMUQ==
 
 git-sha1@^0.1.2:
   version "0.1.2"
-  resolved "https://registry.npmjs.org/git-sha1/-/git-sha1-0.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/git-sha1/-/git-sha1-0.1.2.tgz#599ac192b71875825e13a445f3a6e05118c2f745"
   integrity sha512-2e/nZezdVlyCopOCYHeW0onkbZg7xP1Ad6pndPy1rCygeRykefUS6r7oA5cJRGEFvseiaz5a/qUHFVX1dd6Isg==
 
 glob-parent@~5.1.2:
@@ -1079,7 +1079,7 @@ he@1.2.0:
 
 http-proxy-agent@^7.0.0:
   version "7.0.2"
-  resolved "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-7.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/http-proxy-agent/-/http-proxy-agent-7.0.2.tgz#9a8b1f246866c028509486585f62b8f2c18c270e"
   integrity sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==
   dependencies:
     agent-base "^7.1.0"
@@ -1087,7 +1087,7 @@ http-proxy-agent@^7.0.0:
 
 https-proxy-agent@^7.0.2:
   version "7.0.4"
-  resolved "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/https-proxy-agent/-/https-proxy-agent-7.0.4.tgz#8e97b841a029ad8ddc8731f26595bad868cb4168"
   integrity sha512-wlwpilI7YdjSkWaQ/7omYBMTliDcmCN8OLihO6I9B86g06lMyAoqgoDpV0XqoaPOKj+0DIdAvnsWfyAAhmimcg==
   dependencies:
     agent-base "^7.0.2"
@@ -1100,7 +1100,7 @@ human-signals@^2.1.0:
 
 iconv-lite@^0.4.4:
   version "0.4.24"
-  resolved "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz"
+  resolved "https://registry.yarnpkg.com/iconv-lite/-/iconv-lite-0.4.24.tgz#2022b4b25fbddc21d2f524974a474aafe733908b"
   integrity sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==
   dependencies:
     safer-buffer ">= 2.1.2 < 3"
@@ -1130,7 +1130,7 @@ interpret@^1.0.0:
 
 ip-address@^9.0.5:
   version "9.0.5"
-  resolved "https://registry.npmjs.org/ip-address/-/ip-address-9.0.5.tgz"
+  resolved "https://registry.yarnpkg.com/ip-address/-/ip-address-9.0.5.tgz#117a960819b08780c3bd1f14ef3c1cc1d3f3ea5a"
   integrity sha512-zHtQzGojZXTwZTHQqra+ETKd4Sn3vgi7uBmlPoXVWZqYvuKmtI0l/VZTjqGmJY9x88GGOaZ9+G9ES8hC4T4X8g==
   dependencies:
     jsbn "1.1.0"
@@ -1243,7 +1243,7 @@ isexe@^2.0.0:
 
 js-git@^0.7.8:
   version "0.7.8"
-  resolved "https://registry.npmjs.org/js-git/-/js-git-0.7.8.tgz"
+  resolved "https://registry.yarnpkg.com/js-git/-/js-git-0.7.8.tgz#52fa655ab61877d6f1079efc6534b554f31e5444"
   integrity sha512-+E5ZH/HeRnoc/LW0AmAyhU+mNcWBzAKE+30+IDMLSLbbK+Tdt02AdkOKq9u15rlJsDEGFqtgckc8ZM59LhhiUA==
   dependencies:
     bodec "^0.1.0"
@@ -1260,7 +1260,7 @@ js-yaml@4.1.0, js-yaml@~4.1.0:
 
 jsbn@1.1.0:
   version "1.1.0"
-  resolved "https://registry.npmjs.org/jsbn/-/jsbn-1.1.0.tgz"
+  resolved "https://registry.yarnpkg.com/jsbn/-/jsbn-1.1.0.tgz#b01307cb29b618a1ed26ec79e911f803c4da0040"
   integrity sha512-4bYVV3aAMtDTTu4+xsDYa6sy9GyJ69/amsu9sYF2zqjiEoZA5xJi3BrfX3uY+/IekIu7MwdObdbDWpoZdBv3/A==
 
 json-schema-traverse@^1.0.0:
@@ -1270,7 +1270,7 @@ json-schema-traverse@^1.0.0:
 
 json-stringify-safe@^5.0.1:
   version "5.0.1"
-  resolved "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz#1296a2d58fd45f19a0f6ce01d65701e2c735b6eb"
   integrity sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA==
 
 jsonfile@^6.0.1:
@@ -1302,10 +1302,10 @@ knuth-shuffle@^1.0.8:
   resolved "https://registry.yarnpkg.com/knuth-shuffle/-/knuth-shuffle-1.0.8.tgz#929a467b0efd8d297bdcf318ca988a9f1037f80d"
   integrity sha512-IdC4Hpp+mx53zTt6VAGsAtbGM0g4BV9fP8tTcviCosSwocHcRDw9uG5Rnv6wLWckF4r72qeXFoK9NkvV1gUJCQ==
 
-lagrange.onebot@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.npmjs.org/lagrange.onebot/-/lagrange.onebot-1.0.0.tgz"
-  integrity sha512-KI5EJNiaXtnOdXTDdTaNNw0eZJVwwx5JIuaR1Ci0JhacYaxWd9FSXHEWbBFHFdZejv/uxyqv9yvDT1Zn4w3DIw==
+lagrange.onebot@^1.0.2:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/lagrange.onebot/-/lagrange.onebot-1.0.2.tgz#db3aef4b85a4f31c8b28c770c269ca60c09fbd14"
+  integrity sha512-0Plag0DbJp3q88pA0sa72Pzk2X1RZwU/TIxbxiiZ3vauNN3naJ7d2j6mc6fDVfORde94Cxn/BjPRZwUd2pbsaw==
   dependencies:
     "@ptkdev/logger" "^1.8.0"
     "@types/node" "^20.12.12"
@@ -1321,7 +1321,7 @@ lazy-seq@^1.0.0:
 
 lazy@~1.0.11:
   version "1.0.11"
-  resolved "https://registry.npmjs.org/lazy/-/lazy-1.0.11.tgz"
+  resolved "https://registry.yarnpkg.com/lazy/-/lazy-1.0.11.tgz#daa068206282542c088288e975c297c1ae77b690"
   integrity sha512-Y+CjUfLmIpoUCCRl0ub4smrYtGGr5AOa2AKOaWelGHOGz33X/Y/KizefGqbkwfz44+cnq/+9habclf8vOmu2LA==
 
 locate-path@^6.0.0:
@@ -1367,14 +1367,14 @@ lowdb@^1.0.0:
 
 lru-cache@^6.0.0:
   version "6.0.0"
-  resolved "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-6.0.0.tgz#6d6fe6570ebd96aaf90fcad1dafa3b2566db3a94"
   integrity sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==
   dependencies:
     yallist "^4.0.0"
 
 lru-cache@^7.14.1:
   version "7.18.3"
-  resolved "https://registry.npmjs.org/lru-cache/-/lru-cache-7.18.3.tgz"
+  resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-7.18.3.tgz#f793896e0fd0e954a59dfdd82f0773808df6aa89"
   integrity sha512-jumlc0BIUrS3qJGgIkWZsyfAM7NCWiBcCDhnd+3NNM5KbBmLTgHVfWBcg6W+rLUsIpzpERPsvwUP7CckAQSOoA==
 
 merge-stream@^2.0.0:
@@ -1439,7 +1439,7 @@ minimist@^1.2.0:
 
 mkdirp@1.0.4:
   version "1.0.4"
-  resolved "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz"
+  resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-1.0.4.tgz#3eb5ed62622756d79a5f0e2a221dfebad75c2f7e"
   integrity sha512-vVqVZQyf3WLx2Shd0qJ9xuvqgAyKPLAiqITEtqW0oIUjzo3PePDd6fW9iFz30ef7Ysp/oiWqbhszeGWW2T6Gzw==
 
 mocha@^10.4.0:
@@ -1470,7 +1470,7 @@ mocha@^10.4.0:
 
 module-details-from-path@^1.0.3:
   version "1.0.3"
-  resolved "https://registry.npmjs.org/module-details-from-path/-/module-details-from-path-1.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/module-details-from-path/-/module-details-from-path-1.0.3.tgz#114c949673e2a8a35e9d35788527aa37b679da2b"
   integrity sha512-ySViT69/76t8VhE1xXHK6Ch4NcDd26gx0MzKXLO+F7NOtnqH68d9zF94nT8ZWSxXh8ELOERsnJO/sWt1xZYw5A==
 
 ms@2.0.0:
@@ -1490,12 +1490,12 @@ ms@2.1.3, ms@^2.1.1:
 
 mute-stream@~0.0.4:
   version "0.0.8"
-  resolved "https://registry.npmjs.org/mute-stream/-/mute-stream-0.0.8.tgz"
+  resolved "https://registry.yarnpkg.com/mute-stream/-/mute-stream-0.0.8.tgz#1630c42b2251ff81e2a283de96a5497ea92e5e0d"
   integrity sha512-nnbWWOkoWyUsTjKrhgD0dcz22mdkSnpYqbEjIm2nhwhuxlSkpywJmBo8h0ZqJdkp73mb90SssHkN4rsRaBAfAA==
 
 needle@2.4.0:
   version "2.4.0"
-  resolved "https://registry.npmjs.org/needle/-/needle-2.4.0.tgz"
+  resolved "https://registry.yarnpkg.com/needle/-/needle-2.4.0.tgz#6833e74975c444642590e15a750288c5f939b57c"
   integrity sha512-4Hnwzr3mi5L97hMYeNl8wRW/Onhy4nUKR/lVemJ8gJedxxUyBLm9kkrDColJvoSfwi0jCNhD+xCdOtiGDQiRZg==
   dependencies:
     debug "^3.2.6"
@@ -1509,7 +1509,7 @@ negotiator@0.6.3:
 
 netmask@^2.0.2:
   version "2.0.2"
-  resolved "https://registry.npmjs.org/netmask/-/netmask-2.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/netmask/-/netmask-2.0.2.tgz#8b01a07644065d536383835823bc52004ebac5e7"
   integrity sha512-dBpDMdxv9Irdq66304OLfEmQ9tbNRFnFTuZiLo+bD+r332bBmMJ8GBLXklIXXgxd3+v9+KUnZaUR5PJMa75Gsg==
 
 next-tick@^1.1.0:
@@ -1553,7 +1553,7 @@ npm-run-path@^4.0.1:
 
 nssocket@0.6.0:
   version "0.6.0"
-  resolved "https://registry.npmjs.org/nssocket/-/nssocket-0.6.0.tgz"
+  resolved "https://registry.yarnpkg.com/nssocket/-/nssocket-0.6.0.tgz#59f96f6ff321566f33c70f7dbeeecdfdc07154fa"
   integrity sha512-a9GSOIql5IqgWJR3F/JXG4KpJTA3Z53Cj0MeMvGpglytB1nxE4PdFNC0jINe27CS7cGivoynwc054EzCcT3M3w==
   dependencies:
     eventemitter2 "~0.4.14"
@@ -1594,7 +1594,7 @@ p-locate@^5.0.0:
 
 pac-proxy-agent@^7.0.1:
   version "7.0.1"
-  resolved "https://registry.npmjs.org/pac-proxy-agent/-/pac-proxy-agent-7.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/pac-proxy-agent/-/pac-proxy-agent-7.0.1.tgz#6b9ddc002ec3ff0ba5fdf4a8a21d363bcc612d75"
   integrity sha512-ASV8yU4LLKBAjqIPMbrgtaKIvxQri/yh2OpI+S6hVa9JRkUI3Y3NPFbfngDtY7oFtSMD3w31Xns89mDa3Feo5A==
   dependencies:
     "@tootallnate/quickjs-emscripten" "^0.23.0"
@@ -1608,7 +1608,7 @@ pac-proxy-agent@^7.0.1:
 
 pac-resolver@^7.0.0:
   version "7.0.1"
-  resolved "https://registry.npmjs.org/pac-resolver/-/pac-resolver-7.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/pac-resolver/-/pac-resolver-7.0.1.tgz#54675558ea368b64d210fd9c92a640b5f3b8abb6"
   integrity sha512-5NPgf87AT2STgwa2ntRMr45jTKrYBGkVU36yT0ig/n/GMAa3oPqhZfIQ2kMEimReg0+t9kZViDVZ83qfVUlckg==
   dependencies:
     degenerator "^5.0.0"
@@ -1616,7 +1616,7 @@ pac-resolver@^7.0.0:
 
 pako@^0.2.5:
   version "0.2.9"
-  resolved "https://registry.npmjs.org/pako/-/pako-0.2.9.tgz"
+  resolved "https://registry.yarnpkg.com/pako/-/pako-0.2.9.tgz#f3f7522f4ef782348da8161bad9ecfd51bf83a75"
   integrity sha512-NUcwaKxUxWrZLpDG+z/xZaCgQITkA/Dv4V/T6bw7VON6l1Xz/VnrBqrYjZQ12TamKHzITTfOEIYUj48y2KXImA==
 
 path-exists@^4.0.0:
@@ -1666,14 +1666,14 @@ picomatch@^2.0.4, picomatch@^2.2.1:
 
 pidusage@^2.0.21:
   version "2.0.21"
-  resolved "https://registry.npmjs.org/pidusage/-/pidusage-2.0.21.tgz"
+  resolved "https://registry.yarnpkg.com/pidusage/-/pidusage-2.0.21.tgz#7068967b3d952baea73e57668c98b9eaa876894e"
   integrity sha512-cv3xAQos+pugVX+BfXpHsbyz/dLzX+lr44zNMsYiGxUw+kV5sgQCIcLd1z+0vq+KyC7dJ+/ts2PsfgWfSC3WXA==
   dependencies:
     safe-buffer "^5.2.1"
 
 pidusage@~3.0:
   version "3.0.2"
-  resolved "https://registry.npmjs.org/pidusage/-/pidusage-3.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/pidusage/-/pidusage-3.0.2.tgz#6faa5402b2530b3af2cf93d13bcf202889724a53"
   integrity sha512-g0VU+y08pKw5M8EZ2rIGiEBaB8wrQMjYGFfW2QVIfyT8V+fq8YFLkvlz4bz5ljvFDJYNFCWT3PWqcRr2FKO81w==
   dependencies:
     safe-buffer "^5.2.1"
@@ -1685,14 +1685,14 @@ pify@^3.0.0:
 
 pm2-axon-rpc@~0.7.0, pm2-axon-rpc@~0.7.1:
   version "0.7.1"
-  resolved "https://registry.npmjs.org/pm2-axon-rpc/-/pm2-axon-rpc-0.7.1.tgz"
+  resolved "https://registry.yarnpkg.com/pm2-axon-rpc/-/pm2-axon-rpc-0.7.1.tgz#2daec5383a63135b3f18babb70266dacdcbc429a"
   integrity sha512-FbLvW60w+vEyvMjP/xom2UPhUN/2bVpdtLfKJeYM3gwzYhoTEEChCOICfFzxkxuoEleOlnpjie+n1nue91bDQw==
   dependencies:
     debug "^4.3.1"
 
 pm2-axon@~4.0.1:
   version "4.0.1"
-  resolved "https://registry.npmjs.org/pm2-axon/-/pm2-axon-4.0.1.tgz"
+  resolved "https://registry.yarnpkg.com/pm2-axon/-/pm2-axon-4.0.1.tgz#a7b4bb586e9aeb35b1042b488cde15b60cabafd2"
   integrity sha512-kES/PeSLS8orT8dR5jMlNl+Yu4Ty3nbvZRmaAtROuVm9nYYGiaoXqqKQqQYzWQzMYWUKHMQTvBlirjE5GIIxqg==
   dependencies:
     amp "~0.3.1"
@@ -1702,7 +1702,7 @@ pm2-axon@~4.0.1:
 
 pm2-deploy@~1.0.2:
   version "1.0.2"
-  resolved "https://registry.npmjs.org/pm2-deploy/-/pm2-deploy-1.0.2.tgz"
+  resolved "https://registry.yarnpkg.com/pm2-deploy/-/pm2-deploy-1.0.2.tgz#98d8385553a3a4dca11c7b3116deb519bc5961a7"
   integrity sha512-YJx6RXKrVrWaphEYf++EdOOx9EH18vM8RSZN/P1Y+NokTKqYAca/ejXwVLyiEpNju4HPZEk3Y2uZouwMqUlcgg==
   dependencies:
     run-series "^1.1.8"
@@ -1710,14 +1710,14 @@ pm2-deploy@~1.0.2:
 
 pm2-multimeter@^0.1.2:
   version "0.1.2"
-  resolved "https://registry.npmjs.org/pm2-multimeter/-/pm2-multimeter-0.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/pm2-multimeter/-/pm2-multimeter-0.1.2.tgz#1a1e55153d41a05534cea23cfe860abaa0eb4ace"
   integrity sha512-S+wT6XfyKfd7SJIBqRgOctGxaBzUOmVQzTAS+cg04TsEUObJVreha7lvCfX8zzGVr871XwCSnHUU7DQQ5xEsfA==
   dependencies:
     charm "~0.1.1"
 
 pm2-sysmonit@^1.2.8:
   version "1.2.8"
-  resolved "https://registry.npmjs.org/pm2-sysmonit/-/pm2-sysmonit-1.2.8.tgz"
+  resolved "https://registry.yarnpkg.com/pm2-sysmonit/-/pm2-sysmonit-1.2.8.tgz#eddea34a53fd8c8d7c3efb73b97a3c548686e24d"
   integrity sha512-ACOhlONEXdCTVwKieBIQLSi2tQZ8eKinhcr9JpZSUAL8Qy0ajIgRtsLxG/lwPOW3JEKqPyw/UaHmTWhUzpP4kA==
   dependencies:
     async "^3.2.0"
@@ -1728,7 +1728,7 @@ pm2-sysmonit@^1.2.8:
 
 pm2@^5.4.0:
   version "5.4.0"
-  resolved "https://registry.npmjs.org/pm2/-/pm2-5.4.0.tgz"
+  resolved "https://registry.yarnpkg.com/pm2/-/pm2-5.4.0.tgz#bf7976d8681304c31388ff8aae81633a2a04d54e"
   integrity sha512-9TrDuckcSEnINoURygr3yfruK20qXuOUPOPQyIh4FIskQduyDNst9ys1XAt9YPY3RyGxVr2+x8Irsdma3klVQw==
   dependencies:
     "@pm2/agent" "~2.0.0"
@@ -1770,14 +1770,14 @@ possible-typed-array-names@^1.0.0:
 
 promptly@^2:
   version "2.2.0"
-  resolved "https://registry.npmjs.org/promptly/-/promptly-2.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/promptly/-/promptly-2.2.0.tgz#2a13fa063688a2a5983b161fff0108a07d26fc74"
   integrity sha512-aC9j+BZsRSSzEsXBNBwDnAxujdx19HycZoKgRgzWnS8eOHg1asuf9heuLprfbe739zY3IdUQx+Egv6Jn135WHA==
   dependencies:
     read "^1.0.4"
 
 proxy-agent@~6.3.0:
   version "6.3.1"
-  resolved "https://registry.npmjs.org/proxy-agent/-/proxy-agent-6.3.1.tgz"
+  resolved "https://registry.yarnpkg.com/proxy-agent/-/proxy-agent-6.3.1.tgz#40e7b230552cf44fd23ffaf7c59024b692612687"
   integrity sha512-Rb5RVBy1iyqOtNl15Cw/llpeLH8bsb37gM1FUfKQ+Wck6xHlbAhWGUFiTRHtkjqGTA5pSHz6+0hrPW/oECihPQ==
   dependencies:
     agent-base "^7.0.2"
@@ -1833,7 +1833,7 @@ rc@^1.0.1, rc@^1.1.6:
 
 read@^1.0.4:
   version "1.0.7"
-  resolved "https://registry.npmjs.org/read/-/read-1.0.7.tgz"
+  resolved "https://registry.yarnpkg.com/read/-/read-1.0.7.tgz#b3da19bd052431a97671d44a42634adf710b40c4"
   integrity sha512-rSOKNYUmaxy0om1BNjMN4ezNT6VKK+2xF4GBhc81mkH7L60i6dp8qPYrkndNLT3QPphoII3maL9PVC9XmhHwVQ==
   dependencies:
     mute-stream "~0.0.4"
@@ -1879,7 +1879,7 @@ require-from-string@^2.0.2:
 
 require-in-the-middle@^5.0.0:
   version "5.2.0"
-  resolved "https://registry.npmjs.org/require-in-the-middle/-/require-in-the-middle-5.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/require-in-the-middle/-/require-in-the-middle-5.2.0.tgz#4b71e3cc7f59977100af9beb76bf2d056a5a6de2"
   integrity sha512-efCx3b+0Z69/LGJmm9Yvi4cqEdxnoGnxYxGxBghkkTTFeXRtTCmmhO0AnAfHz59k957uTSuy8WaHqOs8wbYUWg==
   dependencies:
     debug "^4.1.1"
@@ -1915,7 +1915,7 @@ rotating-file-stream@^2.1.5:
 
 run-series@^1.1.8:
   version "1.1.9"
-  resolved "https://registry.npmjs.org/run-series/-/run-series-1.1.9.tgz"
+  resolved "https://registry.yarnpkg.com/run-series/-/run-series-1.1.9.tgz#15ba9cb90e6a6c054e67c98e1dc063df0ecc113a"
   integrity sha512-Arc4hUN896vjkqCYrUXquBFtRZdv1PfLbTYP71efP6butxyQ0kWpiNJyAgsxscmQg1cqvHY32/UCBzXedTpU2g==
 
 safe-buffer@5.1.2:
@@ -1930,22 +1930,22 @@ safe-buffer@^5.0.1, safe-buffer@^5.1.0, safe-buffer@^5.2.1:
 
 "safer-buffer@>= 2.1.2 < 3":
   version "2.1.2"
-  resolved "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/safer-buffer/-/safer-buffer-2.1.2.tgz#44fa161b0187b9549dd84bb91802f9bd8385cd6a"
   integrity sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==
 
 sax@^1.2.4:
   version "1.4.1"
-  resolved "https://registry.npmjs.org/sax/-/sax-1.4.1.tgz"
+  resolved "https://registry.yarnpkg.com/sax/-/sax-1.4.1.tgz#44cc8988377f126304d3b3fc1010c733b929ef0f"
   integrity sha512-+aWOz7yVScEGoKNd4PA10LZ8sk0A/z5+nXQG5giUO5rprX9jgYsTdov9qCchZiPIZezbZH+jRut8nPodFAX4Jg==
 
 semver@^7.2:
   version "7.6.2"
-  resolved "https://registry.npmjs.org/semver/-/semver-7.6.2.tgz"
+  resolved "https://registry.yarnpkg.com/semver/-/semver-7.6.2.tgz#1e3b34759f896e8f14d6134732ce798aeb0c6e13"
   integrity sha512-FNAIBWCx9qcRhoHcgcJ0gvU7SN1lYU2ZXuSfl04bSC5OpvDHFyJCjdNHomPXxjQlCBU67YW64PzY7/VIEH7F2w==
 
 semver@~7.5.0, semver@~7.5.4:
   version "7.5.4"
-  resolved "https://registry.npmjs.org/semver/-/semver-7.5.4.tgz"
+  resolved "https://registry.yarnpkg.com/semver/-/semver-7.5.4.tgz#483986ec4ed38e1c6c48c34894a9182dbff68a6e"
   integrity sha512-1bCSESV6Pv+i21Hvpxp3Dx+pSD8lIPt8uVjRrxAUt/nbswYc+tK6Y2btiULjd4+fnq15PX+nqQDC7Oft7WkwcA==
   dependencies:
     lru-cache "^6.0.0"
@@ -2023,7 +2023,7 @@ shelljs@^0.8.5:
 
 shimmer@^1.2.0:
   version "1.2.1"
-  resolved "https://registry.npmjs.org/shimmer/-/shimmer-1.2.1.tgz"
+  resolved "https://registry.yarnpkg.com/shimmer/-/shimmer-1.2.1.tgz#610859f7de327b587efebf501fb43117f9aff337"
   integrity sha512-sQTKC1Re/rM6XyFM6fIAGHRPVGvyXfgzIDvzoq608vM+jeyVD0Tu1E6Np0Kc2zAIFWIj963V2800iF/9LPieQw==
 
 should-equal@^2.0.0:
@@ -2101,12 +2101,12 @@ sinon@^18.0.0:
 
 smart-buffer@^4.2.0:
   version "4.2.0"
-  resolved "https://registry.npmjs.org/smart-buffer/-/smart-buffer-4.2.0.tgz"
+  resolved "https://registry.yarnpkg.com/smart-buffer/-/smart-buffer-4.2.0.tgz#6e1d71fa4f18c05f7d0ff216dd16a481d0e8d9ae"
   integrity sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==
 
 socks-proxy-agent@^8.0.2:
   version "8.0.3"
-  resolved "https://registry.npmjs.org/socks-proxy-agent/-/socks-proxy-agent-8.0.3.tgz"
+  resolved "https://registry.yarnpkg.com/socks-proxy-agent/-/socks-proxy-agent-8.0.3.tgz#6b2da3d77364fde6292e810b496cb70440b9b89d"
   integrity sha512-VNegTZKhuGq5vSD6XNKlbqWhyt/40CgoEw8XxD6dhnm8Jq9IEa3nIa4HwnM8XOqU0CdB0BwWVXusqiFXfHB3+A==
   dependencies:
     agent-base "^7.1.1"
@@ -2115,7 +2115,7 @@ socks-proxy-agent@^8.0.2:
 
 socks@^2.7.1:
   version "2.8.3"
-  resolved "https://registry.npmjs.org/socks/-/socks-2.8.3.tgz"
+  resolved "https://registry.yarnpkg.com/socks/-/socks-2.8.3.tgz#1ebd0f09c52ba95a09750afe3f3f9f724a800cb5"
   integrity sha512-l5x7VUUWbjVFbafGLxPWkYsHIhEvmF85tbIeFZWc8ZPtoMyybuEhL7Jye/ooC4/d48FgOjSJXgsF/AJPYCW8Zw==
   dependencies:
     ip-address "^9.0.5"
@@ -2123,7 +2123,7 @@ socks@^2.7.1:
 
 source-map-support@0.5.21:
   version "0.5.21"
-  resolved "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz"
+  resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.21.tgz#04fe7c7f9e1ed2d662233c28cb2b35b9f63f6e4f"
   integrity sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==
   dependencies:
     buffer-from "^1.0.0"
@@ -2131,17 +2131,17 @@ source-map-support@0.5.21:
 
 source-map@^0.6.0, source-map@~0.6.1:
   version "0.6.1"
-  resolved "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz"
+  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.6.1.tgz#74722af32e9614e9c287a8d0bbde48b5e2f1a263"
   integrity sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==
 
 sprintf-js@1.1.2:
   version "1.1.2"
-  resolved "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.1.2.tgz"
+  resolved "https://registry.yarnpkg.com/sprintf-js/-/sprintf-js-1.1.2.tgz#da1765262bf8c0f571749f2ad6c26300207ae673"
   integrity sha512-VE0SOVEHCk7Qc8ulkWw3ntAzXuqf7S2lvwQaDLRnUeIEaKNQJzV6BwmLKhOqT61aGhfUMrXeaBk+oDGCzvhcug==
 
 sprintf-js@^1.1.3:
   version "1.1.3"
-  resolved "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.1.3.tgz"
+  resolved "https://registry.yarnpkg.com/sprintf-js/-/sprintf-js-1.1.3.tgz#4914b903a2f8b685d17fdf78a70e917e872e444a"
   integrity sha512-Oo+0REFV59/rz3gfJNKQiBlwfHaSESl1pcGyABQsnnIfWOFt6JNj5gCog2U6MLZ//IGYD+nA8nI+mTShREReaA==
 
 steno@^0.4.1:
@@ -2219,7 +2219,7 @@ supports-preserve-symlinks-flag@^1.0.0:
 
 systeminformation@^5.7:
   version "5.22.10"
-  resolved "https://registry.npmjs.org/systeminformation/-/systeminformation-5.22.10.tgz"
+  resolved "https://registry.yarnpkg.com/systeminformation/-/systeminformation-5.22.10.tgz#9465306edd4db4bd5a3a04766703b35b279369b7"
   integrity sha512-RJ3oed80NkqgHtpB0TLkxEKEpQ3pUm2lgVolkHeoaExPidkWsj2D/hO6Rwwi9i+Odl1vm8TMiRNIKK7hBaqDsw==
 
 to-regex-range@^5.0.1:
@@ -2236,22 +2236,22 @@ trampa@^1.0.0:
 
 tslib@1.9.3:
   version "1.9.3"
-  resolved "https://registry.npmjs.org/tslib/-/tslib-1.9.3.tgz"
+  resolved "https://registry.yarnpkg.com/tslib/-/tslib-1.9.3.tgz#d7e4dd79245d85428c4d7e4822a79917954ca286"
   integrity sha512-4krF8scpejhaOgqzBEcGM7yDIEfi0/8+8zDRZhNZZ2kjmHJ4hv3zCbQWxoJGz1iw5U0Jl0nma13xzHXcncMavQ==
 
 tslib@^2.0.1:
-  version "2.6.2"
-  resolved "https://registry.npmjs.org/tslib/-/tslib-2.6.2.tgz"
-  integrity sha512-AEYxH93jGFPn/a2iVAwW87VuUIkR1FVUKB77NwMF7nBTDkDrrT/Hpt/IrCJ0QXhW27jTBDcf5ZY7w6RiqTMw2Q==
+  version "2.6.3"
+  resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.6.3.tgz#0438f810ad7a9edcde7a241c3d80db693c8cbfe0"
+  integrity sha512-xNvxJEOUiWPGhUuUdQgAJPKOOJfGnIyKySOc09XkKsgdUV/3E2zvwZYdejjmRgPCgcym1juLH3226yA7sEFJKQ==
 
 tv4@^1.3.0:
   version "1.3.0"
-  resolved "https://registry.npmjs.org/tv4/-/tv4-1.3.0.tgz"
+  resolved "https://registry.yarnpkg.com/tv4/-/tv4-1.3.0.tgz#d020c846fadd50c855abb25ebaecc68fc10f7963"
   integrity sha512-afizzfpJgvPr+eDkREK4MxJ/+r8nEEHcmitwgnPUqpaP+FpwQyadnxNoSACbgc/b1LsZYtODGoPiFxQrgJgjvw==
 
 tx2@~1.0.4:
   version "1.0.5"
-  resolved "https://registry.npmjs.org/tx2/-/tx2-1.0.5.tgz"
+  resolved "https://registry.yarnpkg.com/tx2/-/tx2-1.0.5.tgz#ee0b0e5e2c351f8d23e54bdf46dd60afa3bbc73d"
   integrity sha512-sJ24w0y03Md/bxzK4FU8J8JveYYUbSs2FViLJ2D/8bytSiyPRbuE3DyL/9UKYXTZlV3yXq0L8GLlhobTnekCVg==
   dependencies:
     json-stringify-safe "^5.0.1"
@@ -2324,7 +2324,7 @@ vary@~1.1.2:
 
 vizion@~2.2.1:
   version "2.2.1"
-  resolved "https://registry.npmjs.org/vizion/-/vizion-2.2.1.tgz"
+  resolved "https://registry.yarnpkg.com/vizion/-/vizion-2.2.1.tgz#04201ea45ffd145d5b5210e385a8f35170387fb2"
   integrity sha512-sfAcO2yeSU0CSPFI/DmZp3FsFE9T+8913nv1xWBOyzODv13fwkn6Vl7HqxGpkr9F608M+8SuFId3s+BlZqfXww==
   dependencies:
     async "^2.6.3"
@@ -2387,7 +2387,7 @@ wrappy@1:
 
 ws@^7.0.0:
   version "7.5.9"
-  resolved "https://registry.npmjs.org/ws/-/ws-7.5.9.tgz"
+  resolved "https://registry.yarnpkg.com/ws/-/ws-7.5.9.tgz#54fa7db29f4c7cec68b1ddd3a89de099942bb591"
   integrity sha512-F+P9Jil7UiSKSkppIiD94dN07AwvFixvLIj1Og1Rl9GGMuNipJnV9JzjD6XuqmAeiswGvUmNLjr5cFuXwNS77Q==
 
 ws@^8.17.0:
@@ -2397,7 +2397,7 @@ ws@^8.17.0:
 
 ws@~7.4.0:
   version "7.4.6"
-  resolved "https://registry.npmjs.org/ws/-/ws-7.4.6.tgz"
+  resolved "https://registry.yarnpkg.com/ws/-/ws-7.4.6.tgz#5654ca8ecdeee47c33a9a4bf6d28e2be2980377c"
   integrity sha512-YmhHDO4MzaDLB+M9ym/mDA5z0naX8j7SIlT8f8z+I0VtzsRbekxEutHSme7NPS2qE8StCYQNUnfWdXta/Yu85A==
 
 y18n@^5.0.5:
@@ -2407,7 +2407,7 @@ y18n@^5.0.5:
 
 yallist@^4.0.0:
   version "4.0.0"
-  resolved "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz"
+  resolved "https://registry.yarnpkg.com/yallist/-/yallist-4.0.0.tgz#9bb92790d9c0effec63be73519e11a35019a3a72"
   integrity sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==
 
 yaml@^2.4.2: