From 02cc92dda2ad9339475d0169ced155922419cc58 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E5=86=AF=E5=98=89=E9=A2=96?= <568296125@qq.com>
Date: Fri, 13 Mar 2026 23:04:03 +0800
Subject: [PATCH] =?UTF-8?q?feat:=20=E9=87=8D=E5=86=99=E5=85=AC=E5=BC=8F?=
 =?UTF-8?q?=E8=A7=A3=E6=9E=90=E4=B8=8E=E8=BD=AC=E6=8D=A2=E9=80=BB=E8=BE=91?=
 =?UTF-8?q?=EF=BC=8C=E5=8D=87=E7=BA=A7=E8=87=B3=20v3.0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

公式解析
- 废弃正则整体匹配，改用字符级逐字扫描，解决歧义和越界问题
- 完整支持 $、$$、\(...\)、\[...\] 四种公式格式
- 新增转义字符检测（isEscaped）、行内公式有效性校验
- Token 携带 start/end/lineStart/lineEnd/standaloneBlock 等精确位置信息

行内公式转换
- 通过 getTextSegments + resolveTextPosition 精确映射跨文本节点的选区
- 新增 waitForInlineInput 机制，确认公式输入框已打开再写入，
  避免误替换正文内容
- 修复行内公式在新版 Notion 界面下因输入框未就绪导致的失败问题

块公式转换
- 非独立行的块公式自动降级为行内公式（添加 \displaystyle）
- 采用 waitForCondition 轮询替代固定 sleep，大幅缩短等待时间
- 移除表格内公式的特殊处理逻辑；getEditableEditors 直接过滤表格单元格
- 删除 retryFailedBlockEquations 重试逻辑，由前置检测保证可靠性

性能与稳定性
- 引入两阶段转换：先处理全部行内公式，再处理块公式，避免位置漂移
- 关键等待时间从数百 ms 降至 10-40 ms 量级
- simulateKey / simulateShortcut 新增 target 参数，事件派发更精准
- 新增 DEBUG_MODE 开关，便于调试时输出详细日志
---
 .gitignore                             |    1 +
 Notion-Formula-Auto-Conversion-Tool.js | 1584 +++++++++++++++---------
 2 files changed, 1017 insertions(+), 568 deletions(-)

diff --git a/.gitignore b/.gitignore
index 0fd0354..1277a92 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1,2 @@
 .history/
+.DS_Store
diff --git a/Notion-Formula-Auto-Conversion-Tool.js b/Notion-Formula-Auto-Conversion-Tool.js
index 7cfde5d..b34ed59 100644
--- a/Notion-Formula-Auto-Conversion-Tool.js
+++ b/Notion-Formula-Auto-Conversion-Tool.js
@@ -1,9 +1,9 @@
 // ==UserScript==
 // @name         Notion-Formula-Auto-Conversion-Tool
 // @namespace    http://tampermonkey.net/
-// @version      2.0
+// @version      3.0
 // @description  自动公式转换工具
-// @author       skyance
+// @author       skyance、0xstride
 // @match        https://www.notion.so/*
 // @grant        GM_addStyle
 // @github       https://github.com/skyance/Notion-Formula-Auto-Conversion-Tool
@@ -12,10 +12,10 @@
 // @updateURL https://update.greasyfork.org/scripts/525730/Notion-Formula-Auto-Conversion-Tool.meta.js
 // ==/UserScript==
 
-(function() {
-    'use strict';
+(function () {
+  "use strict";
 
-    GM_addStyle(`
+  GM_addStyle(`
         /* 基础样式 */
         #formula-helper {
             position: fixed;
@@ -239,19 +239,24 @@
         }
     `);
 
-    // 缓存DOM元素
-    let panel, statusText, convertBtn, progressBar, progressContainer, collapseBtn;
-    let isProcessing = false;
-    let shouldStop = false;
-    let formulaCount = 0;
-    let isCollapsed = true;
-    let hoverTimer = null;
-
-    function createPanel() {
-        panel = document.createElement('div');
-        panel.id = 'formula-helper';
-        panel.classList.add('collapsed');
-        panel.innerHTML = `
+  // 缓存DOM元素
+  let panel,
+    statusText,
+    convertBtn,
+    progressBar,
+    progressContainer,
+    collapseBtn;
+  let isProcessing = false;
+  let shouldStop = false;
+  let formulaCount = 0;
+  let isCollapsed = true;
+  let hoverTimer = null;
+  const DEBUG_MODE = false;
+  function createPanel() {
+    panel = document.createElement("div");
+    panel.id = "formula-helper";
+    panel.classList.add("collapsed");
+    panel.innerHTML = `
             <button id="collapse-btn">
                 <svg viewBox="0 0 24 24">
                     <path d="M19 6.41L17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z"/>
@@ -265,602 +270,1045 @@
                 <div id="status-text">就绪</div>
             </div>
         `;
-        document.body.appendChild(panel);
-
-        statusText = panel.querySelector('#status-text');
-        convertBtn = panel.querySelector('#convert-btn');
-        progressBar = panel.querySelector('#progress-bar');
-        progressContainer = panel.querySelector('#progress-container');
-        collapseBtn = panel.querySelector('#collapse-btn');
-
-        // 添加收起按钮事件
-        collapseBtn.addEventListener('click', toggleCollapse);
-
-        // 添加鼠标悬停事件
-        panel.addEventListener('mouseenter', () => {
-            clearTimeout(hoverTimer);
-            if (isCollapsed) {
-                hoverTimer = setTimeout(() => {
-                    panel.classList.remove('collapsed');
-                    isCollapsed = false;
-                }, 150); // 减少展开延迟时间
-            }
-        });
+    document.body.appendChild(panel);
+
+    statusText = panel.querySelector("#status-text");
+    convertBtn = panel.querySelector("#convert-btn");
+    progressBar = panel.querySelector("#progress-bar");
+    progressContainer = panel.querySelector("#progress-container");
+    collapseBtn = panel.querySelector("#collapse-btn");
+
+    // 添加收起按钮事件
+    collapseBtn.addEventListener("click", toggleCollapse);
+
+    // 添加鼠标悬停事件
+    panel.addEventListener("mouseenter", () => {
+      clearTimeout(hoverTimer);
+      if (isCollapsed) {
+        hoverTimer = setTimeout(() => {
+          panel.classList.remove("collapsed");
+          isCollapsed = false;
+        }, 150); // 减少展开延迟时间
+      }
+    });
 
-        panel.addEventListener('mouseleave', () => {
-            clearTimeout(hoverTimer);
-            if (!isCollapsed && !isProcessing) { // 添加处理中状态判断
-                hoverTimer = setTimeout(() => {
-                    panel.classList.add('collapsed');
-                    isCollapsed = true;
-                }, 800); // 适当减少收起延迟
-            }
-        });
+    panel.addEventListener("mouseleave", () => {
+      clearTimeout(hoverTimer);
+      if (!isCollapsed && !isProcessing) {
+        // 添加处理中状态判断
+        hoverTimer = setTimeout(() => {
+          panel.classList.add("collapsed");
+          isCollapsed = true;
+        }, 800); // 适当减少收起延迟
+      }
+    });
+  }
+
+  function toggleCollapse() {
+    isCollapsed = !isCollapsed;
+    panel.classList.toggle("collapsed");
+  }
+
+  function updateProgress(current, total) {
+    const percentage = total > 0 ? (current / total) * 100 : 0;
+    progressBar.style.width = `${percentage}%`;
+  }
+
+  const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+  async function waitForCondition(
+    checkFn,
+    { timeout = 240, interval = 12 } = {},
+  ) {
+    const startTime = Date.now();
+    while (Date.now() - startTime < timeout) {
+      const result = checkFn();
+      if (result) {
+        return result;
+      }
+      await sleep(interval);
     }
+    return null;
+  }
 
-    function toggleCollapse() {
-        isCollapsed = !isCollapsed;
-        panel.classList.toggle('collapsed');
+  function updateStatus(text, timeout = 0) {
+    statusText.textContent = text;
+    if (timeout) {
+      setTimeout(() => (statusText.textContent = "就绪"), timeout);
     }
+    console.log("[状态]", text);
+  }
 
-    function updateProgress(current, total) {
-        const percentage = total > 0 ? (current / total) * 100 : 0;
-        progressBar.style.width = `${percentage}%`;
+  function describeElement(element) {
+    if (!element) {
+      return "[null]";
     }
 
-    const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+    const tag = element.tagName ? element.tagName.toLowerCase() : "unknown";
+    const id = element.id ? `#${element.id}` : "";
+    const className =
+      typeof element.className === "string"
+        ? element.className
+            .trim()
+            .split(/\s+/)
+            .filter(Boolean)
+            .slice(0, 4)
+            .join(".")
+        : "";
+    const classes = className ? `.${className}` : "";
+    const role = element.getAttribute?.("role");
+    const roleText = role ? `[role="${role}"]` : "";
+    const aria =
+      element.getAttribute?.("aria-roledescription") ||
+      element.getAttribute?.("aria-label") ||
+      "";
+    const text = (element.textContent || "")
+      .replace(/\s+/g, " ")
+      .trim()
+      .slice(0, 40);
+    return `${tag}${id}${classes}${roleText}${aria ? `("${aria}")` : ""}${text ? ` text="${text}"` : ""}`;
+  }
+
+  function debugLog(...args) {
+    if (!DEBUG_MODE) {
+      return;
+    }
+    console.log("[FormulaDebug]", ...args);
+  }
 
-    function updateStatus(text, timeout = 0) {
-        statusText.textContent = text;
-        if (timeout) {
-            setTimeout(() => statusText.textContent = '就绪', timeout);
-        }
-        console.log('[状态]', text);
+  function isEscaped(text, index) {
+    let slashCount = 0;
+    for (let i = index - 1; i >= 0 && text[i] === "\\"; i--) {
+      slashCount++;
     }
+    return slashCount % 2 === 1;
+  }
+
+  function findLineBoundaries(text, start, end) {
+    const lineStart = text.lastIndexOf("\n", start - 1) + 1;
+    const lineEndIndex = text.indexOf("\n", end);
+    const lineEnd = lineEndIndex === -1 ? text.length : lineEndIndex;
+    const before = text.slice(lineStart, start).trim();
+    const after = text.slice(end, lineEnd).trim();
+
+    return {
+      lineStart,
+      lineEnd,
+      standaloneBlock: before === "" && after === "",
+    };
+  }
+
+  function findClosingSingleDollar(text, startIndex) {
+    for (let i = startIndex; i < text.length; i++) {
+      if (text[i] === "\n") {
+        return -1;
+      }
+      if (text[i] !== "$" || isEscaped(text, i) || text[i + 1] === "$") {
+        continue;
+      }
+      return i;
+    }
+    return -1;
+  }
+
+  function findClosingDoubleDollar(text, startIndex) {
+    for (let i = startIndex; i < text.length - 1; i++) {
+      if (text[i] === "$" && text[i + 1] === "$" && !isEscaped(text, i)) {
+        return i;
+      }
+    }
+    return -1;
+  }
+
+  function findClosingLatex(text, startIndex, closeChar) {
+    for (let i = startIndex; i < text.length - 1; i++) {
+      if (
+        text[i] === "\\" &&
+        text[i + 1] === closeChar &&
+        !isEscaped(text, i)
+      ) {
+        return i;
+      }
+    }
+    return -1;
+  }
 
-    // 公式查找
-    function findFormulas(text) {
-        const formulas = [];
-        const combinedRegex = /\$\$(.*?)\$\$|\$([^\$\n]+?)\$|\\\((.*?)\\\)|\\\[(.*?)\\\]/gs;
+  function isValidInlineDollar(text, start, end) {
+    const content = text.slice(start + 1, end);
+    if (!content.trim() || /\n/.test(content)) {
+      return false;
+    }
 
-        let match;
-        while ((match = combinedRegex.exec(text)) !== null) {
-            const [fullMatch, blockFormula, inlineFormula, latexFormula, latexBlockFormula] = match;
-            const formula = fullMatch;
+    const firstChar = text[start + 1];
+    const lastChar = text[end - 1];
+    if (
+      !firstChar ||
+      !lastChar ||
+      /\s/.test(firstChar) ||
+      /\s/.test(lastChar)
+    ) {
+      return false;
+    }
 
-            if (formula) {
-                // 判断公式类型：块公式（行间）或行内公式
-                const isBlockFormula = fullMatch.startsWith('$$') || fullMatch.startsWith('\\[');
-                formulas.push({
-                    formula: fullMatch,
-                    index: match.index,
-                    type: isBlockFormula ? 'block' : 'inline',
-                    content: blockFormula || inlineFormula || latexFormula || latexBlockFormula
-                });
+    return true;
+  }
+
+  function buildFormulaToken(
+    text,
+    start,
+    end,
+    openLength,
+    closeLength,
+    type,
+    syntax,
+  ) {
+    const boundaries = findLineBoundaries(text, start, end);
+    return {
+      raw: text.slice(start, end),
+      start,
+      end,
+      type,
+      syntax,
+      content: text.slice(start + openLength, end - closeLength),
+      lineStart: boundaries.lineStart,
+      lineEnd: boundaries.lineEnd,
+      standaloneBlock: type === "block" ? boundaries.standaloneBlock : false,
+    };
+  }
+
+  // 公式查找
+  function findFormulas(text) {
+    const formulas = [];
+
+    for (let i = 0; i < text.length; i++) {
+      if (text[i] === "$" && !isEscaped(text, i)) {
+        if (text[i + 1] === "$") {
+          const closeIndex = findClosingDoubleDollar(text, i + 2);
+          if (closeIndex !== -1) {
+            const end = closeIndex + 2;
+            const token = buildFormulaToken(text, i, end, 2, 2, "block", "$$");
+            if (token.content.trim()) {
+              formulas.push(token);
             }
+            i = end - 1;
+            continue;
+          }
+        } else {
+          const closeIndex = findClosingSingleDollar(text, i + 1);
+          if (closeIndex !== -1 && isValidInlineDollar(text, i, closeIndex)) {
+            const end = closeIndex + 1;
+            formulas.push(buildFormulaToken(text, i, end, 1, 1, "inline", "$"));
+            i = end - 1;
+            continue;
+          }
         }
-
-        return formulas;
-    }
-
-    // 操作区域查找
-    async function findOperationArea() {
-        const selector = '.notion-overlay-container';
-        for (let i = 0; i < 5; i++) {
-            const areas = document.querySelectorAll(selector);
-            const area = Array.from(areas).find(a =>
-                a.style.display !== 'none' && a.querySelector('[role="button"]')
+      }
+
+      if (text[i] === "\\" && !isEscaped(text, i)) {
+        if (text[i + 1] === "(") {
+          const closeIndex = findClosingLatex(text, i + 2, ")");
+          if (closeIndex !== -1) {
+            const end = closeIndex + 2;
+            const token = buildFormulaToken(
+              text,
+              i,
+              end,
+              2,
+              2,
+              "inline",
+              "\\(\\)",
             );
+            if (token.content.trim()) {
+              formulas.push(token);
+            }
+            i = end - 1;
+            continue;
+          }
+        }
 
-            if (area) {
-                console.log('找到操作区域');
-                return area;
+        if (text[i + 1] === "[") {
+          const closeIndex = findClosingLatex(text, i + 2, "]");
+          if (closeIndex !== -1) {
+            const end = closeIndex + 2;
+            const token = buildFormulaToken(
+              text,
+              i,
+              end,
+              2,
+              2,
+              "block",
+              "\\[\\]",
+            );
+            if (token.content.trim()) {
+              formulas.push(token);
             }
-            await sleep(50);
+            i = end - 1;
+            continue;
+          }
         }
-        return null;
+      }
     }
 
-    // 按钮查找
-    async function findButton(area, options = {}) {
-        const {
-            buttonText = [],
-            hasSvg = false,
-            attempts = 8
-        } = options;
+    return formulas;
+  }
+
+  function getTextSegments(editor) {
+    const segments = [];
+    const walker = document.createTreeWalker(editor, NodeFilter.SHOW_TEXT);
+    let currentOffset = 0;
+    let node;
+
+    while ((node = walker.nextNode())) {
+      if (!node.textContent) {
+        continue;
+      }
+      segments.push({
+        node,
+        start: currentOffset,
+        end: currentOffset + node.textContent.length,
+      });
+      currentOffset += node.textContent.length;
+    }
 
-        const buttons = area.querySelectorAll('[role="button"]');
-        const cachedButtons = Array.from(buttons);
+    return segments;
+  }
 
-        for (let i = 0; i < attempts; i++) {
-            const button = cachedButtons.find(btn => {
-                if (hasSvg && btn.querySelector('svg.equation')) return true;
-                const text = btn.textContent.toLowerCase();
-                return buttonText.some(t => text.includes(t));
-            });
+  function resolveTextPosition(segments, offset, preferEnd = false) {
+    if (!segments.length) {
+      return null;
+    }
 
-            if (button) {
-                return button;
-            }
-            await sleep(50);
-        }
-        return null;
-    }
-
-    // 文本输入模拟
-    async function simulateTyping(text, quick = false) {
-        const activeElement = document.activeElement;
-        if (activeElement) {
-            if (quick) {
-                // 快速模式：直接插入整段文本 (模拟粘贴)
-                const inputEvent = new InputEvent('beforeinput', {
-                    bubbles: true,
-                    cancelable: true,
-                    inputType: 'insertText',
-                    data: text
-                });
-                activeElement.dispatchEvent(inputEvent);
-                
-                document.execCommand('insertText', false, text);
-                
-                const inputEventAfter = new InputEvent('input', {
-                    bubbles: true,
-                    cancelable: false,
-                    inputType: 'insertText',
-                    data: text
-                });
-                activeElement.dispatchEvent(inputEventAfter);
-            } else {
-                // 普通模式：逐字输入 (用于触发命令菜单等)
-                for (const char of text) {
-                    const inputEvent = new InputEvent('beforeinput', {
-                        bubbles: true,
-                        cancelable: true,
-                        inputType: 'insertText',
-                        data: char
-                    });
-                    activeElement.dispatchEvent(inputEvent);
-                    
-                    document.execCommand('insertText', false, char);
-                    
-                    const inputEventAfter = new InputEvent('input', {
-                        bubbles: true,
-                        cancelable: false,
-                        inputType: 'insertText',
-                        data: char
-                    });
-                    activeElement.dispatchEvent(inputEventAfter);
-                    
-                    await sleep(5);
-                }
-            }
-        }
+    if (offset <= 0) {
+      return { node: segments[0].node, offset: 0 };
     }
 
-    // 单个按键模拟
-    async function simulateKey(keyName) {
-        const keyInfo = getKeyCode(keyName);
-        const keydownEvent = new KeyboardEvent('keydown', {
-            key: keyInfo.key,
-            code: keyInfo.code,
-            keyCode: keyInfo.keyCode,
-            bubbles: true
-        });
-        const keyupEvent = new KeyboardEvent('keyup', {
-            key: keyInfo.key,
-            code: keyInfo.code,
-            keyCode: keyInfo.keyCode,
-            bubbles: true
-        });
-        
-        document.dispatchEvent(keydownEvent);
-        await sleep(30);
-        document.dispatchEvent(keyupEvent);
+    for (const segment of segments) {
+      const inSegment = preferEnd
+        ? offset > segment.start && offset <= segment.end
+        : offset >= segment.start && offset < segment.end;
+
+      if (inSegment) {
+        return {
+          node: segment.node,
+          offset: Math.min(
+            segment.node.textContent.length,
+            offset - segment.start,
+          ),
+        };
+      }
+
+      if (preferEnd && offset === segment.end) {
+        return { node: segment.node, offset: segment.node.textContent.length };
+      }
     }
 
-    // 聚焦到目标元素，避免表格单元格或行顺序错位
-    async function ensureFocus(element) {
-        if (!element) return;
-        element.focus();
-        await simulateClick(element);
+    const lastSegment = segments[segments.length - 1];
+    return {
+      node: lastSegment.node,
+      offset: lastSegment.node.textContent.length,
+    };
+  }
+
+  function createRangeFromOffsets(editor, start, end) {
+    const segments = getTextSegments(editor);
+    if (!segments.length) {
+      return null;
     }
 
-    // 检查元素是否在表格内
-    function isInTable(element) {
-        return !!element.closest('.notion-simple-table-block, .notion-table-view, [role="gridcell"], [role="cell"], td, th');
+    const startPos = resolveTextPosition(segments, start, false);
+    const endPos = resolveTextPosition(segments, end, true);
+    if (!startPos || !endPos) {
+      return null;
     }
 
-    // 优化的公式转换
-    async function convertFormula(editor, formulaObj) {
-        try {
-            let { formula, type, content } = formulaObj;
+    const range = document.createRange();
+    range.setStart(startPos.node, startPos.offset);
+    range.setEnd(endPos.node, endPos.offset);
+    return range;
+  }
+
+  async function focusEditor(editor) {
+    if (!editor) return;
+    editor.focus();
+    await sleep(10);
+  }
+
+  async function selectRange(editor, start, end) {
+    const range = createRangeFromOffsets(editor, start, end);
+    if (!range) {
+      return null;
+    }
 
-            // 如果在表格内，强制使用行内公式模式（表格内不支持/block equation）
-            if (type === 'block' && isInTable(editor)) {
-                console.log('检测到表格内块公式，自动转换为行内模式');
-                type = 'inline';
-                // 可选：添加 displaystyle 以保持块级显示效果
-                // if (!content.trim().startsWith('\\displaystyle')) {
-                //    content = '\\displaystyle ' + content;
-                // }
-            }
-            const walker = document.createTreeWalker(editor, NodeFilter.SHOW_TEXT);
-            const textNodes = [];
-            let node;
-
-            while (node = walker.nextNode()) {
-                if (node.textContent.includes(formula)) {
-                    textNodes.unshift(node);
-                }
-            }
+    await focusEditor(editor);
+    const selection = window.getSelection();
+    selection.removeAllRanges();
+    selection.addRange(range);
+    await sleep(10);
+    return range;
+  }
+
+  function normalizeFormulaContent(content, { useDisplayStyle = false } = {}) {
+    let normalized = content.trim();
+    if (
+      useDisplayStyle &&
+      normalized &&
+      !/^\\displaystyle\b/.test(normalized)
+    ) {
+      normalized = `\\displaystyle ${normalized}`;
+    }
+    return normalized;
+  }
 
-            if (!textNodes.length) {
-                console.warn('未找到匹配的文本');
-                return;
-            }
+  function isSafeInlineInputElement(element, editor) {
+    if (!element || element === editor) {
+      return false;
+    }
 
-            const targetNode = textNodes[0];
-            const startOffset = targetNode.textContent.indexOf(formula);
-            const range = document.createRange();
-            range.setStart(targetNode, startOffset);
-            range.setEnd(targetNode, startOffset + formula.length);
-
-            const selection = window.getSelection();
-            selection.removeAllRanges();
-            selection.addRange(range);
-
-            await ensureFocus(targetNode.parentElement);
-            await sleep(60);
-
-            if (type === 'block') {
-                // 块公式：删除选中文本，输入 /block equation 命令
-                document.execCommand('delete');
-                await sleep(100);
-
-                // 重新焦点聚焦，确保光标在正确位置
-                await ensureFocus(targetNode.parentElement);
-                await sleep(80);
-                
-                // 输入 /block equation 命令
-                await simulateTyping('/block equation', true);
-                await sleep(240);
-
-                // 优先按 Enter 选择命令
-                await simulateKey('Enter');
-                await sleep(100);
-                
-                // 清空并输入公式内容（去掉 $$ 符号）
-                await simulateTyping(content, true);
-                await sleep(100);
-
-                // 按 Enter 完成编辑（而非 Escape），避免行序错乱
-                await simulateKey('Enter');
-                await sleep(150);
-                
-                // 再次焦点回到原编辑区域，稳定行顺序
-                await ensureFocus(targetNode.parentElement);
-                await sleep(80);
-            } else {
-                // 行内公式：使用快捷键
-                const isMac = navigator.platform.toUpperCase().indexOf('MAC') >= 0;
-                await ensureFocus(targetNode.parentElement);
-                await simulateShortcut(isMac ? 'Meta+Shift+E' : 'Ctrl+Shift+E');
-                await sleep(100);
-                
-                // 清空并输入公式内容（去掉 $ 符号）
-                document.execCommand('selectAll');
-                await sleep(30);
-                await simulateTyping(content, true);
-                await sleep(50);
-                
-                // 按 Enter 确认
-                await simulateKey('Enter');
-                await sleep(50);
-            }
+    if (element.closest("#formula-helper")) {
+      return false;
+    }
 
-            return true;
-        } catch (error) {
-            console.error('转换公式时出错:', error);
-            updateStatus(`错误: ${error.message}`);
-            throw error;
-        }
-    }
-
-    // 检测并修复失败的块公式转换
-    async function retryFailedBlockEquations() {
-        try {
-            updateStatus('扫描未成功转换的公式...');
-            
-            const editors = document.querySelectorAll('[contenteditable="true"]');
-            let retryCount = 0;
-            
-            for (const editor of editors) {
-                if (shouldStop) break;
-                const walker = document.createTreeWalker(editor, NodeFilter.SHOW_TEXT);
-                const textNodes = [];
-                let node;
-                
-                // 收集所有文本节点
-                while (node = walker.nextNode()) {
-                    textNodes.push(node);
-                }
-                
-                // 查找 /block equation
-                for (let i = 0; i < textNodes.length; i++) {
-                    if (shouldStop) break;
-                    const node = textNodes[i];
-                    if (node.textContent.includes('/block equation')) {
-                        console.log('找到失败的块公式标记');
-                        
-                        // 删除 /block equation 文本
-                        const startOffset = node.textContent.indexOf('/block equation');
-                        const range = document.createRange();
-                        range.setStart(node, startOffset);
-                        range.setEnd(node, startOffset + '/block equation'.length);
-                        
-                        const selection = window.getSelection();
-                        selection.removeAllRanges();
-                        selection.addRange(range);
-                        
-                        await ensureFocus(node.parentElement);
-                        await sleep(50);
-                        document.execCommand('delete');
-                        await sleep(80);
-                        
-                        // 查找该行后面的内容（已无 $$ 格式）
-                        if (i + 1 < textNodes.length) {
-                            const nextNode = textNodes[i + 1];
-                            const content = nextNode.textContent.trim();
-                            
-                            if (content && content.length > 0) {
-                                console.log('重新转换失败的块公式，内容:', content);
-                                
-                                // 选中下一行全部内容
-                                const formulaRange = document.createRange();
-                                formulaRange.selectNodeContents(nextNode);
-                                
-                                selection.removeAllRanges();
-                                selection.addRange(formulaRange);
-                                
-                                await ensureFocus(nextNode.parentElement);
-                                await sleep(60);
-                                
-                                // 删除该行内容
-                                document.execCommand('delete');
-                                await sleep(80);
-                                
-                                // 重新输入 /block equation 命令
-                                await simulateTyping('/block equation', true);
-                                await sleep(240);
-                                
-                                // 优先按 Enter 选择命令
-                                await simulateKey('Enter');
-                                await sleep(80);
-                                
-                                // 输入公式内容
-                                await simulateTyping(content, true);
-                                await sleep(80);
-                                
-                                // 按 Escape 完成编辑
-                                await simulateKey('Escape');
-                                await sleep(120);
-                                
-                                retryCount++;
-                                updateStatus(`重新转换失败公式... (${retryCount})`);
-                                await sleep(150);
-                            }
-                        }
-                    }
-                }
-            }
-            
-            if (retryCount > 0) {
-                updateStatus(`完成修复 ${retryCount} 个失败公式`, 3000);
-                console.log('修复完成，失败公式数:', retryCount);
-            } else {
-                updateStatus('未找到失败的公式', 2000);
-            }
-            
-            return retryCount;
-        } catch (error) {
-            console.error('修复失败公式时出错:', error);
-            updateStatus(`修复出错: ${error.message}`, 3000);
-            return 0;
-        }
-    }
-
-    // 优化的主转换函数
-    async function convertFormulas() {
-        if (isProcessing) return;
-        isProcessing = true;
-        shouldStop = false;
-        convertBtn.classList.add('processing');
-        convertBtn.textContent = '取消';
-
-        try {
-            formulaCount = 0;
-            updateStatus('开始扫描文档... (按ESC取消)');
-
-            const editors = document.querySelectorAll('[contenteditable="true"]');
-            console.log('找到编辑区域数量:', editors.length);
-
-            // 预先收集所有公式
-            const allFormulas = [];
-            let totalFormulas = 0;
-            for (const editor of editors) {
-                const text = editor.textContent;
-                const formulas = findFormulas(text);
-                totalFormulas += formulas.length;
-                allFormulas.push({ editor, formulas });
-            }
+    if (element.tagName === "INPUT" || element.tagName === "TEXTAREA") {
+      return true;
+    }
 
-            if (totalFormulas === 0) {
-                updateStatus('未找到需要转换的公式', 3000);
-                updateProgress(0, 0);
-                convertBtn.classList.remove('processing');
-                isProcessing = false;
-                return;
-            }
+    if (!element.isContentEditable) {
+      return false;
+    }
 
-            updateStatus(`找到 ${totalFormulas} 个公式，开始转换...`);
-
-            // 从末尾开始处理公式
-            for (const { editor, formulas } of allFormulas.reverse()) {
-                if (shouldStop) break;
-                for (const formulaObj of formulas.reverse()) {
-                    if (shouldStop) break;
-                    await convertFormula(editor, formulaObj);
-                    formulaCount++;
-                    updateProgress(formulaCount, totalFormulas);
-                    updateStatus(`正在转换... (${formulaCount}/${totalFormulas}) [${formulaObj.type}]`);
-                    // 给Notion更多时间处理块公式
-                    if (formulaObj.type === 'block') {
-                        await sleep(150);
-                    }
-                }
-            }
+    if (editor.contains(element)) {
+      return true;
+    }
 
-            if (shouldStop) {
-                updateStatus(`已取消。已完成: ${formulaCount}`, 3000);
-            } else {
-                updateStatus(`初始转换完成，开始核对...`);
-                await sleep(500);
-                
-                // 核对并修复失败的块公式转换
-                await retryFailedBlockEquations();
-                
-                updateStatus(`Done:${formulaCount}`, 3000);
-            }
-            
-            convertBtn.textContent = `🔄 (${formulaCount})`;
-
-            // 转换完成后自动收起面板
-            setTimeout(() => {
-                if (!panel.classList.contains('collapsed')) {
-                    panel.classList.add('collapsed');
-                    isCollapsed = true;
-                }
-            }, 1000);
-
-        } catch (error) {
-            console.error('转换过程出错:', error);
-            updateStatus(`发生错误: ${error.message}`, 5000);
-            updateProgress(0, 0);
-        } finally {
-            isProcessing = false;
-            convertBtn.classList.remove('processing');
-
-            setTimeout(() => {
-                if (!isProcessing) {
-                    updateProgress(0, 0);
-                }
-            }, 1000);
-        }
-    }
-
-    // 点击事件模拟
-    async function simulateClick(element) {
-        const rect = element.getBoundingClientRect();
-        const centerX = rect.left + rect.width / 2;
-        const centerY = rect.top + rect.height / 2;
-
-        const events = [
-            new MouseEvent('mousemove', { bubbles: true, clientX: centerX, clientY: centerY }),
-            new MouseEvent('mouseenter', { bubbles: true, clientX: centerX, clientY: centerY }),
-            new MouseEvent('mousedown', { bubbles: true, clientX: centerX, clientY: centerY }),
-            new MouseEvent('mouseup', { bubbles: true, clientX: centerX, clientY: centerY }),
-            new MouseEvent('click', { bubbles: true, clientX: centerX, clientY: centerY })
-        ];
-
-        for (const event of events) {
-            element.dispatchEvent(event);
-            await sleep(20);
-        }
-    }
-
-    // 键盘快捷键模拟
-    async function simulateShortcut(keyCombination) {
-        const keys = keyCombination.split('+');
-        const keyEvents = [];
-
-        // 创建键盘事件
-        for (const key of keys) {
-            const isModifier = ['ctrl', 'shift', 'alt', 'meta'].includes(key.toLowerCase());
-            const keyCode = getKeyCode(key);
-
-            keyEvents.push({
-                key: keyCode.key,
-                code: keyCode.code,
-                keyCode: keyCode.keyCode,
-                ctrlKey: keys.includes('Ctrl'),
-                shiftKey: keys.includes('Shift'),
-                altKey: keys.includes('Alt'),
-                metaKey: keys.includes('Meta'),
-                bubbles: true
-            });
-        }
-
-        // 先按下所有修饰键
-        for (let i = 0; i < keyEvents.length - 1; i++) {
-            const event = keyEvents[i];
-            document.dispatchEvent(new KeyboardEvent('keydown', event));
-        }
-
-        // 按下最终按键
-        const finalEvent = keyEvents[keyEvents.length - 1];
-        document.dispatchEvent(new KeyboardEvent('keydown', finalEvent));
-        document.dispatchEvent(new KeyboardEvent('keyup', finalEvent));
-
-        // 释放所有修饰键
-        for (let i = keyEvents.length - 2; i >= 0; i--) {
-            const event = keyEvents[i];
-            document.dispatchEvent(new KeyboardEvent('keyup', event));
-        }
-
-        await sleep(100);
-    }
-
-    // 获取键盘按键信息
-    function getKeyCode(key) {
-        const keyMap = {
-            'ctrl': { key: 'Control', code: 'ControlLeft', keyCode: 17 },
-            'shift': { key: 'Shift', code: 'ShiftLeft', keyCode: 16 },
-            'alt': { key: 'Alt', code: 'AltLeft', keyCode: 18 },
-            'meta': { key: 'Meta', code: 'MetaLeft', keyCode: 91 },
-            'enter': { key: 'Enter', code: 'Enter', keyCode: 13 },
-            'escape': { key: 'Escape', code: 'Escape', keyCode: 27 },
-            'e': { key: 'e', code: 'KeyE', keyCode: 69 }
-        };
+    return !!element.closest(
+      '.notion-overlay-container, [role="dialog"], .notion-modal',
+    );
+  }
 
-        return keyMap[key.toLowerCase()] || { key: key, code: `Key${key.toUpperCase()}`, keyCode: key.charCodeAt(0) };
+  function selectElementContents(element) {
+    if (!element) {
+      return false;
     }
 
-    // 初始化
-    createPanel();
-    convertBtn.addEventListener('click', () => {
-        if (isProcessing) {
-            shouldStop = true;
-            updateStatus('正在取消...');
-        } else {
-            convertFormulas();
-        }
+    element.focus();
+
+    if (typeof element.select === "function") {
+      element.select();
+      return true;
+    }
+
+    if (element.isContentEditable) {
+      const selection = window.getSelection();
+      const range = document.createRange();
+      range.selectNodeContents(element);
+      selection.removeAllRanges();
+      selection.addRange(range);
+      return true;
+    }
+
+    return false;
+  }
+
+  function isVisibleElement(element) {
+    if (!element) {
+      return false;
+    }
+    const style = window.getComputedStyle(element);
+    if (style.display === "none" || style.visibility === "hidden") {
+      return false;
+    }
+    return element.getClientRects().length > 0;
+  }
+
+  function findInlineInputCandidate(editor) {
+    const localSelectors = 'input, textarea, [contenteditable="true"]';
+    const globalSelectors = [
+      ".notion-overlay-container input",
+      ".notion-overlay-container textarea",
+      '.notion-overlay-container [contenteditable="true"]',
+      '[role="dialog"] input',
+      '[role="dialog"] textarea',
+      '[role="dialog"] [contenteditable="true"]',
+      ".notion-modal input",
+      ".notion-modal textarea",
+      '.notion-modal [contenteditable="true"]',
+    ];
+
+    const candidates = [
+      ...Array.from(editor.querySelectorAll(localSelectors)),
+      ...Array.from(document.querySelectorAll(globalSelectors.join(","))),
+    ];
+    debugLog("inline input candidates", candidates.map(describeElement));
+    return (
+      candidates.find(
+        (candidate) =>
+          isVisibleElement(candidate) &&
+          isSafeInlineInputElement(candidate, editor),
+      ) || null
+    );
+  }
+
+  async function waitForInlineInput(editor, attempts = 8, interval = 12) {
+    for (let i = 0; i < attempts; i++) {
+      const activeElement = document.activeElement;
+      debugLog(`waitForInlineInput attempt ${i + 1}`, {
+        activeElement: describeElement(activeElement),
+        editor: describeElement(editor),
+      });
+      if (isSafeInlineInputElement(activeElement, editor)) {
+        return activeElement;
+      }
+
+      const candidate = findInlineInputCandidate(editor);
+      if (candidate) {
+        return candidate;
+      }
+
+      await sleep(interval);
+    }
+    return null;
+  }
+
+  function getEditableEditors() {
+    return Array.from(
+      document.querySelectorAll('[contenteditable="true"]'),
+    ).filter((editor) => {
+      if (editor.closest("#formula-helper")) {
+        return false;
+      }
+      if (
+        editor.closest(
+          '.notion-simple-table-block, .notion-table-view, [role="gridcell"], [role="cell"], td, th',
+        )
+      ) {
+        return false;
+      }
+      if (!editor.textContent || !editor.textContent.trim()) {
+        return false;
+      }
+      if (editor.getClientRects().length === 0) {
+        return false;
+      }
+      return !editor.querySelector('[contenteditable="true"]');
     });
+  }
 
-    // 监听ESC键取消
-    document.addEventListener('keydown', (e) => {
-        if (e.key === 'Escape' && isProcessing) {
-            shouldStop = true;
-            updateStatus('正在取消...');
+  function collectFormulaTasks(filterFn = () => true) {
+    const tasks = [];
+
+    for (const editor of getEditableEditors()) {
+      const formulas = findFormulas(editor.textContent).filter(filterFn);
+      if (!formulas.length) {
+        continue;
+      }
+      tasks.push({ editor, formulas });
+    }
+
+    return tasks;
+  }
+
+  function restoreSelection(range) {
+    if (!range) {
+      return;
+    }
+    const selection = window.getSelection();
+    selection.removeAllRanges();
+    selection.addRange(range);
+    debugLog("selection restored", {
+      text: selection.toString(),
+      anchorNode: selection.anchorNode?.textContent?.slice(0, 60) || null,
+    });
+  }
+
+  async function openInlineEquationEditor(editor, selectedRange = null) {
+    const isMac = navigator.platform.toUpperCase().indexOf("MAC") >= 0;
+    restoreSelection(selectedRange);
+    debugLog("openInlineEquationEditor shortcut mode", {
+      editor: describeElement(editor),
+      selectedText: selectedRange?.toString() || "",
+      activeElement: describeElement(document.activeElement),
+    });
+    await simulateShortcut(isMac ? "Meta+Shift+E" : "Ctrl+Shift+E", editor);
+    await sleep(10);
+    return true;
+  }
+
+  // 文本输入模拟
+  async function simulateTyping(text, quick = false) {
+    const activeElement = document.activeElement;
+    if (activeElement) {
+      if (quick) {
+        // 快速模式：直接插入整段文本 (模拟粘贴)
+        const inputEvent = new InputEvent("beforeinput", {
+          bubbles: true,
+          cancelable: true,
+          inputType: "insertText",
+          data: text,
+        });
+        activeElement.dispatchEvent(inputEvent);
+
+        document.execCommand("insertText", false, text);
+
+        const inputEventAfter = new InputEvent("input", {
+          bubbles: true,
+          cancelable: false,
+          inputType: "insertText",
+          data: text,
+        });
+        activeElement.dispatchEvent(inputEventAfter);
+      } else {
+        // 普通模式：逐字输入 (用于触发命令菜单等)
+        for (const char of text) {
+          const inputEvent = new InputEvent("beforeinput", {
+            bubbles: true,
+            cancelable: true,
+            inputType: "insertText",
+            data: char,
+          });
+          activeElement.dispatchEvent(inputEvent);
+
+          document.execCommand("insertText", false, char);
+
+          const inputEventAfter = new InputEvent("input", {
+            bubbles: true,
+            cancelable: false,
+            inputType: "insertText",
+            data: char,
+          });
+          activeElement.dispatchEvent(inputEventAfter);
+
+          await sleep(5);
         }
+      }
+    }
+  }
+
+  // 单个按键模拟
+  async function simulateKey(keyName, target = null) {
+    const keyInfo = getKeyCode(keyName);
+    const eventTarget =
+      target || document.activeElement || document.body || document;
+    const keydownEvent = new KeyboardEvent("keydown", {
+      key: keyInfo.key,
+      code: keyInfo.code,
+      keyCode: keyInfo.keyCode,
+      bubbles: true,
     });
+    const keyupEvent = new KeyboardEvent("keyup", {
+      key: keyInfo.key,
+      code: keyInfo.code,
+      keyCode: keyInfo.keyCode,
+      bubbles: true,
+    });
+
+    eventTarget.dispatchEvent(keydownEvent);
+    await sleep(10);
+    eventTarget.dispatchEvent(keyupEvent);
+  }
+
+  // 聚焦到目标元素，避免行顺序错位
+  async function ensureFocus(element) {
+    if (!element) return;
+    element.focus();
+    await sleep(8);
+    if (document.activeElement !== element) {
+      await simulateClick(element);
+    }
+  }
+
+  // 优化的公式转换
+  async function convertFormula(editor, formulaObj) {
+    try {
+      let { type, content, start, end, lineStart, lineEnd, standaloneBlock } =
+        formulaObj;
+      let renderMode = type;
+      let useDisplayStyle = false;
+
+      debugLog("convertFormula start", {
+        editor: describeElement(editor),
+        type,
+        syntax: formulaObj.syntax,
+        start,
+        end,
+        content,
+      });
+
+      if (type === "block" && !standaloneBlock) {
+        console.log("检测到非独立行块公式，自动降级为行内公式");
+        renderMode = "inline";
+        useDisplayStyle = true;
+      }
+
+      const rangeStart = renderMode === "block" ? lineStart : start;
+      const rangeEnd = renderMode === "block" ? lineEnd : end;
+      const range = await selectRange(editor, rangeStart, rangeEnd);
+      if (!range) {
+        console.warn("未找到匹配的文本范围");
+        return false;
+      }
+
+      debugLog("convertFormula range selected", {
+        renderMode,
+        selectedText: range.toString(),
+        activeElement: describeElement(document.activeElement),
+      });
+
+      const normalizedContent = normalizeFormulaContent(content, {
+        useDisplayStyle,
+      });
+
+      if (renderMode === "block") {
+        // 块公式：清空整行，再创建 block equation
+        const originalText = editor.textContent;
+        document.execCommand("delete");
+        await waitForCondition(
+          () =>
+            editor.textContent !== originalText ||
+            document.activeElement !== editor,
+          {
+            timeout: 120,
+            interval: 10,
+          },
+        );
+
+        // 重新焦点聚焦，确保光标留在当前块
+        await ensureFocus(editor);
+        await sleep(16);
+
+        // 输入 /block equation 命令
+        await simulateTyping("/block equation", true);
+        await sleep(40);
+
+        // 优先按 Enter 选择命令
+        await simulateKey("Enter");
+        const blockInput = await waitForInlineInput(editor, 10, 15);
+        if (!blockInput) {
+          updateStatus("块公式输入框未打开，已跳过当前公式", 4000);
+          return false;
+        }
+
+        // 输入公式内容
+        if (!selectElementContents(blockInput)) {
+          updateStatus("无法安全选中块公式输入框，已跳过当前公式", 4000);
+          return false;
+        }
+        await simulateTyping(normalizedContent, true);
+        await sleep(16);
+
+        // 按 Enter 完成编辑（而非 Escape），避免行序错乱
+        await simulateKey("Enter", blockInput);
+        await waitForCondition(() => document.activeElement !== blockInput, {
+          timeout: 140,
+          interval: 10,
+        });
+
+        // 再次焦点回到原编辑区域，稳定行顺序
+        await ensureFocus(editor);
+        await sleep(16);
+      } else {
+        const opened = await openInlineEquationEditor(editor, range);
+        if (!opened) {
+          return false;
+        }
+
+        // 仅在焦点进入独立公式输入框时继续，避免误伤正文
+        const inlineInput = await waitForInlineInput(editor);
+        if (!inlineInput) {
+          updateStatus(
+            "行内公式输入框未打开，已跳过当前公式以避免误替换",
+            4000,
+          );
+          return false;
+        }
+
+        if (!selectElementContents(inlineInput)) {
+          updateStatus("无法安全选中行内公式输入框，已跳过当前公式", 4000);
+          return false;
+        }
+
+        debugLog("inline input ready", {
+          inlineInput: describeElement(inlineInput),
+          activeElement: describeElement(document.activeElement),
+          selectedText: window.getSelection()?.toString() || "",
+        });
+
+        await simulateTyping(normalizedContent, true);
+        await sleep(10);
+
+        debugLog("inline input typed", {
+          activeElement: describeElement(document.activeElement),
+          inlineInputText: inlineInput.value || inlineInput.textContent || "",
+        });
+
+        // 按 Enter 确认
+        await simulateKey("Enter", inlineInput);
+        await waitForCondition(() => document.activeElement !== inlineInput, {
+          timeout: 140,
+          interval: 10,
+        });
+        debugLog("inline input confirmed", {
+          activeElement: describeElement(document.activeElement),
+          editorText: editor.textContent,
+        });
+      }
 
-    // 页面加载完成后检查公式数量
-    setTimeout(() => {
-        const formulas = findFormulas(document.body.textContent);
-        if (formulas.length > 0) {
-            convertBtn.textContent = `🔄(${formulas.length})`;
+      return renderMode;
+    } catch (error) {
+      console.error("转换公式时出错:", error);
+      updateStatus(`错误: ${error.message}`);
+      throw error;
+    }
+  }
+
+  // 优化的主转换函数
+  async function convertFormulas() {
+    if (isProcessing) return;
+    isProcessing = true;
+    shouldStop = false;
+    convertBtn.classList.add("processing");
+    convertBtn.textContent = "取消";
+
+    try {
+      formulaCount = 0;
+      updateStatus("开始扫描文档... (按ESC取消)");
+
+      const initialTasks = collectFormulaTasks();
+      const totalFormulas = initialTasks.reduce(
+        (sum, item) => sum + item.formulas.length,
+        0,
+      );
+
+      if (totalFormulas === 0) {
+        updateStatus("未找到需要转换的公式", 3000);
+        updateProgress(0, 0);
+        convertBtn.classList.remove("processing");
+        isProcessing = false;
+        return;
+      }
+
+      updateStatus(`找到 ${totalFormulas} 个公式，开始转换...`);
+
+      const phases = [
+        {
+          name: "行内公式",
+          getTasks: () =>
+            initialTasks
+              .map(({ editor, formulas }) => ({
+                editor,
+                formulas: formulas.filter(
+                  (formula) => formula.type === "inline",
+                ),
+              }))
+              .filter((item) => item.formulas.length),
+        },
+        {
+          name: "块公式",
+          getTasks: () =>
+            collectFormulaTasks((formula) => formula.type === "block"),
+        },
+      ];
+
+      for (const phase of phases) {
+        if (shouldStop) break;
+        const phaseTasks = phase.getTasks();
+        if (!phaseTasks.length) {
+          continue;
+        }
+
+        updateStatus(
+          `开始转换${phase.name}... (${formulaCount}/${totalFormulas})`,
+        );
+
+        // 每个阶段独立处理，避免块级转换破坏后续行内公式定位
+        for (const { editor, formulas } of phaseTasks.slice().reverse()) {
+          if (shouldStop) break;
+          for (const formulaObj of formulas.slice().reverse()) {
+            if (shouldStop) break;
+            const result = await convertFormula(editor, formulaObj);
+            if (!result) {
+              continue;
+            }
+            const renderMode = result;
+            formulaCount++;
+            updateProgress(formulaCount, totalFormulas);
+            if (
+              formulaCount === 1 ||
+              formulaCount === totalFormulas ||
+              formulaCount % 5 === 0 ||
+              renderMode === "block"
+            ) {
+              updateStatus(
+                `正在转换... (${formulaCount}/${totalFormulas}) [${formulaObj.syntax} -> ${renderMode}]`,
+              );
+            }
+            if (renderMode === "block") {
+              await sleep(24);
+            }
+          }
+        }
+      }
+
+      if (shouldStop) {
+        updateStatus(`已取消。已完成: ${formulaCount}`, 3000);
+      } else {
+        updateStatus(`Done:${formulaCount}`, 3000);
+      }
+
+      convertBtn.textContent = `🔄 (${formulaCount})`;
+
+      // 转换完成后自动收起面板
+      setTimeout(() => {
+        if (!panel.classList.contains("collapsed")) {
+          panel.classList.add("collapsed");
+          isCollapsed = true;
+        }
+      }, 1000);
+    } catch (error) {
+      console.error("转换过程出错:", error);
+      updateStatus(`发生错误: ${error.message}`, 5000);
+      updateProgress(0, 0);
+    } finally {
+      isProcessing = false;
+      convertBtn.classList.remove("processing");
+
+      setTimeout(() => {
+        if (!isProcessing) {
+          updateProgress(0, 0);
         }
-    }, 1000);
+      }, 1000);
+    }
+  }
+
+  // 点击事件模拟
+  async function simulateClick(element) {
+    const rect = element.getBoundingClientRect();
+    const centerX = rect.left + rect.width / 2;
+    const centerY = rect.top + rect.height / 2;
+
+    const events = [
+      new MouseEvent("mousemove", {
+        bubbles: true,
+        clientX: centerX,
+        clientY: centerY,
+      }),
+      new MouseEvent("mouseenter", {
+        bubbles: true,
+        clientX: centerX,
+        clientY: centerY,
+      }),
+      new MouseEvent("mousedown", {
+        bubbles: true,
+        clientX: centerX,
+        clientY: centerY,
+      }),
+      new MouseEvent("mouseup", {
+        bubbles: true,
+        clientX: centerX,
+        clientY: centerY,
+      }),
+      new MouseEvent("click", {
+        bubbles: true,
+        clientX: centerX,
+        clientY: centerY,
+      }),
+    ];
+
+    for (const event of events) {
+      element.dispatchEvent(event);
+      await sleep(8);
+    }
+  }
+
+  // 键盘快捷键模拟
+  async function simulateShortcut(keyCombination, target = null) {
+    const keys = keyCombination.split("+");
+    const keyEvents = [];
+    const eventTarget =
+      target || document.activeElement || document.body || document;
+
+    // 创建键盘事件
+    for (const key of keys) {
+      const keyCode = getKeyCode(key);
+
+      keyEvents.push({
+        key: keyCode.key,
+        code: keyCode.code,
+        keyCode: keyCode.keyCode,
+        ctrlKey: keys.includes("Ctrl"),
+        shiftKey: keys.includes("Shift"),
+        altKey: keys.includes("Alt"),
+        metaKey: keys.includes("Meta"),
+        bubbles: true,
+      });
+    }
+
+    // 先按下所有修饰键
+    for (let i = 0; i < keyEvents.length - 1; i++) {
+      const event = keyEvents[i];
+      eventTarget.dispatchEvent(new KeyboardEvent("keydown", event));
+    }
+
+    // 按下最终按键
+    const finalEvent = keyEvents[keyEvents.length - 1];
+    eventTarget.dispatchEvent(new KeyboardEvent("keydown", finalEvent));
+    eventTarget.dispatchEvent(new KeyboardEvent("keyup", finalEvent));
+
+    // 释放所有修饰键
+    for (let i = keyEvents.length - 2; i >= 0; i--) {
+      const event = keyEvents[i];
+      eventTarget.dispatchEvent(new KeyboardEvent("keyup", event));
+    }
+
+    await sleep(10);
+  }
+
+  // 获取键盘按键信息
+  function getKeyCode(key) {
+    const keyMap = {
+      ctrl: { key: "Control", code: "ControlLeft", keyCode: 17 },
+      shift: { key: "Shift", code: "ShiftLeft", keyCode: 16 },
+      alt: { key: "Alt", code: "AltLeft", keyCode: 18 },
+      meta: { key: "Meta", code: "MetaLeft", keyCode: 91 },
+      enter: { key: "Enter", code: "Enter", keyCode: 13 },
+      escape: { key: "Escape", code: "Escape", keyCode: 27 },
+      e: { key: "e", code: "KeyE", keyCode: 69 },
+    };
+
+    return (
+      keyMap[key.toLowerCase()] || {
+        key: key,
+        code: `Key${key.toUpperCase()}`,
+        keyCode: key.toUpperCase().charCodeAt(0),
+      }
+    );
+  }
+
+  // 初始化
+  createPanel();
+  convertBtn.addEventListener("click", () => {
+    if (isProcessing) {
+      shouldStop = true;
+      updateStatus("正在取消...");
+    } else {
+      convertFormulas();
+    }
+  });
+
+  // 监听ESC键取消
+  document.addEventListener("keydown", (e) => {
+    if (e.key === "Escape" && isProcessing) {
+      shouldStop = true;
+      updateStatus("正在取消...");
+    }
+  });
+
+  // 页面加载完成后检查公式数量
+  setTimeout(() => {
+    const formulas = findFormulas(document.body.textContent);
+    if (formulas.length > 0) {
+      convertBtn.textContent = `🔄(${formulas.length})`;
+    }
+  }, 1000);
 
-    console.log('公式转换工具已加载');
+  console.log("公式转换工具已加载");
 })();