lke-component 1.2.22 → 1.2.23

package/lib/react/src/shared/components/mathjax.js

@@ -0,0 +1,935 @@
+import { getDefaultWhiteList, escapeAttrValue, whiteList } from 'xss';
+
+window.isMathJaxLoaded = false;
+/**
+ * Mathjax to be injected into the document head
+ * @param {IInjectOptions} options The script attribute
+ * @returns void
+ */
+export function injectMathJax({ loadType, url }) {
+  console.log('injectMathJax 3');
+  if (!window.isMathJaxLoaded) {
+    const script = document.createElement('script');
+    script.src = window.mathjaxSrc ? window.mathjaxSrc :
+      'https://cdn.xiaowei.qq.com/webim/assets/static/mathjax/es5/tex-chtml.min.es5.js';
+    script.async = true;
+    document.head.appendChild(script);
+  }
+}
+// const tmpArr = [];
+/**
+ * Global configuration MathJax
+ * @param {IMathJaxProps} options Custom MathJax global configuration  reference: http://docs.mathjax.org/en/latest/
+ * @param {FnType} callback Mathjax loading is completed, you need to perform the function
+ */
+export function initMathJax(
+  options = {},
+  callback,
+) {
+  // console.log('initMathJax 1', window.isMathJaxLoaded);
+  if (!window.isMathJaxLoaded) {
+    // console.log('initMathJax 2', window.MathJax);
+    if (window.MathJax) {
+      const tmp = window.MathJax.startup.pageReady;
+      window.MathJax.startup.pageReady = () => {
+        console.log('MathJax callback');
+        callback && callback();
+        window.isMathJaxLoaded = true;
+        tmp();
+        // const fn = tmpArr.shift();
+        // fn && fn();
+      }
+      // tmpArr.push(tmp);
+    } else {
+      injectMathJax({});
+      window.MathJax = {
+        loader: {load: ['[tex]/mhchem']},
+        tex: {
+          inlineMath: [
+              ["$", "$"],
+              ["\\(", "\\)"]
+          ], //行内公式选择符
+          displayMath: [
+              ["$$", "$$"],
+              ["\\[", "\\]"]
+          ], //段内公式选择符
+          // 下面两个主要是支持渲染某些公式，可以自己了解
+          processEnvironments: true,
+          processRefs: true,
+          processEscapes: true,
+          packages: {'[+]': ['mhchem']},
+          equationNumbers: {autoNumber: "AMS"},
+        },
+        options: {
+          // 跳过渲染的标签
+          skipHtmlTags: ['script', 'noscript', 'style', 'textarea', 'pre', 'code', 'a'],
+          // 跳过mathjax处理的元素的类名，任何元素指定一个类 tex2jax_ignore 将被跳过，多个累=类名'class1|class2'
+          ignoreHtmlClass: 'tex2jax_ignore',
+        },
+        startup: {
+          // 当mathjax加载并初始化完成后的回调
+          pageReady: () => {
+            console.log('initMathJax 4 pageReady');
+            callback && callback();
+            window.isMathJaxLoaded = true;
+          },
+        },
+        svg: {
+          fontCache: 'global',
+        },
+      };
+    }
+  } else {
+    callback && callback();
+  }
+  // window.MathJax.Hub.Config({
+  //     extensions: ["tex2jax.js"],
+  //     showProcessingMessages: false, //关闭js加载过程信息
+  //     messageStyle: "none", //不显示信息
+  //     jax: ["input/TeX", "output/HTML-CSS"],
+  //     tex2jax: {
+  //         inlineMath: [
+  //             ["$", "$"],
+  //             ["\\(", "\\)"]
+  //         ], //行内公式选择符
+  //         displayMath: [
+  //             ["$$", "$$"],
+  //             ["\\[", "\\]"]
+  //         ], //段内公式选择符
+  //         skipTags: ["script", "noscript", "style", "textarea", "pre", "code", "a"] //避开某些标签
+  //     },
+  //     "HTML-CSS": {
+  //         availableFonts: ["STIX", "TeX"], //可选字体
+  //         showMathMenu: false //关闭右击菜单显示
+  //     }
+  // });
+  // isMathjaxConfig = true; //配置完成，改为true
+}
+
+/**
+ * Manual rendering formula, returns a Promise
+ * @param {HTMLElement} el Need to be mathjax rendered HTMLElement
+ * @returns Promise
+ */
+export function renderByMathjax(el) {
+  // console.log('renderByMathjax', window.MathJax ? window.MathJax.version : '');
+
+  if (el && !Array.isArray(el)) {
+    el = [el]
+  }
+
+  return new Promise((resolve, reject) => {
+    initMathJax({},() => {
+      window.MathJax.typesetPromise(el)
+        .then(() => {
+          resolve(void 0)
+        })
+        .catch((err) => reject(err))
+      });
+  });
+}
+
+export function partialDescape(html) {
+  var lines = html.split('\n');
+  var out = '';
+
+  // is true when we are
+  // ```
+  //  inside a code block
+  // ```
+  var inside_code = false;
+
+  for (var i = 0; i < lines.length; i++) {
+    // a hack to properly rendre the blockquotes
+    if (lines[i].startsWith('&gt;')) {
+      lines[i] = lines[i].replace(/&gt;/g, '>');
+    }
+
+    // rendrer properly stuff like this
+    // ```c
+    //  if (a > b)
+    // ```
+    if (inside_code) {
+      // inside the code we descape stuff
+      lines[i] = lines[i]
+        .replace(new RegExp('&lt;', 'g'), '<')
+        .replace(new RegExp('&gt;', 'g'), '>')
+        .replace(new RegExp('&quot;', 'g'), '"')
+        .replace(new RegExp('&#39;', 'g'), '\'');
+    }
+    if (lines[i].startsWith('```')) {
+      inside_code = ! inside_code;
+    }
+    out += lines[i] + '\n';
+  }
+  return out.replace(/<span>\\<\/span>/g, '\\\\');
+}
+
+export function escapeStr (html, encode) {
+  const regex = new RegExp("&(?!#?\\w+;)", "g");
+  if (html && html.replace) {
+    return html
+      .replace(!encode ? regex : new RegExp('&', 'g'), '&amp;')
+      .replace(new RegExp('<', 'g'), '&lt;')
+      .replace(new RegExp('>', 'g'), '&gt;')
+      .replace(new RegExp('"', 'g'), '&quot;')
+      .replace(new RegExp("'", 'g'), '&#39;');
+  }
+  return html;
+}
+export function revertEscapeStr(escapedHtml) {
+  if (escapedHtml && escapedHtml.replace) {
+    return escapedHtml
+      .replace(new RegExp('&quot;', 'g'), '"')
+      .replace(new RegExp('&#39;', 'g'), "'")
+      .replace(new RegExp('&lt;', 'g'), '<')
+      .replace(new RegExp('&gt;', 'g'), '>')
+      .replace(new RegExp('&amp;', 'g'), '&')
+      .replace(new RegExp('<span>\\\\<\\/span>', 'g'), '\\\\');
+  }
+  return escapedHtml;
+}
+
+export function extractCodeBlocks(mdString) {
+  // 用于保存代码块的数组
+  const codeBlocks = [];
+
+  // 定义匹配代码块的正则表达式
+  const codeBlockPattern = new RegExp('```[\\s\\S]*?```', 'g');
+
+  // 替换代码块为特殊字符串，并保存代码块内容
+  const modifiedMdString = mdString.replace(codeBlockPattern, (match) => {
+      codeBlocks.push(match);
+      return '{{CODE_BLOCK}}';
+  });
+
+  return { modifiedMdString, codeBlocks };
+}
+
+export function restoreCodeBlocks(modifiedMdString, codeBlocks) {
+  // 定义特殊字符串的正则表达式
+  const specialStringPattern = new RegExp('\\{\\{CODE_BLOCK\\}\\}', 'g');
+
+  // 逐个替换特殊字符串为原始代码块
+  let index = 0;
+  const restoredMdString = modifiedMdString.replace(specialStringPattern, () => {
+      return codeBlocks[index++];
+  });
+
+  return restoredMdString;
+}
+
+
+export function replaceVideoTags(htmlString) {
+  const videoTagRegex = new RegExp('<video[\\s\\S]*?<\\/video>', 'gi');
+  const videoTags = [];
+  const replacedString = htmlString.replace(videoTagRegex, (match) => {
+    // 压缩 video 标签内部的换行和多余空白为单行，防止 markdown 渲染器插入 <br>/<p> 破坏 DOM 结构
+    const compacted = match.replace(/>\s+</g, '><').replace(/\n\s*/g, ' ').trim();
+    videoTags.push(compacted);
+    return 'HTML@@Video';
+  });
+  return { replacedString, videoTags };
+}
+export function restoreVideoTags(replacedString, videoTags) {
+  let restoredString = replacedString;
+  videoTags.forEach((videoTag) => {
+    restoredString = restoredString.replace('HTML@@Video', videoTag);
+  });
+  return restoredString;
+}
+
+function isFinancialData(text) {
+  let str = '$'+text+'$'
+  console.log('isMathJaxFormula 66', str);
+
+  // 因为需要结合语义，所以要把截取的$$之间的内容，前后补充$,在通过下面正则校验语义
+  const patterns = [
+    // 金额 + 变化关键词 + 百分比等字符
+    /\$\d+(\.\d+)?.*(change|up|down|gain|loss|move).*([\+\-]?\d+(\.\d+)?).*([\+\-]?\d+(\.\d+)?%)/i,
+    // 市值关键词 + is/:
+    /(market\s+cap|capitalization|market\s+value).*(is|\:)\s*\$\d+/i,
+    // 交易关键词 + at|\@ + 金额
+    /(trading|volume|shares|stock).*(at|\@)\s*\$\d+/i,
+    // 价格范围 + (to|-|~) + 第二个金额
+    /\$\d+(\.\d+)?\s*(to|-|~)\s*\$\d+(\.\d+)?/i
+  ];
+
+  return patterns.some(pattern => pattern.test(str));
+}
+
+/**
+ * 检测文本是否为数学公式
+ * @param {string} text 需要检测的文本
+ * @return {boolean} 是否为数学公式
+ */
+export function isMathJaxFormula(text) {
+  console.log('isMathJaxFormula 6', isFinancialData(text), text);
+
+  //  // 新增: 优先检测金融数据
+   if (isFinancialData(text)) {
+    return false;
+  }
+
+  // 新增: 检测 HTML 实体编码的 JSON 字符串
+  if (text.includes('\\&quot;')) {
+    // 检查是否是 JSON 对象或数组结构
+    if ((text.startsWith('{') && text.endsWith('}')) ||
+        (text.startsWith('[') && text.endsWith(']'))) {
+      return false;
+    }
+
+    // 检测典型的 JSON 键值对模式，但使用 HTML 实体编码的引号
+    const htmlEncodedJsonPattern = /\\&quot;[^\\]+\\&quot;\s*:\s*\\&quot;[^\\]*\\&quot;/;
+    if (htmlEncodedJsonPattern.test(text)) {
+      return false;
+    }
+  }
+
+  // 更一般化地检测各种编码的 JSON
+  if ((text.startsWith('{') && text.endsWith('}')) ||
+      (text.startsWith('[') && text.endsWith(']'))) {
+
+    // 检查是否包含各种形式的编码引号
+    if (text.includes('\\\"') || text.includes('\\"') ||
+        text.includes('\\&quot;') || text.includes('&quot;')) {
+
+      // 检查是否有冒号，这是 JSON 键值对的特征
+      if (text.includes(':')) {
+        return false;
+      }
+    }
+  }
+
+  // 原有函数的其余部分保持不变
+  // 首先排除 Markdown 特殊格式
+  // 1. 排除 Markdown 标题格式
+  if (/^#{1,6}\s+/.test(text.trim())) {
+    return false;
+  }
+
+  // 2. 排除包含多个 # 的解释性文本
+  if (text.includes('###') || text.includes('##') || /^#\s+/.test(text.trim())) {
+    return false;
+  }
+
+  // 如果文本为空或只是空白字符，则不是公式
+  if (!text || text.trim() === '') return false;
+
+  // 排除变量引用和非数学公式的内容
+  if (
+    text.match(/^CONST\[/) ||              // 排除 CONST[] 变量
+    text.match(/^[A-Z_]+\[/) ||            // 排除大写字母+下划线组成的变量引用
+    text.includes('@\\`')                  // 排除特定标记
+  ) {
+    return false;
+  }
+
+  // 新增: 排除代码引用/变量引用模式
+  // 匹配形如 $region\` 或包含反引号的代码引用格式
+  if (
+    (text.startsWith('$') && text.endsWith('$') && text.includes('\\`')) ||
+    /\$[a-zA-Z0-9_]+\\`/.test(text) ||
+    /`[^`]*`/.test(text)
+  ) {
+    return false;
+  }
+
+  // 新增: 排除带有 Markdown 语法的解释性文本
+  if (/\*\*.*?\*\*|__.*?__|_.*?_|\*.*?\*|~~.*?~~|\[.*?\]\(.*?\)/.test(text)) {
+    // 检查它是否确实像是解释性文本而不是数学公式
+    if (!/(\\frac|\\sum|\\int|\\prod|\\lim|\\{|\\}|\\[|\\]|\\(|\\))/.test(text)) {
+      return false;
+    }
+  }
+
+  // 处理多行内容 - 检测价格+说明的多行格式
+  if (text.includes('\n')) {
+    const lines = text.trim().split('\n');
+
+    // 检查第一行是否为价格数字
+    if (lines.length >= 2 && /^(\$)?\s*\d+(\.\d+)?\s*$/.test(lines[0].trim())) {
+      // 检查第二行是否为价格相关说明
+      const secondLine = lines[1].trim();
+      if (
+        /^\*\*.*?(价格|原价|折扣|优惠|促销|售价).*?\*\*\s*:/.test(secondLine) ||
+        /^\*\*(Price|Original|Discount|Sale|Special).*?\*\*\s*:/i.test(secondLine)
+      ) {
+        return false; // 这是价格+说明的多行格式，不是数学公式
+      }
+    }
+
+    // 新增: 检查是否包含Markdown标题行，如果是，整个文本块不是数学公式
+    for (const line of lines) {
+      if (/^#{1,6}\s+/.test(line.trim())) {
+        return false;
+      }
+    }
+  }
+
+  const trimmedText = text.trim();
+
+  // 新增: 直接排除包含Markdown格式的解释文本
+  if (/^(Based on|According to|From|In|The) .*(answer|correct|material|provided|explanation).*:?$/i.test(trimmedText)) {
+    return false;
+  }
+
+  // 新增: 检测解释性文本中的美元金额
+  // 匹配形如 "at least $300" 或 "the fine is **$300**" 的模式
+  if (/(at least|\bat\b|\bof\b|\bis\b|\bfine\b|\bpay\b|\bfees?\b|\bprice\b|\bcosts?\b|\bpenalty|\bpenalties)\s+(\*\*)?\$\d+/i.test(text)) {
+    return false;
+  }
+
+  // 新增: 检测列表项中的美元金额
+  if (/^[-•*]\s+.*\$\d+/.test(text) || /^[\d]+\.?\s+.*\$\d+/.test(text)) {
+    return false;
+  }
+
+  // 新增: 检测表格引用和解释中的美元金额
+  if (/table\s+\d+|general\s+impairment|high\s+rate|highest\s+rate/i.test(text) && /\$\d+/.test(text)) {
+    return false;
+  }
+
+  // 1. 检测常见价格模式 (无论是否有美元符号)
+  if (/^(\$)?\s*\d+(\.\d+)?\s*$/.test(trimmedText)) {
+    return false; // 纯数字或带美元符号的数字，如 "25.99" 或 "$25.99"
+  }
+
+  // 2. 检查商品价格相关上下文
+  const priceContextPatterns = [
+    // 中文价格相关描述
+    /(原价|现价|优惠价|折扣价|促销价|售价|定价|价格|折扣信息|优惠信息)\s*[:：]?\s*$/,
+    /(价格|费用|金额)\s*[:：]?\s*$/,
+    /^\s*([¥＄€₤₹₽¢₩]|USD|CAD|EUR|GBP|JPY|RMB|CNY)/,  // 各种货币符号或货币代码开头
+
+    // 英文价格相关描述
+    /\b(quotation|budget|controller|department|head|manager|director|verbal|approval|vendor|supplier)\b/i,
+    /^(price|cost|fee|amount|fine|penalty|minimum)\s*:?\s*$/i,
+    /(original|discount|sale|special|retail|list|offer)\s+(price|cost)\s*:?\s*$/i,
+    /(price|cost|fine)\s+(before|after|is|of|at least)\s+(tax|discount)\s*:?\s*$/i,
+    // 新增: 匹配形如 "minimum fine"、"penalty is" 的模式
+    /(minimum|maximum|guaranteed)\s+(fine|penalty|cost|payment)/i
+  ];
+
+  for (const pattern of priceContextPatterns) {
+    if (pattern.test(trimmedText)) {
+      return false;
+    }
+  }
+
+  // 检查常见明显非公式模式
+    const notFormulaReg = [
+        // 表格特征
+        /\|.*\|/,                                      // 包含竖线分隔符
+        /\n.*\|/,                                      // 多行表格
+
+        /^\s*\$?\d{1,3}(,\d{3})+(\.\d{2})?\s*$/,     // 千分位货币：$20,000
+        /\$\d+,\d+/, 
+                                          // 带$的千分位数字
+        /[A-Z][a-z]+\s+[A-Z][a-z]+/  //// 首字母大写，英文短语Budget Controllers
+    ]
+    for (const p of notFormulaReg) {
+      if (p.test(trimmedText)) {
+        return false;
+      }
+    }
+
+  // 3. 检测价格附近的描述文本 - 扩展匹配范围
+  const priceDescriptionPatterns = [
+    // 商品描述标记
+    /^\*\*[\s\S]*?(价格|折扣|优惠|促销|售价|特价|打折|fine|penalty|payment|fee)[\s\S]*?\*\*\s*:?$/i,
+    // 商品规格、价格等结构化信息
+    /^\*\*(商品|产品|规格|型号|尺寸|数量|Table|BAC|Rate|offense|conviction|Explanation|Notes|Additional)[\s\S]*?\*\*\s*:?$/i,
+  ];
+
+  for (const pattern of priceDescriptionPatterns) {
+    if (pattern.test(trimmedText)) {
+      return false;
+    }
+  }
+
+  // 新增: 检测出现在句中的货币金额 (如 "$300 across all impairment levels")
+  if (/\$\d+(\.\d+)?([\s,]+(across|for|in|when|per|each|every|all|any|most|minimum|maximum))/i.test(text)) {
+    return false;
+  }
+
+  // 4. 检查是否是特定格式的数字，如只有小数价格
+  if (/^(\d+)?\.?\d+$/.test(trimmedText)) {
+    return false; // 仅包含数字和小数点的情况，如 "25.99"、".99" 或 "25"
+  }
+
+  // 新增: 检测带引号的金额表述
+  if (/['"][^'"]*\$\d+[^'"]*['"]/.test(text)) {
+    return false;
+  }
+
+  // 新增：检测引用格式的内容
+  if (/^>.*\$\d+/.test(trimmedText)) {
+    return false;
+  }
+
+  // 预处理 - 检查是否为美元符号包裹的内容
+  const isMathDelimited = text.startsWith('$') && text.endsWith('$') && text.length > 2;
+
+  // 如果是美元符号包裹的内容，简化处理
+  if (isMathDelimited) {
+    const content = text.slice(1, -1);
+
+    // 排除内容是纯数字+小数点的情况（很可能是价格）
+    if (/^\s*\d+(\.\d+)?\s*$/.test(content)) {
+      return false;
+    }
+
+    // 新增: 排除变量引用格式
+    if (/.*\\`.*/.test(content)) {
+      return false;
+    }
+
+    // 新增: 排除包含 # 的内容，避免 macro parameter 错误
+    if (content.includes('#')) {
+      return false;
+    }
+
+    // 单字母或字母组合在数学环境中
+    if (/^[a-zA-Z]+$/.test(content.trim())) {
+      return true;
+    }
+  }
+
+  // 特别处理：独立的单个字母或两个大写字母组合可能是数学符号
+
+  // 单字母作为独立的数学符号，常见于几何点、变量等
+  if (/^[A-Za-z]$/.test(trimmedText)) {
+    return true;
+  }
+
+  // 两个大写字母的组合，常见于向量表示如OA、AB等
+  if (/^[A-Z]{2}$/.test(trimmedText)) {
+    return true;
+  }
+
+  // 处理反斜杠问题 - 将\\text转换为\text进行判断
+  const normalizedText = text.replace(/\\\\(?=\w)/g, "\\");
+
+  // 数学坐标对或区间模式 - 匹配如 (0,c), [a,b] 形式
+  const coordinatePattern = /\([^()]+,[^()]+\)|\[[^[\]]+,[^[\]]+\]/;
+  if (coordinatePattern.test(normalizedText)) return true;
+
+  // 新增: 检查是否是代码块或变量引用(包含反引号的模式)
+  if (/\\`/.test(normalizedText)) {
+    // 先检测是否符合变量引用模式
+    if (/\$[a-zA-Z0-9_]+\\`/.test(normalizedText)) {
+      return false;
+    }
+  }
+
+  // 新增: 排除包含 # 字符的文本，避免 macro parameter 错误
+  if (normalizedText.includes('#')) {
+    return false;
+  }
+
+  // 检查是否包含LaTeX命令 - 扩展匹配范围，包括比较运算符
+  if (/\\([a-zA-Z]+|[=<>])/.test(normalizedText)) return true;
+
+  // 简单数学公式模式 - 匹配形如 c = 3, c - 3 = 0 的表达式
+  const simpleMathPattern = /\b[a-zA-Z]\s*[\+\-\*\/]?\s*\d+\s*[=<>]?\s*\d*\b/;
+  if (simpleMathPattern.test(normalizedText)) return true;
+
+  // 变量与关系运算符的组合 - 匹配形如 x = y, a < b 的表达式
+  const variableRelationPattern = /\b[a-zA-Z]\s*[=<>≤≥]\s*[a-zA-Z0-9]\b/;
+  if (variableRelationPattern.test(normalizedText)) return true;
+
+  // LaTeX关系运算符和比较运算符
+  const latexOperators = [
+    "geq", "leq", "gt", "lt", "neq", "approx", "equiv",
+    "geqslant", "leqslant", "sim", "simeq", "cong"
+  ];
+
+  // 检查常见LaTeX关系运算符
+  const relationPattern = new RegExp(`\\\\(${latexOperators.join('|')})`);
+  if (relationPattern.test(normalizedText)) return true;
+
+  // 检查是否包含除了文本外的数学结构
+  if (/\\text\{[^}]*\}.*?[=+\-*\/\^_\\]/.test(normalizedText)) return true;
+
+  // 检查常见的数学结构和符号
+  const mathPatterns = [
+    // 分数结构
+    /\\frac/,
+    // 各种括号 - 修改以排除 JSON 格式
+    /(?!^\s*[\[\{].*?\\\".*?[\]\}]\s*$)[\{\}\(\)\[\]]{2,}/,
+    // 数学运算符
+    /[+\-*\/=<>^_]/,
+    // 特殊数学符号
+    /\\(times|div|cdot|pm|mp|sum|int|infty|partial|sqrt|over)/,
+    // 矩阵命令
+    /\\(begin|end)\{(matrix|pmatrix|bmatrix|vmatrix)\}/,
+    // 求和、积分等大型运算符
+    /\\(sum|int|prod|lim)/
+  ];
+
+  for (const pattern of mathPatterns) {
+    if (pattern.test(normalizedText)) return true;
+  }
+
+  // 修改最后的数学符号检测，排除 HTML 实体编码的 JSON
+  if (normalizedText.match(/[\\^_{}]|\\[a-z]+/) &&
+      !normalizedText.match(/\\`/) &&
+      !normalizedText.includes('\\&quot;')) {
+    return true;
+  }
+  return false;
+}
+/**
+ * 提取字符串中被$或$$符号包围的且满足条件的内容
+ *  和双美元符号格式
+ * @param {string} input - 输入字符串
+ * @return {object} 包含转换后字符串和提取内容的对象
+ * 举个例子
+ *
+ *
+ 123$$ 233333 $$ 123
+ 不是公式---> 123_PLACEHOLDER1_123
+ 是公式---> 123$$ 233333 $$ 123
+
+ 之后就会进行公式处理，处理之后，会替换回来：
+ 123_PLACEHOLDER1_123 -> 123$$ 233333 $$ 123
+ *
+ */
+export function extractDollarEnclosedStrings(input) {
+  // console.log('extractDollarEnclosedStrings', input);
+  let extracted = [];
+  let result = input;
+  let placeholderIndex = 0; // 新增：用于生成递增的占位符索引
+
+  // 步骤1: 先处理双美元符号 $$...$$（暂时保护它们，不进行替换）
+  const doubleDelimiters = [];
+  const doubleDollarRegex = /\$\$([\s\S]*?)\$\$/g;
+  let doubleDollarMatch;
+  let doubleDollarPositions = []; // 记录双$的位置，用于后续判断
+
+  while ((doubleDollarMatch = doubleDollarRegex.exec(input)) !== null) {
+    // 保存双$的起始和结束位置
+    doubleDollarPositions.push({
+      start: doubleDollarMatch.index,
+      end: doubleDollarMatch.index + doubleDollarMatch[0].length - 1
+    });
+    // 保存匹配到的完整内容
+    doubleDelimiters.push(doubleDollarMatch[0]);
+  }
+
+  // 使用一个不太可能出现的标记替换双美元符号内容
+  for (let i = 0; i < doubleDelimiters.length; i++) {
+    const placeholder = `__DOUBLE_DOLLAR_TEMP_${i}__`;
+    result = result.replace(doubleDelimiters[i], placeholder);
+  }
+
+  // 步骤2: 处理 \[...\] 语法
+  const bracketRegex = /\\\[([\s\S]*?)\\\]/g;
+  let bracketMatch;
+  let bracketMatches = []; // 存储带有位置信息的匹配项
+
+  while ((bracketMatch = bracketRegex.exec(result)) !== null) {
+    bracketMatches.push({
+      full: bracketMatch[0],
+      content: bracketMatch[1],
+      start: bracketMatch.index,
+      end: bracketMatch.index + bracketMatch[0].length
+    });
+  }
+
+  // 从后向前处理 \[...\] 匹配项，避免位置偏移
+  for (let i = bracketMatches.length - 1; i >= 0; i--) {
+    const m = bracketMatches[i];
+    // 检查是否是真正的数学公式，与$...$处理方式相同
+    if (!isMathJaxFormula(m.content)) {
+      const placeholder = `__PLACEHOLDER_${placeholderIndex}__`;
+      extracted[placeholderIndex] = m.full; // 修改：直接按索引赋值
+      placeholderIndex++; // 索引递增
+      result = result.substring(0, m.start) + placeholder + result.substring(m.end);
+    }
+  }
+
+  // 步骤3: 处理单美元符号 $...$
+  const singleDollarRegex = /\$([^\$]+?)\$/g;
+  let singleDollarMatch;
+  const tempResult = result; // 临时存储结果，用于后续恢复
+  let matches = [];
+
+  while ((singleDollarMatch = singleDollarRegex.exec(tempResult)) !== null) {
+    const fullMatch = singleDollarMatch[0];
+    const content = singleDollarMatch[1];
+    const start = singleDollarMatch.index;
+    const end = start + fullMatch.length;
+
+    // 确认这是一个独立的单$公式
+    let isInDoubleDollar = false;
+    for (const pos of doubleDollarPositions) {
+      if (start >= pos.start && end <= pos.end) {
+        isInDoubleDollar = true;
+        break;
+      }
+    }
+
+    if (!isInDoubleDollar && content.trim() !== '') {
+      matches.push({
+        full: fullMatch,
+        content: content,
+        start: start,
+        end: end
+      });
+    }
+  }
+
+  // 从后向前替换，避免位置偏移
+  for (let i = matches.length - 1; i >= 0; i--) {
+    const m = matches[i];
+    // 检查是否是真正的数学公式
+    console.log('isMathJaxFormula111');
+    if (!isMathJaxFormula(m.content)) {
+      const placeholder = `__PLACEHOLDER_${placeholderIndex}__`;
+      extracted[placeholderIndex] = m.full; // 修改：直接按索引赋值
+      placeholderIndex++; // 索引递增
+      result = result.substring(0, m.start) + placeholder + result.substring(m.end);
+    }
+  }
+
+  // 步骤4: 恢复双美元符号内容的临时替换
+  for (let i = 0; i < doubleDelimiters.length; i++) {
+    const placeholder = `__DOUBLE_DOLLAR_TEMP_${i}__`;
+    result = result.replace(placeholder, doubleDelimiters[i]);
+  }
+
+  console.log('extractDollarEnclosedStrings1', result, extracted);
+  return {
+    transformed: result,
+    extracted: extracted
+  };
+}
+
+/**
+ * 将提取的内容还原回原始字符串
+ * @param {string} transformed - 转换后的字符串
+ * @param {array} extracted - 提取出的内容数组
+ * @return {string} 还原后的原始字符串
+ */
+export function restoreString(transformed, extracted, doubleDelimiters = []) {
+  let result = transformed;
+
+  // 1. 还原所有占位符，包括单美元符号和 \[...\] 的占位符
+  const singleRegex = new RegExp("__PLACEHOLDER_(\\d+)__", "g");
+  result = result.replace(singleRegex, (match, index) => {
+    const idx = parseInt(index, 10);
+    return idx < extracted.length ? extracted[idx] : match;
+  });
+
+  // 2. 再还原双美元符号的占位符
+  const doubleRegex = new RegExp("__DOUBLE_DOLLAR_TEMP_(\\d+)__", "g");
+  result = result.replace(doubleRegex, (match, index) => {
+    const idx = parseInt(index, 10);
+    return idx < doubleDelimiters.length ? doubleDelimiters[idx] : match;
+  });
+
+  return result;
+}
+// 自定义白名单
+const myWhiteList = getDefaultWhiteList();
+myWhiteList.a = ['href', 'title', 'target']; // 允许 a 标签的 href, title 和 target 属性
+myWhiteList.source = ['src', 'type']; // 允许 source 标签用于 video/audio
+
+console.log('myWhiteList', myWhiteList);
+
+export const xssHtmlOptions = {
+    css: false,
+    whiteList: myWhiteList,
+    // {
+    //     ...,
+    //     // a: ['class', 'style', 'target', 'data-link-url', 'rel', 'href', 'data-link-url'],
+    //     // table: ['width', 'border', 'cellspacing', 'cellpadding'],
+    //     // tr: [],
+    //     // td: ['width', 'colspan', 'rowspan'],
+    //     // th: ['width', 'colspan', 'rowspan'],
+    //     // tbody: [],
+    //     // thead: [],
+    //     // tfoot: []
+    //     // audio: ['class', 'style', 'controls', 'controlsList', 'src'],
+    //     // video: ['class', 'style', 'controls', 'width', 'height', 'webkit-playsinline', 'playsinline', 'x5-playsinline', 'poster', 'src'],
+    //     // p: ['class', 'style'],
+    //     // strong: ['class', 'style'],
+    //     // span: ['contenteditable'],
+    //     // div: ['class', 'style', ''],
+    // },
+    onTag: function (tag, html, options) {
+      if (tag.startsWith('mjx-') || tag.startsWith('mjx') || tag.startsWith('mj')) {
+        return html;
+      }
+      return null;
+    },
+    // 文档地址：https://www.npmjs.com/package/xss
+    onTagAttr (tag, name, value, isWhiteAttr) {
+        const hasDangerousChars = (val) => {
+          if (!val) return false;
+          // 检测以下危险模式：
+          // 1. 包含 < 或 > 字符（可能是标签注入）
+          // 2. 包含引号后紧跟 > 或空格+>（属性闭合攻击）
+          // 3. 包含 = 后紧跟引号再跟 >（属性闭合攻击变种）
+          // 4. 包含 javascript: 协议
+          // 5. 包含事件处理器关键字（onerror, onload 等）
+          // 6. 包含 on 开头的事件属性模式（支持 / 或空格作为分隔符）
+          return /[<>]|[\"']\\s*>|=\\s*[\"'][^\"']*>|javascript:|data:text\/html|onerror|onload|onclick|onmouseover|on\\w+\\s*=|vbscript:/i.test(val);
+        };
+
+        // 首先检查属性值是否包含危险字符
+        if (hasDangerousChars(value)) {
+          console.log(`阻止包含危险字符的属性: ${tag} ${name}="${value}"`);
+          return ''; // 移除包含危险字符的属性
+        }
+
+        if (tag.indexOf('_') !== -1) {
+          // 如果包含下划线，则认为是自定义标签，放过
+            return `${name}="${value}"`;
+        }
+        const tagIgnore = ['div', 'span', 'strong', 'p', 'mark'];
+        if (tagIgnore.includes(tag)) {
+            // do not filter its attributes
+            const blockAttrsReg = new RegExp('^on');
+            if (!blockAttrsReg.test(name)) {
+                return `${name}="${value}"`;
+            }
+        }
+        const tagAttrIgnore = ['class', 'style'];
+        if (tagAttrIgnore.includes(name)) {
+            return `${name}="${value}"`;
+        }
+        // 自定义属性省略
+        const aTagAttrIgnore = ['rel', 'data-link-url'];
+        if (tag === 'a' && aTagAttrIgnore.includes(name)) {
+            return `${name}="${value}"`;
+        }
+        if (tag === 'a' && name === 'href') {
+            // 允许的协议列表
+            const allowedProtocols = ['qdweb', 'qdim', 'mqqwpa'];
+            const protocol = value.split(':')[0];
+            if (allowedProtocols.includes(protocol)) {
+                return `${name}="${escapeAttrValue(value)}"`;
+            }
+        }
+        const videoTagAttrIgnore = [
+            'rel',
+            'webkit-playsinline',
+            'x5-playsinline',
+            'title',
+            'size',
+            'format'
+        ];
+        if (tag === 'video' && videoTagAttrIgnore.includes(name)) {
+            return `${name}="${value}"`;
+        }
+        const audioTagAttrIgnore = [
+            'controls',
+            'controlslist',
+            'id',
+            'speed',
+            'title',
+            'size',
+            'format',
+            'data-duration-ms'
+        ];
+        if (tag === 'audio' && audioTagAttrIgnore.includes(name)) {
+            return `${name}="${value}"`;
+        }
+        const imgTagAttrIgnore = ['alt', 'data-value'];
+        if (tag === 'img' && imgTagAttrIgnore.includes(name)) {
+            return `${name}="${value}"`;
+        }
+        // 允许所有 mjx- 开头的标签的 class 和 style 属性
+        if ((tag.startsWith('mjx-') || tag.startsWith('mjx') || tag.startsWith('mj') || tag.startsWith('mo')) && (name === 'class' || name === 'style')) {
+          // console.log('tag.startsWith 2', tag, name);
+          return `${name}="${escapeAttrValue(value)}"`;
+        }
+        // if (!isWhiteAttr) {
+        //   return '';
+        // }
+    }
+};
+
+// 特殊字符映射表
+const SPECIAL_CHAR_MAP = {
+  '$@$': 'DEOLLERQ1',
+  '$@': 'DEOLLERQ2'
+};
+
+// 反向映射表
+const REVERSE_SPECIAL_CHAR_MAP = Object.fromEntries(
+  Object.entries(SPECIAL_CHAR_MAP).map(([k, v]) => [v, k])
+);
+
+/**
+* 替换特殊字符
+* @param {string} input 输入字符串
+* @returns {string} 替换后的字符串
+*/
+export const replaceSpecialChars = (input) => {
+  let result = input;
+
+  // 遍历映射表进行替换
+  Object.entries(SPECIAL_CHAR_MAP).forEach(([original, replacement]) => {
+      // 使用全局替换
+      result = result.split(original).join(replacement);
+  });
+
+  return result;
+}
+
+/**
+* 还原特殊字符
+* @param {string} input 输入字符串
+* @returns {string} 还原后的字符串
+*/
+export const restoreSpecialChars = (input) => {
+  let result = input;
+
+  // 遍历反向映射表进行还原
+  Object.entries(REVERSE_SPECIAL_CHAR_MAP).forEach(([replacement, original]) => {
+      // 使用全局替换
+      result = result.split(replacement).join(original);
+  });
+
+  return result;
+}
+
+// 检测是否支持负向后瞻
+let supportsLookbehind = undefined;
+export const checkIsSupportsLookbehind = () => {
+  if(typeof supportsLookbehind === 'boolean') {
+    return supportsLookbehind;
+  }
+  try {
+    new RegExp('(?<!x)y');
+    supportsLookbehind = true;
+  } catch (e) {
+    supportsLookbehind = false;
+  }
+  return supportsLookbehind;
+}
+
+export const fixEmptyMarkdownLinks = (markdown) => {
+  console.log(9999, checkIsSupportsLookbehind());
+  if(checkIsSupportsLookbehind()) {
+    // 使用负向后瞻(?<!!)确保我们不匹配图片语法![](url)
+    const res = markdown.replace(new RegExp('(?<!!)\\[\\]\\((https?:\\/\\/[^)]+)\\)', 'g'), function(match, url) {
+      return '[' + url + '](' + url + ')';
+    });
+    return res;
+  } else {
+    // 捕获可能的空链接，包括前面可能的感叹号
+    return markdown.replace(new RegExp('(\\!?)(\\[\\]\\((https?:\\/\\/[^)]+)\\))', 'g'), function(match, exclamation, fullMatch, url) {
+      // 如果前面有感叹号，说明是图片语法，保持不变
+      if (exclamation === '!') {
+        return match;
+      }
+      // 否则进行替换
+      return '[' + url + '](' + url + ')';
+    });
+  }
+}