PicKit

Reduce the number of mouse clicks for users
换行
// ==UserScript==
// @name               PicKit
// @name:zh-CN         拾字
// @namespace          https://github.com/CodebyGPT/PicKit
// @version            2025.12.12
// @description        Reduce the number of mouse clicks for users
// @description:zh-CN  帮你少点一次鼠标
// @author             CodebyGPT
// @license            GPL-3.0
// @license            https://www.gnu.org/licenses/gpl-3.0.txt
// @match              *://*/*
// @icon               data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxZW0iIGhlaWdodD0iMWVtIiB2aWV3Qm94PSIwIDAgMjQgMjQiPjx0aXRsZSB4bWxucz0iIj50b3VjaC10cmlwbGU8L3RpdGxlPjxwYXRoIGZpbGw9ImN1cnJlbnRDb2xvciIgZD0ibTE3Ljk3NSAzLjRsMS0xLjc1cTEuMTc1LjY1IDEuODUgMS44MjVUMjEuNSA2cTAgLjY3NS0uMTc1IDEuMzEzdC0uNSAxLjE4N2wtMS43MjUtMXEuMi0uMzUuMy0uNzEyVDE5LjUgNnEwLS44LS40MTItMS41dC0xLjExMy0xLjFtLTQgMGwxLTEuNzVxMS4xNzUuNjUgMS44NSAxLjgyNVQxNy41IDZxMCAuNjc1LS4xNzUgMS4zMTN0LS41IDEuMTg3bC0xLjcyNS0xcS4yLS4zNS4zLS43MTJUMTUuNSA2cTAtLjgtLjQxMy0xLjV0LTEuMTEyLTEuMW0tMy41IDE4LjZxLS43IDAtMS4zMTItLjN0LTEuMDM4LS44NWwtNS40NS02LjkyNWwuNDc1LS41cS41LS41MjUgMS4yLS42MjV0MS4zLjI3NUw3LjUgMTQuMlY2cTAtLjQyNS4yODgtLjcxMlQ4LjUgNXQuNzI1LjI4OHQuMy43MTJ2NUgxN3ExLjI1IDAgMi4xMjUuODc1VDIwIDE0djRxMCAxLjY1LTEuMTc1IDIuODI1VDE2IDIyem0tNi4zLTEzLjVxLS4zMjUtLjU1LS41LTEuMTg3VDMuNSA2cTAtMi4wNzUgMS40NjMtMy41MzdUOC41IDF0My41MzggMS40NjNUMTMuNSA2cTAgLjY3NS0uMTc1IDEuMzEzdC0uNSAxLjE4N2wtMS43MjUtMXEuMi0uMzUuMy0uNzEyVDExLjUgNnEwLTEuMjUtLjg3NS0yLjEyNVQ4LjUgM3QtMi4xMjUuODc1VDUuNSA2cTAgLjQyNS4xLjc4OHQuMy43MTJ6Ii8+PC9zdmc+
// @grant              GM_registerMenuCommand
// @grant              GM_setValue
// @grant              GM_getValue
// @grant              GM_openInTab
// @grant              GM_addStyle
// @grant              GM_setClipboard
// @sandbox            DOM
// @inject-into        content
// @run-at             document-start
// @supportURL         https://github.com/CodebyGPT/PicKit/issues
// ==/UserScript==

/*
 * 非原创内容声明：
 * 1. Icon 来自 allsvgicons.com 提供的 Material Symbols 图标库。
 * 2. 脚本大部分代码参考或直接使用了 Gemini 3 Pro Preview、ChatGPT、Kimi K2、Qwen3-Max 等 LLM 的输出结果。
 * 3. 快速粘贴网盘提取码功能参考了 greasyfork.org/zh-CN/scripts/445489-网盘链接识别、greasyfork.org/zh-CN/scripts/439266-网盘有效性检查、github.com/Magiclyan/panAI（forked from syhyz1990/panAI）等脚本。
 * 4. 中文文本校正功能的部分语法规则参考了 github.com/sparanoid/chinese-copywriting-guidelines 中的内容。
 * 
 * Non-original content disclaimer:
 * 1. The icon is sourced from the Material Symbols icon library provided by allsvgicons.com.
 * 2. The script primarily references or directly utilizes the output results from large language models (LLMs) such as Gemini 3 Pro Preview, ChatGPT, Kimi K2, and Qwen3-Max.
 * 3. The quick paste function for cloud storage extraction codes draws inspiration from scripts such as greasyfork.org/zh-CN/scripts/445489-网盘链接识别, greasyfork.org/zh-CN/scripts/439266-网盘有效性检查, and github.com/Magiclyan/panAI (forked from syhyz1990/panAI).
 * 4. The grammatical rules for the Chinese text correction feature are partially referenced from the content on github.com/sparanoid/chinese-copywriting-guidelines.
 * 
 * Заявление о неоригинальном контенте:
 * 1. Иконка взята из библиотеки Material Symbols, предоставленной сайтом allsvgicons.com.
 * 2. Большая часть кода скрипта заимствована или использована напрямую из Gemini 3 Pro Preview, ChatGPT и Kimi.
 * 3. Функция быстрого вставления кода извлечения облачного хранилища вдохновлена скриптами, такими как greasyfork.org/zh-CN/scripts/445489-网盘链接识别, greasyfork.org/zh-CN/scripts/439266-网盘有效性检查, github.com/Magiclyan/panAI (forked from syhyz1990/panAI).
 * 4. Некоторые грамматические правила функции коррекции китайского текста частично основаны на материале с github.com/sparanoid/chinese-copywriting-guidelines.
 */

(function () {
    'use strict';
    // 0. 异步兼容层 (Async Compatibility Layer)
    // 优先使用 GM.getValue (标准异步)，降级使用 GM_getValue (Tampermonkey同步)
    const safeGetValue = (key, def) => {
        if (typeof GM !== 'undefined' && GM.getValue) {
            return GM.getValue(key, def);
        } else {
            return Promise.resolve(GM_getValue(key, def));
        }
    };

    const safeSetValue = (key, val) => {
        if (typeof GM !== 'undefined' && GM.setValue) {
            return GM.setValue(key, val);
        } else {
            return Promise.resolve(GM_setValue(key, val));
        }
    };
const safeOpenTab = (url, options) => {
    if (typeof GM !== 'undefined' && GM.openInTab) {
        // 现代异步标准 (GM.openInTab)
        GM.openInTab(url, options);
    } else {
        // 旧版同步标准 (GM_openInTab)
        GM_openInTab(url, options);
    }
};

    // =========================================================================
    // 1. 配置与状态管理 (Configuration & State)
    // =========================================================================

    const DEFAULT_CONFIG = {
        language: 'auto', // 'auto'（默认） | 'zh-CN' | 'en' | 'ru'
        positionMode: 'endchar', // 'endchar' | 'mouse'
        offset: 12, // px
        timeout: 2800, // ms, 0 = infinite
        buttonStyle: 'row', // 'row' (capsule) | 'col' (rounded rect)
        forceWhiteBlack: false, // true = force white bg/black text
        searchEngine: 'google', // key or custom url
        enableToast: true,
        enableCache: true,
        unlockHotkey: 'ControlLeft',
        enablePaste: true,
        inputRecoveryMode: 'off', // 'off' | 'loose' (default, ignore tracking params) | 'strict'
        enableDragPreview: false,
    };

    const PASTE_MODE_THREE_BTNS = 'copy-search-paste';   // 闪电粘贴三按钮模式标记

    const SEARCH_ENGINES = {
        google: { name: 'Google', url: 'https://www.google.com/search?q=%s' },
        baidu: { name: 'Baidu', url: 'https://www.baidu.com/s?wd=%s' },
        bing: { name: 'Bing', url: 'https://www.bing.com/search?q=%s' },
        brave: { name: 'Brave', url: 'https://search.brave.com/search?q=%s' },
    };

    // [新增] 网盘域名匹配规则 (用于闪电粘贴密码提取)
    const PAN_DOMAINS = [
        'pan.baidu.com', 'lanzou', 'weiyun.com', 'cloud.189.cn',
        'aliyundrive.com', 'alipan.com', '123pan.com', 'pan.quark.cn',
        'pan.xunlei.com', '115.com', 'drive.uc.cn', 'fast.uc.cn', 'ctfile.com'
    ];
    // [新增] 网盘密码提取正则
    const PAN_CODE_REGEX = /(?:提取码|密码|访问码|分享码|口令)\s*[:：]?\s*([a-zA-Z0-9]{4})(?![a-zA-Z0-9])/;
    
    // [新增] 仅在当前Tab有效的网盘密码缓存（用于新标签页接收）
    let sessionPanCode = null;

    // 运行时状态
    let cachedSelection = { text: '', html: '' };
    let uiTimer = null;
    let toastTimer = null;
    let isScrolling = false;
    let scrollTimeout = null;
    let shadowRoot = null;
    let hostElement = null;

    // 获取配置
// 1. 配置缓存对象 (初始化为默认值)
    let configCache = { ...DEFAULT_CONFIG };

    // 新的同步读取 (直接读内存，速度最快，不阻塞UI)
    const getConfig = (key) => {
        return configCache[key];
    };

    // 新的异步写入 (更新内存 + 保存到存储)
    const setConfig = async (key, val) => {
        configCache[key] = val; // 立即更新内存，保证交互响应
        await safeSetValue(key, val); // 异步写入持久化存储
    };

    // 多语言支持系统 (I18N System)
    const I18N = {
        'zh-CN': {
            lang_name: '简体中文',
            menu_lang: '🌐 语言/Language',
            menu_pos: '📍 定位模式',
            val_endchar: '字符末尾',
            val_mouse: '鼠标位置',
            menu_offset: '📏 弹出偏移量',
            prompt_offset: '请输入按钮距离选区的偏移量 (px):',
            menu_timeout: '⏱️ 停留时长',
            val_infinite: '不消失',
            prompt_timeout: '请输入停留时长 (ms, 0表示不自动消失):',
            menu_style: '🎨 按钮布局',
            val_row: '横排胶囊',
            val_col: '纵排矩形',
            menu_theme: '🌓 配色方案',
            val_light: '强制浅色',
            val_auto: '自动反色',
            menu_search: '🔍 搜索引擎',
            prompt_search: '请输入搜索引擎代码 (google, baidu, bing, brave) 或完整URL (%s 代替关键词):',
            err_search: '无效输入。自定义URL需包含 %s',
            menu_cache: '💾 选中即缓存',
            val_on: '开启',
            val_off: '关闭',
            menu_toast: '🔔 复制反馈',
            menu_hotkey: '🔑 超级划词键',
            val_disabled: '已禁用',
            prompt_hotkey: '请按下快捷键 (如 Ctrl, Alt, Shift) 或输入 "NONE" 禁用:',
            menu_paste: '⚡ 闪电粘贴',
            menu_block: '🚫 屏蔽页面自带划词条',
            menu_clear: '🗑️ 清除当前域名屏蔽规则',
            confirm_clear: '确定要清除 %s 下所有屏蔽规则吗？',
            alert_cleared: '规则已清除，请刷新。',
            alert_no_rules: '当前域名无已保存规则。',
            menu_reset: '⚙️ 重置所有设置',
            confirm_reset: '确定要重置所有设置吗？',
            toast_unlock: '🔓 超级划词已激活',
            toast_copied: '已复制',
            toast_pasted: '已粘贴',
            toast_paste_compat: '已粘贴 (兼容模式)',
            toast_paste_fail: '粘贴失败',
            picker_active: '进入拾取模式；按 ESC 退出',
            picker_cant_block_self: '不能屏蔽脚本自身的按钮！',
            picker_confirm: '确定屏蔽该元素吗？(按Esc退出)\n\n选择器: %s',
            picker_saved: '元素已屏蔽并保存规则',
            picker_exit: '已退出拾取模式',
            btn_copy: '复制',
            btn_search: '搜索',
            btn_paste: '粘贴',
            festival_cny: '🏮已复制🏮',
            festival_xmas: '🎄已复制🎄',
            btn_open_link: '打开链接',
            toast_password_pasted: '已粘贴提取码',
            menu_drag_preview: '🔗 拖拽预览',
            btn_cut: '剪切',
            menu_edit: '✏️ 编辑网页',
            menu_exit_edit: '已退出编辑',
            btn_delete: '删除',
            btn_bold: '加粗',
            btn_highlight: '标记',
            disclaimer_text: '此网页内容已经过 <SCRIPT_NAME> 编辑，仅出于简化网页便于浏览之目的，不用于其他用途。'
        },
        'en': {
            lang_name: 'English',
            menu_lang: '🌐 Language',
            menu_pos: '📍 Position',
            val_endchar: 'End of Text',
            val_mouse: 'Mouse Cursor',
            menu_offset: '📏 Offset',
            prompt_offset: 'Enter offset distance (px):',
            menu_timeout: '⏱️ Timeout',
            val_infinite: 'Infinite',
            prompt_timeout: 'Enter timeout (ms, 0 = infinite):',
            menu_style: '🎨 Layout',
            val_row: 'Row (Capsule)',
            val_col: 'Column (Rect)',
            menu_theme: '🌓 Theme',
            val_light: 'Force Light',
            val_auto: 'Auto Contrast',
            menu_search: '🔍 Engine',
            prompt_search: 'Enter engine code (google, bing...) or URL with %s:',
            err_search: 'Invalid input. Custom URL must contain %s',
            menu_cache: '💾 Cache Selection',
            val_on: 'On',
            val_off: 'Off',
            menu_toast: '🔔 Toast Notification',
            menu_hotkey: '🔑 Unlock Hotkey',
            val_disabled: 'Disabled',
            prompt_hotkey: 'Press a key (Ctrl, Alt...) or type "NONE" to disable:',
            menu_paste: '⚡ Smart Paste',
            menu_block: '🚫 Block Page Element',
            menu_clear: '🗑️ Clear Block Rules',
            confirm_clear: 'Clear all rules for %s?',
            alert_cleared: 'Rules cleared. Please refresh.',
            alert_no_rules: 'No rules found for this domain.',
            menu_reset: '⚙️ Reset Settings',
            confirm_reset: 'Reset all settings?',
            toast_unlock: '🔓 Unlock Mode Active',
            toast_copied: 'Copied',
            toast_pasted: 'Pasted',
            toast_paste_compat: 'Pasted (Compat)',
            toast_paste_fail: 'Paste Failed',
            picker_active: 'Picker Mode Active (ESC to exit)',
            picker_cant_block_self: 'Cannot block script UI!',
            picker_confirm: 'Block this element? (ESC to cancel)\n\nSelector: %s',
            picker_saved: 'Element blocked & saved.',
            picker_exit: 'Picker Mode Exited',
            btn_copy: 'Copy',
            btn_search: 'Search',
            btn_paste: 'Paste',
            festival_cny: '🏮 Copied 🏮',
            festival_xmas: '🎄 Copied 🎄',
            btn_open_link: 'Open Link',
            toast_password_pasted: 'Code Pasted',
            menu_drag_preview: '🔗 Drag Link Preview',
            btn_cut: 'Cut',
            menu_edit: '✏️ Edit Page',
            menu_exit_edit: 'Exit Edit Mode',
            btn_delete: 'Delete',
            btn_bold: 'Bold',
            btn_highlight: 'Highlight',
            disclaimer_text: 'Content edited by <SCRIPT_NAME> for simplification purposes only.'
        },
        'ru': {
            lang_name: 'Русский',
            menu_lang: '🌐 Язык/Language',
            menu_pos: '📍 Позиция',
            val_endchar: 'Конец текста',
            val_mouse: 'Курсор мыши',
            menu_offset: '📏 Отступ',
            prompt_offset: 'Введите отступ (px):',
            menu_timeout: '⏱️ Задержка',
            val_infinite: 'Бесконечно',
            prompt_timeout: 'Введите задержку (мс, 0 = бесконечно):',
            menu_style: '🎨 Стиль кнопок',
            val_row: 'Строка',
            val_col: 'Колонка',
            menu_theme: '🌓 Тема',
            val_light: 'Светлая',
            val_auto: 'Авто',
            menu_search: '🔍 Поисковик',
            prompt_search: 'Код (google, yandex...) или URL с %s:',
            err_search: 'Ошибка. URL должен содержать %s',
            menu_cache: '💾 Кэш выделения',
            val_on: 'Вкл',
            val_off: 'Выкл',
            menu_toast: '🔔 Уведомления',
            menu_hotkey: '🔑 Горячая клавиша',
            val_disabled: 'Откл',
            prompt_hotkey: 'Нажмите клавишу (Ctrl, Alt...) или "NONE":',
            menu_paste: '⚡ Быстрая вставка',
            menu_block: '🚫 Блокировка элементов',
            menu_clear: '🗑️ Сброс блокировок',
            confirm_clear: 'Удалить правила для %s?',
            alert_cleared: 'Правила удалены. Обновите страницу.',
            alert_no_rules: 'Нет правил для этого домена.',
            menu_reset: '⚙️ Сброс настроек',
            confirm_reset: 'Сбросить все настройки?',
            toast_unlock: '🔓 Режим разблокировки',
            toast_copied: 'Скопировано',
            toast_pasted: 'Вставлено',
            toast_paste_compat: 'Вставлено (совм.)',
            toast_paste_fail: 'Ошибка вставки',
            picker_active: 'Режим выбора (ESC для выхода)',
            picker_cant_block_self: 'Нельзя блокировать кнопки скрипта!',
            picker_confirm: 'Блокировать элемент? (ESC - отмена)\n\nСелектор: %s',
            picker_saved: 'Заблокировано и сохранено.',
            picker_exit: 'Режим выбора отключен',
            btn_copy: 'Копировать',
            btn_search: 'Поиск',
            btn_paste: 'Вставить',
            festival_cny: '🏮 Скопировано 🏮',
            festival_xmas: '🎄 Скопировано 🎄',
            btn_open_link: 'Открыть ссылку',
            toast_password_pasted: 'Код вставлен',
            menu_drag_preview: '🔗 Предпросмотр ссылки',
            btn_cut: 'Вырезать',
            menu_edit: '✏️ Редактировать',
            menu_exit_edit: 'Выход из редактора',
            btn_delete: 'Удалить',
            btn_bold: 'Жирный',
            btn_highlight: 'Маркер',
            disclaimer_text: 'Контент отредактирован <SCRIPT_NAME> только для упрощения просмотра.'
        }
    };

    const t = (key, ...args) => {
        let lang = getConfig('language');
        if (lang === 'auto') {
            const nav = navigator.language.toLowerCase();
            if (nav.startsWith('zh')) lang = 'zh-CN';
            else if (nav.startsWith('ru')) lang = 'ru';
            else lang = 'en';
        }
        const dict = I18N[lang] || I18N['en'];
        let str = dict[key] || key;
        args.forEach(arg => str = str.replace('%s', arg));
        return str;
    };

    // --- 新增：编辑模式与合规声明状态 ---
    let isEditMode = false;
    let hasEditSessionStarted = false; // 标记本次会话是否启用过编辑模式
    let complianceObserver = null;
    let currentBannerId = null;

    // 生成随机ID (防拦截)
    const generateRandomId = () => 'tm-sc-' + Math.random().toString(36).slice(2, 9);

    // 创建/重建合规声明
    function ensureComplianceBanner() {
        if (!hasEditSessionStarted) return; // 如果从未启动过编辑模式，不生成

        // 1. 检查是否已存在
        const existing = currentBannerId ? document.getElementById(currentBannerId) : null;
        if (existing && existing.offsetParent !== null) return;// 如果存在且看起来正常（display不是none），则跳过
        if (existing) existing.remove();// 如果存在但被隐藏了，或者不存在，则继续重建逻辑

        // 2. 如果之前有Observer，先断开，避免重新插入时死循环
        if (complianceObserver) {
            complianceObserver.disconnect();
        }

        // 3. 创建元素
        const scriptName = GM_info.script.name;
        const banner = document.createElement('div');
        currentBannerId = generateRandomId();
        banner.id = currentBannerId;

        banner.setAttribute('data-tm-policy', 'protected'); // [关键] 添加特殊策略标记，用于 CSS 排除
        banner.setAttribute('contenteditable', 'false'); 
        
        // 样式：高层级、半透明白底、浅灰字、底部居中、禁止选中、穿透点击(防Picker)
        banner.style.cssText = `
            position: fixed !important;
            bottom: 50px !important;
            left: 50% !important;
            transform: translateX(-50%) !important;
            z-index: 2147483647 !important;
            background: rgba(255, 255, 255, 0.85) !important;
            padding: 6px 14px !important;
            border-radius: 6px !important;
            box-shadow: 0 2px 10px rgba(0,0,0,0.08) !important;
            pointer-events: none !important; /* 让鼠标穿透，既不影响浏览，也防止被拾取器选中 */
            user-select: none !important;
            -webkit-user-select: none !important;
            display: flex !important;
            align-items: center !important;
            gap: 8px !important;
            visibility: visible !important;
            opacity: 1 !important;
            width: auto !important;
            height: auto !important;
            border: 1px solid rgba(0,0,0,0.05) !important;
        `;

        // SVG 图标 (Info)
        const iconContainer = document.createElement('div');
        iconContainer.style.cssText = 'display:flex;align-items:center;color:#888;pointer-events:none;';
        iconContainer.innerHTML = `<svg viewBox="0 0 24 24" width="14" height="14" stroke="currentColor" stroke-width="2" fill="none" stroke-linecap="round" stroke-linejoin="round" style="display:block;"><circle cx="12" cy="12" r="10"></circle><line x1="12" y1="16" x2="12" y2="12"></line><line x1="12" y1="8" x2="12.01" y2="8"></line></svg>`;
        banner.appendChild(iconContainer);
        
        // 2. 文本 (使用 Canvas 绘制，防篡改)
        const textStr = t('disclaimer_text').replace('<SCRIPT_NAME>', scriptName);
        const canvas = document.createElement('canvas');
        const ctx = canvas.getContext('2d');
        const fontSize = 12;
        const fontFamily = 'sans-serif';
        
        // 测量文本宽度
        ctx.font = `${fontSize}px ${fontFamily}`;
        const metrics = ctx.measureText(textStr);
        const textWidth = Math.ceil(metrics.width);
        const textHeight = Math.ceil(fontSize * 1.2); // 留一点行高

        // 设置 Canvas 尺寸 (考虑高分屏清晰度，使用 2x 缩放)
        const dpr = window.devicePixelRatio || 1;
        canvas.width = textWidth * dpr;
        canvas.height = textHeight * dpr;
        canvas.style.width = `${textWidth}px`;
        canvas.style.height = `${textHeight}px`;
        canvas.style.pointerEvents = 'none';

        // 绘制
        ctx.scale(dpr, dpr);
        ctx.font = `${fontSize}px ${fontFamily}`;
        ctx.fillStyle = '#999';
        ctx.textBaseline = 'middle';
        ctx.fillText(textStr, 0, textHeight / 2 + 1); // +1 微调垂直居中

        banner.appendChild(canvas);
        document.body.appendChild(banner);

        // 4. 启动被动监视 (MutationObserver)
        complianceObserver = new MutationObserver((mutations) => {
            let needsRebuild = false;
            mutations.forEach(m => {
                // 如果节点被移除
                if (m.removedNodes.length) {
                    m.removedNodes.forEach(node => {
                        if (node.id === currentBannerId) needsRebuild = true;
                    });
                }
                // 如果属性被篡改 (如 style set to none)
                if (m.target.id === currentBannerId) {
                     needsRebuild = true;
                }
                // 子节点变化 (例如 Canvas 被删除了)
                if (m.target.id === currentBannerId && m.type === 'childList') needsRebuild = true;
            });

            if (needsRebuild) { // 异步重建防止死锁
                // 只要检测到针对Banner的任何改动，立即销毁旧的并重建
                setTimeout(() => { // 使用 setTimeout 避免在Observer回调中同步操作DOM
                const old = document.getElementById(currentBannerId); // 销毁旧的引用（如果还在DOM里但被改了）
                if (old) old.remove();
                // 立即重建
                ensureComplianceBanner();
                }, 0);
            }
        });

        complianceObserver.observe(document.body, { childList: true, subtree: false }); // 监控 body 子节点删除
        // 监视 banner 自身的属性变化 (防止通过 style="display:none" 隐藏)
        setTimeout(() => { // 注意：这里需要再次获取最新的 banner 引用
            const b = document.getElementById(currentBannerId);
            if(b && complianceObserver) {
                 complianceObserver.observe(b, { attributes: true, attributeFilter: ['style', 'class', 'hidden', 'id', 'data-tm-policy', 'contenteditable'], childList: true, subtree: true });
            }
        }, 0);
    }

    // 切换编辑模式
    function toggleEditMode(enable) {
        if (isEditMode === enable) return;
        isEditMode = enable;

        if (isEditMode) {
            hasEditSessionStarted = true; // 标记会话已开始，此后 Banner 即使退出编辑模式也会常驻
            document.designMode = 'on';
            ensureComplianceBanner();
            showToast(t('menu_edit') + ': ' + t('val_on'));
        } else {
            document.designMode = 'off';
            showToast(t('menu_exit_edit'));
            hideUI(); // 隐藏可能残留的按钮

            ensureComplianceBanner();  // 确保 Banner 依然存在 (防止在切换瞬间被误删)
        }
    }

    // ===============
    // 2. 菜单系统 (GM Menu System)
    // ===============
// 启动时一次性加载所有配置
    async function initConfiguration() {
        const keys = Object.keys(DEFAULT_CONFIG);
        // 并行读取所有配置，提高速度
        const values = await Promise.all(
            keys.map(key => safeGetValue(key, DEFAULT_CONFIG[key]))
        );
        
        // 将读取到的值写入缓存
        keys.forEach((key, index) => {
            configCache[key] = values[index];
        });
        
        // 额外加载屏蔽规则 (blocked_elements)
        const blockedRules = await safeGetValue('blocked_elements', {});
        
        // 专门处理 blocked_elements 的缓存
        configCache['blocked_elements'] = blockedRules;
    }
    function registerMenus() {
        // 这种做法在某些管理器中可能需要刷新页面才能更新菜单文字，但在现代Tampermonkey中通常有效
        // 为保证响应性，点击后我们弹窗提示或重刷菜单
        // 1. 语言设置 (Language)
        const curLang = getConfig('language');
        const langLabel = curLang === 'auto' ? 'Auto' : (I18N[curLang] ? I18N[curLang].lang_name : curLang);
        GM_registerMenuCommand(`${t('menu_lang')}: ${langLabel}`, () => {
            const nextMap = { 'auto': 'zh-CN', 'zh-CN': 'en', 'en': 'ru', 'ru': 'auto' };
            setConfig('language', nextMap[curLang] || 'auto');
            location.reload();
        });
        
        // 2.1 定位模式
        const posMode = getConfig('positionMode');
        GM_registerMenuCommand(`${t('menu_pos')}: ${posMode === 'endchar' ? t('val_endchar') : t('val_mouse')}`, () => {
            setConfig('positionMode', posMode === 'endchar' ? 'mouse' : 'endchar');
            location.reload(); // 刷新以更新菜单状态
        });

        // 2.2 偏移量
        GM_registerMenuCommand(`${t('menu_offset')}: ${getConfig('offset')}px`, () => {
            const val = prompt(t('prompt_offset'), getConfig('offset'));
            if (val !== null && !isNaN(val)) {
                setConfig('offset', parseInt(val, 10));
                location.reload();
            }
        });

        // 2.3 停留时长
        const timeout = getConfig('timeout');
        GM_registerMenuCommand(`${t('menu_timeout')}: ${timeout === 0 ? t('val_infinite') : timeout + 'ms'}`, () => {
            const val = prompt(t('prompt_timeout'), timeout);
            if (val !== null && !isNaN(val)) {
                setConfig('timeout', parseInt(val, 10));
                location.reload();
            }
        });

        // 2.4 按钮样式
        const btnStyle = getConfig('buttonStyle');
        GM_registerMenuCommand(`${t('menu_style')}: ${btnStyle === 'row' ? t('val_row') : t('val_col')}`, () => {
            setConfig('buttonStyle', btnStyle === 'row' ? 'col' : 'row');
            location.reload();
        });

        // 2.5 配色方案
        const forceWB = getConfig('forceWhiteBlack');
        GM_registerMenuCommand(`${t('menu_theme')}: ${forceWB ? t('val_light') : t('val_auto')}`, () => {
            setConfig('forceWhiteBlack', !forceWB);
            location.reload();
        });

        // 2.6 搜索引擎
        const currentEngineKey = getConfig('searchEngine');
        const engineName = SEARCH_ENGINES[currentEngineKey] ? SEARCH_ENGINES[currentEngineKey].name : 'Custom';
        GM_registerMenuCommand(`${t('menu_search')}: ${engineName}`, () => {
            const choice = prompt(t('prompt_search'), currentEngineKey);
            if (choice) {
                if (SEARCH_ENGINES[choice] || choice.includes('%s')) {
                    setConfig('searchEngine', choice);
                    location.reload();
                } else {
                    alert(t('err_search'));
                }
            }
        });

        // 2.7 缓存功能
        GM_registerMenuCommand(`${t('menu_cache')}: ${getConfig('enableCache') ? t('val_on') : t('val_off')}`, () => {
            setConfig('enableCache', !getConfig('enableCache'));
            location.reload();
        });

        // 2.8 Toast通知
        GM_registerMenuCommand(`${t('menu_toast')}: ${getConfig('enableToast') ? t('val_on') : t('val_off')}`, () => {
            setConfig('enableToast', !getConfig('enableToast'));
            location.reload();
        });

        // 2.9 超级划词模式快捷键
        const currentKey = getConfig('unlockHotkey');
        GM_registerMenuCommand(`${t('menu_hotkey')}: ${currentKey || t('val_disabled')}`, () => {
            const val = prompt(t('prompt_hotkey'));
            if (val === null) return;
            
            // 简单的输入清洗，如果用户按了键，浏览器事件可以捕获，但在prompt里只能输入
            // 这里我们让用户手动输入，或者输入简单的 'ctrl' 映射一下
            let finalKey = val.trim();
            
            // 简单映射常用键
            if (finalKey.toLowerCase() === 'ctrl') finalKey = 'ControlLeft';
            if (finalKey.toLowerCase() === 'alt') finalKey = 'AltLeft';
            if (finalKey.toLowerCase() === 'shift') finalKey = 'ShiftLeft';
            if (finalKey === '' || finalKey.toUpperCase() === 'NONE') finalKey = '';

            setConfig('unlockHotkey', finalKey);
            location.reload();
        });

        // 2.10 闪电粘贴
        GM_registerMenuCommand(`${t('menu_paste')}: ${getConfig('enablePaste') ? t('val_on') : t('val_off')}`, () => {
            setConfig('enablePaste', !getConfig('enablePaste'));
            location.reload();
        });

        // [新增] 拖拽预览开关
        GM_registerMenuCommand(`${t('menu_drag_preview')}: ${getConfig('enableDragPreview') ? t('val_on') : t('val_off')}`, () => {
            setConfig('enableDragPreview', !getConfig('enableDragPreview'));
            location.reload();
        });

        // 2.11 码字防丢设置（功能不稳定目前不对用户展示，暂时注释掉菜单选项）
        const recMode = getConfig('inputRecoveryMode');
        const recModeText = { 'off': '已关闭', 'loose': '宽松 (默认)', 'strict': '严格 (完全匹配URL)' };
        //GM_registerMenuCommand(`🛡️ 码字防丢: ${recModeText[recMode] || '宽松'}`, () => {
        //    const map = ['off', 'loose', 'strict'];
        //    const next = map[(map.indexOf(recMode) + 1) % map.length];
        //    setConfig('inputRecoveryMode', next);
        //    alert(`码字防丢模式已切换为：${recModeText[next]}\n\n说明：\n宽松：忽略 ?utm_source 等跟踪参数 (推荐)\n严格：必须 URL 完全一致才恢复\n关闭：不缓存输入内容`);
        //    location.reload();
        //});

        // 2.12 屏蔽元素工具
        GM_registerMenuCommand(t('menu_block'), () => {
            activateElementPicker();
        });

        GM_registerMenuCommand(t('menu_clear'),  async () => {
            const domain = location.hostname;
            if (confirm(t('confirm_clear', domain))) {
                const rules = await safeGetValue('blocked_elements', {});
                if (rules[domain]) {delete rules[domain];
                await safeSetValue('blocked_elements', rules);if (typeof configCache !== 'undefined') {configCache['blocked_elements'] = rules;}
                alert(t('alert_cleared'));
                location.reload();} else {alert(t('alert_no_rules'));
            }
        }});

                // 新增：编辑网页
        GM_registerMenuCommand(t('menu_edit'), () => {
            toggleEditMode(!isEditMode);
        });

        // 2.13 重置
        GM_registerMenuCommand(t('menu_reset'), async () => {
            if (confirm(t('confirm_reset'))) {
                const keys = Object.keys(DEFAULT_CONFIG);await Promise.all(keys.map(k => setConfig(k, DEFAULT_CONFIG[k])));
                location.reload();
            }
        });
    }

    // =======================
    // 3. 核心逻辑 (Core Logic)
    // =======================

// [新增] 智能链接提取器
    function extractLinkFromText(rawText) {
        // 1. 快速预筛选 (性能优化)
        if (!rawText || (!rawText.includes('.') && !rawText.includes('://'))) return null;

        // 2. 清洗中文混淆 (处理 "pa删n.baid中u.co文m" 这种情况)
        // 仅移除中文字符，保留其他所有字符以便正则匹配
        const cleanText = rawText.replace(/[\u4e00-\u9fa5]/g, '');

        // 3. 正则提取
        // 匹配协议头(可选) + 域名/IP + 路径/参数
        // 排除末尾的标点符号： ) ] 】 ） 以及常见的句号逗号
        const urlPattern = /((?:https?:\/\/)?(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}(?::\d{1,5})?(?:\/[^\s\u4e00-\u9fa5)\]】）]*)?)/gi;
        
        const matches = cleanText.match(urlPattern);
        
        // 4. 必须有且仅有一个完整的链接
        if (!matches || matches.length !== 1) return null;
        
        let url = matches[0];

        // 5. 特殊清洗：如果URL末尾包含了非URL字符（如被正则误吸入的符号），做Trim
        // 由于上面正则排除了特定结束符，这里主要处理可能遗漏的边缘情况
        url = url.replace(/[.,;:]+$/, '');

        // 6. 域名/IP 规则校验
        // 提取Host部分
        let host = url.replace(/^https?:\/\//, '').split('/')[0];
        
        // 6.1 排除以纯IP 10. 或 172. 开头的
        if (/^10\./.test(host) || /^172\./.test(host)) return null;

        // 6.2 必须包含顶级域名分隔符 '.' (regex已保证，但防止demo/这种情况被误判，虽regex也处理了)
        if (!host.includes('.')) return null;

        // 7. 补全协议 (用于 safeOpenTab)
        let fullUrl = url;
        if (!url.startsWith('http')) {
            fullUrl = 'http://' + url;
        }

        return { display: url, url: fullUrl, host: host };
    }

    // [新增] 网盘密码提取器
    function extractPanCode(text) {
        if (!getConfig('enablePaste')) return null;
        const match = text.match(PAN_CODE_REGEX);
        return match ? match[1] : null;
    }

// [修改] 高效智能选区定位计算器 (三级降级策略：智能Rect -> 整体包围盒 -> 鼠标位置)
function getSmartSelectionState(selection, mouseEvent) {
    if (!selection || selection.rangeCount === 0) return null;

    const range = selection.getRangeAt(0);
    // 1. 尝试获取精细的矩形列表 (可能为空，特别是在 Input/Textarea 或 框架更新DOM时)
    let rects = range.getClientRects();
    
    let targetRect = null;
    let isBackward = false;
    let isVertical = false;

    // --- 阶段 A: 智能精确定位 (Smart Directional) ---
    if (rects.length > 0) {
        const anchor = selection.anchorNode;
        const focus = selection.focusNode;

        // 判定选区方向
        if (anchor === focus) {
            isBackward = selection.anchorOffset > selection.focusOffset;
        } else {
            // 使用位掩码判定节点位置
            const pos = anchor.compareDocumentPosition(focus);
            if (pos & Node.DOCUMENT_POSITION_PRECEDING) isBackward = true;
        }

        // 判定垂直排版 (仅检查 focusNode)
        let focusEl = focus.nodeType === 1 ? focus : focus.parentElement;
        if (focusEl) {
            const style = window.getComputedStyle(focusEl);
            const writingMode = style.writingMode || 'horizontal-tb';
            isVertical = writingMode.startsWith('vertical');
        }

        // 根据方向获取头或尾的 Rect
        // 注意：如果是 detached 节点，这里虽然有 rects 但可能全是 0，下一阶段会检测
        targetRect = isBackward ? rects[0] : rects[rects.length - 1];
    }

    // 辅助函数：检测 Rect 是否无效 (0x0 且位于 0,0 通常意味着节点已脱离文档流)
    const isInvalidRect = (r) => {
        return !r || (r.width === 0 && r.height === 0 && r.top === 0 && r.left === 0);
    };

    // --- 阶段 B: 经典包围盒兜底 (Classic Bounding Box) ---
    // 如果没有 rects，或者获取到的 rect 是无效的 (0x0)
    if (isInvalidRect(targetRect)) {
        const bounding = range.getBoundingClientRect();
        // 只有当 bounding 也是有效的时候才使用
        if (!isInvalidRect(bounding)) {
            targetRect = bounding;
            // 包围盒丢失了方向细节，默认视为正向水平
            isBackward = false; 
            isVertical = false;
        }
    }

    // --- 阶段 C: 鼠标坐标兜底 (Mouse Position Fallback) ---
    // 如果连包围盒都是 0x0 (常见于 Vue 销毁了节点但选区对象还在内存中)，直接使用鼠标位置模拟一个 Rect
    if (isInvalidRect(targetRect) && mouseEvent) {
        const size = 20; // 模拟一个光标高度
        targetRect = {
            // 构造一个符合 DOMRect 接口的对象
            top: mouseEvent.clientY - size,
            bottom: mouseEvent.clientY,
            left: mouseEvent.clientX,
            right: mouseEvent.clientX,
            width: 0,
            height: size,
            x: mouseEvent.clientX,
            y: mouseEvent.clientY - size
        };
        isBackward = false;
        isVertical = false;
    }

    // 如果所有尝试都失败（极罕见），返回 null 让外部处理
    if (isInvalidRect(targetRect)) return null;

    return {
        rect: targetRect,
        isBackward: isBackward,
        isVertical: isVertical
    };
}
    // [修改] 初始化 Shadow DOM 容器 (针对 SPA/AJAX 优化)
    function initContainer() {
        // 1. 检查 hostElement 是否存在且仍然连接在文档中 (isConnected)
        if (hostElement && hostElement.isConnected) return;

        // 2. 如果 hostElement 存在但已从 DOM 脱落（被网页脚本清除），清理旧引用
        if (hostElement) {
            hostElement = null;
            shadowRoot = null;
        }

        // 3. 重新创建容器
        hostElement = document.createElement('div');
        hostElement.id = 'tm-smart-copy-host';
        hostElement.style.all = 'initial';
        hostElement.style.position = 'fixed';
        hostElement.style.zIndex = '2147483647'; // Max Z-Index
        hostElement.style.top = '0';
        hostElement.style.left = '0';
        hostElement.style.width = '0';
        hostElement.style.height = '0';
        hostElement.style.overflow = 'visible';
        hostElement.style.pointerEvents = 'none'; 
        
        // [重要修改] 挂载到 documentElement (html) 而不是 body
        // 这样即使 body 被 SPA 框架重写，挂在 html 上的元素通常能幸存，或者至少能保证层级正确
        // 如果必须确保层级，挂载前再次检查
        (document.documentElement || document.body).appendChild(hostElement);
        
        shadowRoot = hostElement.attachShadow({ mode: 'open' });
        
        // 重新注入样式
        const style = document.createElement('style');
        style.textContent = getStyles();
        shadowRoot.appendChild(style);
    }

    // 获取样式表字符串
    function getStyles() {
        const isCol = getConfig('buttonStyle') === 'col';
        const padRow  = '10px 13.1415926px';   // 胶囊：上下略小，左右略大
        const padCol  = '10px';       // 纵向：正方形，四边一致
        return `
            :host { all: initial; font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; }
            .sc-container {
                position: fixed;
                display: flex;
                flex-direction: ${isCol ? 'column' : 'row'};
                background: rgba(255, 255, 255, 0.15); /* 调整背景透明度 */
                border: 1px solid transparent; /* 透明边框 */
                box-shadow:
                    /* 发光边框效果 */
                    0 0 0 1px rgba(255, 255, 255, 0.3),
                    0 8px 24px rgba(0, 0, 0, 0.12), 0 2px 4px rgba(0, 0, 0, 0.06),
                    0 0 10px rgba(255, 255, 255, 0.1); /* 发光效果 */
                color: #000;
                border-radius: ${isCol ? '12px' : '20px'};
                font-size: 16px;
                z-index: 9999;
                cursor: pointer;
                user-select: none;
                backdrop-filter: blur(8px);
                -webkit-backdrop-filter: blur(8px);
                opacity: 0;
                transform: scale(0.95);
                transition: opacity 0.2s ease, transform 0.2s ease, box-shadow 0.2s ease; /* 添加box-shadow过渡 */
                pointer-events: auto;
                overflow: hidden;
                white-space: nowrap;
            }
            .sc-container.visible {
                opacity: 1;
                transform: scale(1);
            }
            .sc-btn {
                display: flex;
                align-items: center;
                justify-content: center;
                transition: background 0.2s, transform 0.1s;
                color: #000;
                /* 方向不同，padding 不同 */
                padding: ${isCol ? padCol : padRow};
            }
            .sc-container[data-btn-count="1"] .sc-btn {
            padding: 10px;
            aspect-ratio: 1 / 1;
            }
            .sc-btn:hover {
                background: rgba(255, 255, 255, 0.3);
                transform: scale(1.03);
            }
            .sc-btn:active {
                transform: scale(0.98);
                background: rgba(255, 255, 255, 0.2);
            }
            /* 深色模式覆盖 */
            .theme-dark-ui {
                /* --- 深色模式背景样式 --- */
                background: rgba(30, 30, 30, 0.3); /* 调整深色模式背景透明度 */
                border: 1px solid transparent; /* 深色模式也需要透明边框 */
                box-shadow:
                    /* 发光边框效果 (深色模式专属颜色) */
                    0 0 0 1px rgba(255, 255, 255, 0.15),
                    0 8px 24px rgba(0, 0, 0, 0.12), 0 2px 4px rgba(0, 0, 0, 0.06),
                    0 0 10px rgba(0, 0, 0, 0.1); /* 深色模式下用较暗的发光 */
                color: #fff;
            }
            .theme-dark-ui .sc-btn {
                color: #fff;
            }
            .theme-dark-ui .sc-btn:hover {
                background: rgba(255, 255, 255, 0.15);
            }
            .theme-dark-ui .sc-btn:active {
                background: rgba(255, 255, 255, 0.1);
            }
            /* 分割线 */
            .divider {
                background: rgba(255, 255, 255, 0.25);
            }
            .theme-dark-ui .divider {
                background: rgba(255, 255, 255, 0.12);
            }
            .divider-v { width: 1px; height: 1.6em; align-self: center; }
            .divider-h { height: 1px; width: 100%; }
            /* Toast 通知 */
            .sc-toast {
                position: fixed;
                left: 50%;
                bottom: 20px;
                transform: translateX(-50%);
                background: rgba(0, 0, 0, 0.6);
                color: white;
                padding: 8px 16px;
                border-radius: 20px;
                font-size: 13px;
                pointer-events: none;
                opacity: 0;
                transition: opacity 0.3s;
                z-index: 10000;
                backdrop-filter: blur(8px);
                -webkit-backdrop-filter: blur(8px);
                font-family: -apple-system, BlinkMacSystemFont, sans-serif;
            }
            .sc-toast.show { opacity: 1; }
            /* ===== Liquid Glass + HDR Glow ===== */

/* 以下均为额外增强玻璃质感补丁，全部删除也不会影响正常显示：涉及模拟玻璃扭曲（使用多层 background、微弱的 background-blend-mode、低透明度彩色噪声）、轮廓边缘反光（利用 box-shadow 叠加 1~3 层白色/彩色外发光）、HDR hover glow（在 hover 时提亮、加入更强的外扩光、加一点 scale） */
.sc-container {
    position: fixed;
    display: flex;
    backdrop-filter: blur(14px) saturate(180%);
    -webkit-backdrop-filter: blur(14px) saturate(180%);
    background:
        /* 轻微彩色折射层 */
        linear-gradient(135deg, rgba(255,255,255,0.20), rgba(255,255,255,0.05)),
        /* 噪声纹理模拟扭曲 */
        url("data:image/svg+xml;utf8,\
<svg xmlns='http://www.w3.org/2000/svg' width='40' height='40' viewBox='0 0 40 40'>\
<filter id='n'>\
<feTurbulence type='fractalNoise' baseFrequency='0.9' numOctaves='2'/>\
<feColorMatrix type='saturate' values='0'/>\
<feComponentTransfer><feFuncA type='linear' slope='0.08'/></feComponentTransfer>\
</filter>\
<rect width='40' height='40' filter='url(#n)'/>\
</svg>"),
        rgba(255,255,255,0.10);

    background-blend-mode: overlay;

    /* 轮廓反光效果（外圈） */
    box-shadow:
        0 0 0 1px rgba(255,255,255,0.35),
        0 0 12px rgba(255,255,255,0.15),
        0 8px 30px rgba(0,0,0,0.22);

    transition: 
        box-shadow .25s ease,
        transform .25s ease,
        opacity .2s ease;
}

/* 鼠标悬停按钮 HDR 高亮 */
.sc-btn:hover {
    background: rgba(255,255,255,0.28);
    transform: scale(1.05);

    box-shadow:
        0 0 6px rgba(255,255,255,0.8),
        0 0 16px rgba(255,255,255,0.6),
        0 0 26px rgba(255,255,255,0.4);
    
    filter: brightness(1.25); /* HDR 感 */
}

/* 深色模式增强 */
.theme-dark-ui {
    background:
        linear-gradient(135deg, rgba(255,255,255,0.06), rgba(255,255,255,0.02)),
        url("data:image/svg+xml;utf8,\
<svg xmlns='http://www.w3.org/2000/svg' width='40' height='40' viewBox='0 0 40 40'>\
<filter id='n'>\
<feTurbulence type='fractalNoise' baseFrequency='0.9' numOctaves='2'/>\
<feColorMatrix type='saturate' values='0'/>\
<feComponentTransfer><feFuncA type='linear' slope='0.06'/></feComponentTransfer>\
</filter>\
<rect width='40' height='40' filter='url(#n)'/>\
</svg>"),
        rgba(0,0,0,0.25);

    background-blend-mode: soft-light;

    box-shadow:
        0 0 0 1px rgba(255,255,255,0.18),
        0 0 12px rgba(255,255,255,0.06),
        0 8px 26px rgba(0,0,0,0.32);
}

/* 深色模式 hover 发光更亮 */
.theme-dark-ui .sc-btn:hover {
    background: rgba(255,255,255,0.12);
    filter: brightness(1.35);
    box-shadow:
        0 0 6px rgba(255,255,255,0.5),
        0 0 22px rgba(255,255,255,0.25),
        0 0 36px rgba(255,255,255,0.15);
}
/* =============================
   浅色按钮（theme-light-ui）左上角 + 右下角出现 黑色反光边模拟透明玻璃的折射深边，深色按钮（theme-dark-ui）左上角 + 右下角出现 白色反光边模拟深色玻璃的折射亮边
   ============================= */

/* 浅色按钮（白底黑字）玻璃边：黑色内阴影 */
.theme-light-ui.sc-container {
    /* 提高整体透明度：背景更透、阴影更亮 */
    background:
        linear-gradient(135deg, rgba(255,255,255,0.25), rgba(255,255,255,0.08)),
        url("data:image/svg+xml;utf8,\
<svg xmlns='http://www.w3.org/2000/svg' width='40' height='40' viewBox='0 0 40 40'>\
<filter id='n'>\
<feTurbulence type='fractalNoise' baseFrequency='0.9' numOctaves='2'/>\
<feColorMatrix type='saturate' values='0'/>\
<feComponentTransfer><feFuncA type='linear' slope='0.06'/></feComponentTransfer>\
</filter>\
<rect width='40' height='40' filter='url(#n)'/>\
</svg>"),
        rgba(255,255,255,0.18);

    background-blend-mode: overlay;
    /* 不改变原本背景，仅增加内侧反光 */
    box-shadow:
        inset 2px 2px 3px rgba(0,0,0,0.20),     /* 左上角黑色内反光 */
        inset -2px -2px 3px rgba(0,0,0,0.18),  /* 右下角黑色内反光 */
        0 0 0 1px rgba(255,255,255,0.45),
        0 0 12px rgba(255,255,255,0.25),
        0 8px 30px rgba(0,0,0,0.18);
    /* 分割线改为黑色，透明度 0.18 */
    --divider-color: rgba(0,0,0,0.18);
}

/* 浅色模式 hover 更亮 */
.theme-light-ui .sc-btn:hover {
    background: rgba(255,255,255,0.35);
    filter: brightness(1.3);
    box-shadow:
        0 0 6px rgba(255,255,255,0.9),
        0 0 16px rgba(255,255,255,0.7),
        0 0 26px rgba(255,255,255,0.5);
}

/* 统一分割线颜色（浅色模式黑色，深色模式白色） */
.divider {
    background: var(--divider-color, rgba(255,255,255,0.25));
}

/* 深色按钮（黑底白字）玻璃边：白色内反光 */
.theme-dark-ui.sc-container {
    box-shadow:
        inset 2px 2px 3px rgba(255,255,255,0.32),    /* 左上角亮边 */
        inset -2px -2px 3px rgba(255,255,255,0.28),  /* 右下角亮边 */
        0 0 0 1px rgba(255,255,255,0.18),
        0 0 12px rgba(255,255,255,0.06),
        0 8px 26px rgba(0,0,0,0.32);
}
        `;
    }
    
// =======================
    // [新增] 拖拽链接预览子系统 (Drag Preview Subsystem)
    // =======================

    let dragStartData = null; // 临时存储拖拽起点数据
    const PREVIEW_WIN_NAME = 'PicKitPreviewWindow';

    // 1. 处理拖拽开始
    function handleLinkDragStart(e) {
        if (!getConfig('enableDragPreview')) return;

        // 精确判断：必须是左键拖拽，且目标是超链接（或在超链接内部）
        // closest 向上查找，避免拖拽链接内的文字或图片时不触发
        const link = e.target.closest('a[href]');
        
        // 排除无效链接（如 javascript:void(0) 或锚点）
        if (!link || !link.href || link.href.startsWith('javascript:') || link.href.startsWith('#')) {
            dragStartData = null;
            return;
        }

        dragStartData = {
            url: link.href,
            x: e.clientX,
            y: e.clientY,
            timestamp: Date.now()
        };
    }

    // 2. 处理拖拽结束
    function handleLinkDragEnd(e) {
    if (!dragStartData) return;

    const { x: startX, y: startY, url } = dragStartData;
    const endX = e.clientX;
    const endY = e.clientY;

    /* ---------- 1. 视口外松开直接放弃 ---------- */
    if (
        endX < 0 || endY < 0 ||
        endX > window.innerWidth || endY > window.innerHeight
    ) {
        dragStartData = null;
        return;
    }

    /* ---------- 2. 输入区 / 富文本 / 拖放容器 过滤 ---------- */
    const target = document.elementFromPoint(endX, endY); // 松手时最顶层的元素
    if (target) {
        // 2-1 输入框
        if (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA') {
            dragStartData = null;
            return;
        }
        // 2-2 富文本编辑
        if (target.closest('[contenteditable="true"]')) {
            dragStartData = null;
            return;
        }
        // 2-3 具有 dragover / drop 事件的容器
        const dropZone = target.closest('[ondragover],[ondrop]');
        if (dropZone) {
            dragStartData = null;
            return;
        }
    }

    /* ---------- 3. 距离阈值判断 ---------- */
    const dist = Math.hypot(endX - startX, endY - startY);
    if (dist > 30) openPreviewWindow(url); // 距离阈值：30px (防止点击时的微小抖动被误判为拖拽)
    // 清理数据
    dragStartData = null;
    }

    // 3. 打开预览窗口
    async function openPreviewWindow(url) {
        const screen = window.screen;
        // 获取屏幕可用区域尺寸
        const screenW = screen.availWidth;
        const screenH = screen.availHeight;
        
        // 兼容多显示器坐标 (如果有 availLeft 则使用，否则默认为 0)
        const screenLeft = screen.availLeft || 0;
        const screenTop = screen.availTop || 0;

        // 黄金分割比
        const GOLDEN_RATIO = 0.618;

        // 计算目标尺寸：保持屏幕宽高比，长宽缩放至 61.8%
        const width = Math.round(screenW * GOLDEN_RATIO);
        const height = Math.round(screenH * GOLDEN_RATIO);

        // 计算居中位置
        const left = screenLeft + (screenW - width) / 2;
        const top = screenTop + (screenH - height) / 2;

        const features = `width=${width},height=${height},left=${left},top=${top},resizable=yes,scrollbars=yes,status=yes`;
        window.open(url, PREVIEW_WIN_NAME, features);
    }

// =======================
    // [新增] 强效解锁模式 (Unlock Mode)
    // ===================

    let isUnlockMode = false;
    let unlockStyleEl = null;
    let startPos = { x: 0, y: 0 };

    // 1. 动态CSS：强制文本可选，屏蔽拖拽，屏蔽指针事件限制等
    function getUnlockCSS() {
        return `
            /* --- 1. 全局强制可选 (排除受保护元素) --- */
            /* 权重: 0,1,1 (html/body) 或 0,1,0 (*:not) */
            html, body, *:not([data-tm-policy="protected"]), [unselectable] {
                user-select: text !important;
                -webkit-user-select: text !important;
                -moz-user-select: text !important;
                -ms-user-select: text !important;
                cursor: text !important;
            }
            /* 强制高亮颜色 */
            ::selection {background-color: #3390FF !important;color: #ffffff !important;text-shadow: none !important;}
            ::-moz-selection {background-color: #3390FF !important;color: #ffffff !important;text-shadow: none !important;}
            /* 让链接看起来像普通文本，且禁止图片/链接被拖拽（干扰划词） */
            a:not([data-tm-policy="protected"]), 
            a *:not([data-tm-policy="protected"]), 
            img:not([data-tm-policy="protected"]){
                pointer-events: auto !important; /* 必须允许点击才能触发我们的拦截逻辑，否则无法划词 */
                user-drag: none !important;
                -webkit-user-drag: none !important;
                text-decoration: none !important; /* 视觉上更像文本 */
            }
            /* 禁用常见的透明遮罩层交互，让鼠标穿透到下方文字 */
            /* 注意：这不会影响文字本身，因为文字会继承通配符的 pointer-events: auto */
            div[style*="z-index"][style*="fixed"]:not([data-tm-policy="protected"]), 
            div[style*="z-index"][style*="absolute"]:not([data-tm-policy="protected"]) {pointer-events: none !important;}
            
            /* 重新把文字元素的交互打开，防止被上面的规则误杀 */
            /* 权重计算: div(1) + [style](10) + :not(10) = 21 */
            div[style*="z-index"] *:not([data-tm-policy="protected"]), 
            p:not([data-tm-policy="protected"]), 
            span:not([data-tm-policy="protected"]), 
            h1:not([data-tm-policy="protected"]), h2:not([data-tm-policy="protected"]), 
            h3:not([data-tm-policy="protected"]), h4:not([data-tm-policy="protected"]), 
            h5:not([data-tm-policy="protected"]), h6:not([data-tm-policy="protected"]), 
            em:not([data-tm-policy="protected"]), strong:not([data-tm-policy="protected"]), 
            i:not([data-tm-policy="protected"]), b:not([data-tm-policy="protected"]), 
            td:not([data-tm-policy="protected"]), li:not([data-tm-policy="protected"]), 
            code:not([data-tm-policy="protected"]), pre:not([data-tm-policy="protected"]) {
                pointer-events: auto !important;
            }
            /* 针对被截断文本展开后的样式：隐藏滚动条但保留滚动功能 */
            .tm-sc-expanded {
                scrollbar-width: none !important; /* Firefox */
                -ms-overflow-style: none !important; /* IE或Edge */
            }
            .tm-sc-expanded::-webkit-scrollbar {
                display: none !important;
                width: 0 !important;
                height: 0 !important;
            }
        /* [新增补丁] 某些网页为了实现"卡片整体可点击"，使用了绝对定位的透明链接层覆盖在文本上方，导致鼠标事件被拦截无法穿透，以下补丁专门针对覆盖文本的透明链接层（如 Tailwind 的 absolute inset-0） */
        a.absolute, a[style*="position: absolute"] { pointer-events: none !important; }
        
            /* 放在最后，确保权重覆盖所有上方规则 */
            /* 
               技巧：重复属性选择器三次，权重叠加。
               权重计算: [attr](10) * 3 = 30。
               30 > 21 (Rule 5)。
               这将彻底覆盖上方任何针对其子元素的 pointer-events: auto 设置。
            */
            [data-tm-policy="protected"][data-tm-policy="protected"][data-tm-policy="protected"],
            [data-tm-policy="protected"][data-tm-policy="protected"][data-tm-policy="protected"] * {
                user-select: none !important;
                -webkit-user-select: none !important;
                -moz-user-select: none !important;
                pointer-events: none !important; /* 强制穿透，不给鼠标任何机会 */
                cursor: default !important;
                z-index: 2147483647 !important;
            }
        `;
    }

    // 检查是否为受保护元素
    function isProtectedElement(target) {
        return target && target.closest && target.closest('[data-tm-policy="protected"]');
    }

    function handleCaptureSelectStart(e) {
    if (!isUnlockMode) return;
        // 如果目标是合规声明，立即阻止一切操作
        if (isProtectedElement(e.target)) {
            e.preventDefault();
            e.stopPropagation();
            e.stopImmediatePropagation();
            return;
        }
    // 阻止网页脚本获知“选区开始”事件，从而无法取消它
    // 注意：不要 preventDefault，否则浏览器自己也不会开始选区了
    // 我们只阻止冒泡给网页代码
    e.stopPropagation(); 
    e.stopImmediatePropagation();
}
// 2. 拦截点击事件：如果是拖拽操作或点击链接，则阻止
    function handleCaptureClick(e) {
        if (!isUnlockMode) return;

        // 针对合规声明的拦截
        if (isProtectedElement(e.target)) {
            e.preventDefault();
            e.stopPropagation();
            e.stopImmediatePropagation();
            return;
        }

        const dx = Math.abs(e.clientX - startPos.x);
        const dy = Math.abs(e.clientY - startPos.y);
        const isDrag = dx > 3 || dy > 3; // 位移超过3px视为拖拽
        
        // 判断是否点击了链接（向上查找a标签）
        let target = e.target;
        let isLink = false;
        while (target && target !== document) {
            if (target.tagName === 'A') {
                isLink = true;
                break;
            }
            target = target.parentNode;
        }

        // 如果是拖拽选区操作，或者点击的是链接，则拦截
        if (isDrag || isLink) {
            e.preventDefault();
            e.stopPropagation();
            e.stopImmediatePropagation();
            // console.log('Blocked click by Smart Copy');
        }
    }

// 鼠标按下时按需处理当前元素
    function handleCaptureMouseDown(e) {
        if (!isUnlockMode) return;
        // 针对合规声明的拦截
        if (isProtectedElement(e.target)) {
            e.preventDefault(); // 阻止聚焦和放置光标
            e.stopPropagation();
            e.stopImmediatePropagation();
            return;
        }
        // 1. 处理被点击的元素 (懒加载逻辑)
        const el = e.target;
        if (el && (el.tagName === 'INPUT' || el.tagName === 'TEXTAREA')) {
            try {
                // 处理 Password -> Text
                if (el.type === 'password') {
                    el.dataset.scOriginalType = 'password';
                    el.type = 'text';
                    modifiedElements.add(el); // 加入待恢复列表
                }

                // 处理 Disabled / ReadOnly
                if (el.disabled) { 
                    el.disabled = false; 
                    el.dataset.scWasDisabled = 'true'; 
                    modifiedElements.add(el); 
                }
                if (el.readOnly) { 
                    el.readOnly = false; 
                    el.dataset.scWasReadOnly = 'true'; 
                    modifiedElements.add(el); 
                }
            } catch (err) {
                // 忽略跨域或受保护元素的错误
            }
        }

        // 2. 阻止网页在这个位置触发自定义逻辑
        startPos = { x: e.clientX, y: e.clientY };
        e.stopPropagation();
        e.stopImmediatePropagation();
    }

    function handleCaptureDragStart(e) {
        if (!isUnlockMode) return;
        // 禁止原生拖拽，保证划词顺畅
        e.preventDefault();
        e.stopPropagation();
    }
    
    function handleCaptureCopy(e) {
        if (!isUnlockMode) return;
        // 允许复制，但阻止网页监听（防止网页通过监听copy事件来篡改剪贴板或弹出付费提示）
        // 注意：这不会阻止 navigator.clipboard.write，但会阻止 document.execCommand('copy') 触发的网页脚本
        e.stopImmediatePropagation();
    }

    // 新增：防止网页通过 selectionchange 监听器清空选区
// 注意：这个事件在 document 上触发频率很高，需要轻量处理
function handleCaptureSelectionChange(e) {
    if (!isUnlockMode) return;
    // 同样，阻止网页感知到选区变化
    e.stopPropagation();
    e.stopImmediatePropagation();
}

function cleanInlineEvents() {
    // 仅处理 document.body 和 document.documentElement，极低消耗
    // 只有当用户确实遇到极难缠的页面时，才需要遍历更多元素，但通常 body 足够了
    const targets = [document.documentElement, document.body];
    const events = ['onselectstart', 'onmousedown', 'oncontextmenu', 'oncopy'];
    
    targets.forEach(el => {
        if (!el) return;
        events.forEach(evt => {
            if (el.hasAttribute(evt)) {
                el.removeAttribute(evt);
            }
            // 同时也置空 DOM 属性
            if (el[evt]) {
                el[evt] = null;
            }
        });
    });
}

    const modifiedElements = new Set(); //追踪受影响元素的集合
// 鼠标悬停时智能展开截断文本
    function handleExpandHover(e) {
        if (!isUnlockMode) return;
        let target = e.target;
        
        // 优化性能：忽略已处理元素或非元素节点
        if (target.nodeType !== 1 || target.classList.contains('tm-sc-expanded')) return;

        // 获取计算样式
        const style = window.getComputedStyle(target);
        
        // 检测单行截断 (text-overflow: ellipsis)
        const isEllipsis = style.textOverflow === 'ellipsis';
        
        // 检测多行截断 (-webkit-line-clamp)
        // 注意：getComputedStyle 获取的 webkitLineClamp 可能是 'none' 或数字字符串
        const isLineClamp = style.webkitLineClamp && style.webkitLineClamp !== 'none';

        if (isEllipsis || isLineClamp) {
            // 1. 锁定当前尺寸，防止布局抖动 (Reflow)
            const rect = target.getBoundingClientRect();
            // 必须使用 important 覆盖原有样式
            target.style.setProperty('height', rect.height + 'px', 'important');
            target.style.setProperty('width', rect.width + 'px', 'important');
            
            // 2. 标记已处理
            target.classList.add('tm-sc-expanded');

            // 3. 应用展开策略
            if (isLineClamp) {
                // 多行截断处理策略：
                // 保持高度不变，移除行数限制，允许垂直滚动
                target.style.setProperty('-webkit-line-clamp', 'none', 'important');
                target.style.setProperty('overflow-y', 'auto', 'important');
                // 某些使用 -webkit-box 的布局在移除 clamp 后行为不可控，
                // 如果需要更激进的显示，可能需要 display: block，但这里为了兼容性优先只动 overflow
            } else {
                // 单行截断处理策略：
                // 保持不换行，移除省略号，允许水平滚动
                target.style.setProperty('text-overflow', 'clip', 'important');
                target.style.setProperty('overflow-x', 'auto', 'important');
                // 强制不换行 (防止某些 flex 布局在 overflow 变动后尝试换行)
                target.style.setProperty('white-space', 'nowrap', 'important'); 
            }
        }
    }

    // 退出模式时清理所有展开的元素
    function cleanupExpandedElements() {
        const elements = document.querySelectorAll('.tm-sc-expanded');
        elements.forEach(el => {
            // 在恢复样式前，强制滚动回顶部和最左侧,使内容停留在起始位置，视觉上与操作前完全一致
            el.scrollTop = 0;
            el.scrollLeft = 0;
            
            el.classList.remove('tm-sc-expanded');
            // 移除我们注入的内联样式，恢复网页原貌
            // 注意：这会移除所有同名内联样式。如果网页本身就有内联 height，这里可能会误伤。
            // 但考虑到这只是个临时交互，且针对的是截断文本（通常由 CSS 类控制），直接 removeProperty 风险可控。
            el.style.removeProperty('height');
            el.style.removeProperty('width');
            el.style.removeProperty('-webkit-line-clamp');
            el.style.removeProperty('overflow-y');
            el.style.removeProperty('overflow-x');
            el.style.removeProperty('text-overflow');
            el.style.removeProperty('white-space');
        });
    }

    // 3. 开启/关闭模式
    function toggleUnlockMode(active) {
        if (active === isUnlockMode) return;
        isUnlockMode = active;

        if (active) {
            // 注入CSS
            if (!unlockStyleEl) {
                unlockStyleEl = document.createElement('style');
                unlockStyleEl.textContent = getUnlockCSS();
                unlockStyleEl.id = 'tm-smart-copy-unlock-style';
            }
            (document.documentElement || document.body).appendChild(unlockStyleEl);

            // 清理内联事件 (只做一次，极低开销)
            cleanInlineEvents();

            // 挂载拦截监听器 (使用Capture模式优先拦截)
            // 优先级：最高 (Capture + StopImmediatePropagation)
            window.addEventListener('selectstart', handleCaptureSelectStart, true);
            window.addEventListener('click', handleCaptureClick, true);
            window.addEventListener('mousedown', handleCaptureMouseDown, true);
            window.addEventListener('dragstart', handleCaptureDragStart, true);
            window.addEventListener('copy', handleCaptureCopy, true);
            window.addEventListener('contextmenu', handleCaptureCopy, true); // 顺便解右键
            // selectionchange 通常在 document 上触发
            document.addEventListener('selectionchange', handleCaptureSelectionChange, true);
            document.addEventListener('mouseover', handleExpandHover, true); // [新增] 挂载文本展开监听器 (使用 mouseover 即可，性能优于 mousemove)

            showToast(t('toast_unlock'));
        } else {
            // 移除CSS
            if (unlockStyleEl && unlockStyleEl.parentNode) {
                unlockStyleEl.parentNode.removeChild(unlockStyleEl);
            }

            // >>>>>> 遍历恢复 <<<<<<
            modifiedElements.forEach(el => {
                try {
                    // 恢复 Password
                    if (el.dataset.scOriginalType === 'password') {
                        el.type = 'password';
                        delete el.dataset.scOriginalType;
                    }
                    // 恢复 Disabled / ReadOnly
                    if (el.dataset.scWasDisabled === 'true') { el.disabled = true; delete el.dataset.scWasDisabled; }
                    if (el.dataset.scWasReadOnly === 'true') { el.readOnly = true; delete el.dataset.scWasReadOnly; }

                } catch(e) {}// 即使某个属性恢复失败，也不应中断循环
            });

            modifiedElements.clear(); // 清空集合

            // 移除监听器
            window.removeEventListener('selectstart', handleCaptureSelectStart, true);
            window.removeEventListener('mousedown', handleCaptureMouseDown, true);
            window.removeEventListener('click', handleCaptureClick, true);
            window.removeEventListener('dragstart', handleCaptureDragStart, true);
            window.removeEventListener('copy', handleCaptureCopy, true);
            window.removeEventListener('contextmenu', handleCaptureCopy, true);
            document.removeEventListener('selectionchange', handleCaptureSelectionChange, true);

            // 移除文本展开监听器 并 还原DOM
            document.removeEventListener('mouseover', handleExpandHover, true);
            cleanupExpandedElements();
            
            // 清除当前选区的高亮
            const sel = window.getSelection();
            if (sel && sel.rangeCount > 0) {
                sel.removeAllRanges();          // 彻底清掉选区
                //sel.collapseToStart();       // 把选区折叠到起点，强制浏览器立即重绘使高亮消失（两种方法二选一）
            }
            // 移除Toast (如果不希望提示“已关闭”可以删掉下面这行)
            // showToast('🔒 超级划词已关闭'); 
            // 为了用户体验，松开按键时让Toast自然消失即可，不必特意提示关闭
             const toast = shadowRoot && shadowRoot.querySelector('.sc-toast');
             if(toast) toast.classList.remove('show');
        }
    }

    // 4. 键盘监听
    document.addEventListener('keydown', (e) => {
        // 新增：ESC 退出编辑模式
        if (e.key === 'Escape' && isEditMode) {
            toggleEditMode(false);
            return;
        }
        const hotkey = getConfig('unlockHotkey');
        if (!hotkey) return;
        // e.code 对应物理按键位置，如 ControlLeft, AltLeft, KeyA
        // e.key 对应字符，如 Control, Alt, a
        if (e.code === hotkey || e.key === hotkey) {
            if (!isUnlockMode) toggleUnlockMode(true);
        }
    });

    document.addEventListener('keyup', (e) => {
        const hotkey = getConfig('unlockHotkey');
        if (!hotkey) return;
        if (e.code === hotkey || e.key === hotkey) {
            if (isUnlockMode) toggleUnlockMode(false);
        }
    });
    window.addEventListener('blur', () => {if (isUnlockMode) toggleUnlockMode(false);});// 窗口失焦时自动关闭，防止卡在开启状态

    // 4. 文本处理与复制
    async function copyToClipboard(text, html) {
        try {
            // 优先尝试构建 ClipboardItem 以保留样式 (如果不是纯文本)
            if (html && typeof ClipboardItem !== 'undefined') {
                // 简单的HTML包装
                const htmlBlob = new Blob([html], { type: 'text/html' });
                const textBlob = new Blob([text], { type: 'text/plain' });
                const data = [new ClipboardItem({ 'text/html': htmlBlob, 'text/plain': textBlob })];
                await navigator.clipboard.write(data);
            } else {
                // 回退到纯文本
                await navigator.clipboard.writeText(text);
            }
        } catch (e) {
        // 有些网页 JS 会执行 delete navigator.clipboard 或类似操作，或者抢夺焦点导致浏览器判定当前没有 User Activation，从而引发标准异步剪贴板 API（Clipboard API）failed，此时降级使用 GM 特权 API_GM_setClipboard
        // GM_setClipboard 虽然在某些脚本管理器中一次只支持多种类型，但这里为了兼容更多脚本管理器一次只使用单个参数指定 mimetype
        if (typeof GM_setClipboard === 'function') {
            if (text) {
                // 尝试写入纯文本（稳定）
                GM_setClipboard(text, 'text');
            } else {
                GM_setClipboard(html, 'html');
            }
        } 
        }
    }

    // 显示 Toast
    function showToast(msg) {
        if (!getConfig('enableToast')) return;
        
        let toast = shadowRoot.querySelector('.sc-toast');
        if (!toast) {
            toast = document.createElement('div');
            toast.className = 'sc-toast';
            shadowRoot.appendChild(toast);
        }
        toast.textContent = msg;
        toast.classList.add('show');

        if (toastTimer) clearTimeout(toastTimer);
        toastTimer = setTimeout(() => {
            toast.classList.remove('show');
        }, 1200);
    }
// 智能获取网页背景亮度，返回 'light' 或 'dark' 以决定 UI 主题
    // 逻辑：网页背景深 -> 返回 'light' (浅色UI)；网页背景浅 -> 返回 'dark' (深色UI)
    function getBestContrastTheme() {
        const getBgColor = (el) => {
            if (!el) return null;
            const style = window.getComputedStyle(el);
            return style.backgroundColor; 
        };

        const getBrightness = (colorStr) => {
            // 处理无效值或完全透明
            if (!colorStr || colorStr === 'transparent' || colorStr === 'rgba(0, 0, 0, 0)') return null;
            
            // 提取 RGB
            const match = colorStr.match(/(\d+),\s*(\d+),\s*(\d+)/);
            if (!match) return null;
            
            const [r, g, b] = [parseInt(match[1]), parseInt(match[2]), parseInt(match[3])];
            
            // 计算亮度 (YIQ公式)
            // 结果 0~255，越小越暗
            return (r * 299 + g * 587 + b * 114) / 1000;
        };

        // 1. 优先检测 body 背景
        let brightness = getBrightness(getBgColor(document.body));

        // 2. 如果 body 透明，检测 html (documentElement) 背景
        if (brightness === null) {
            brightness = getBrightness(getBgColor(document.documentElement));
        }

        // 3. 如果 html 也透明，这通常意味着网页使用浏览器默认背景（通常是白色，但在深色模式插件下可能是黑色）
        // 这里作为一个兜底，如果实在读不到背景色，则回退到读取系统/浏览器原本的深色模式偏好
        if (brightness === null) {
            const sysIsDark = window.matchMedia && window.matchMedia('(prefers-color-scheme: dark)').matches;
            // 系统暗 -> 网页可能暗 -> 用浅色UI
            return sysIsDark ? 'theme-light-ui' : 'theme-dark-ui';
        }

        // 4. 根据亮度判断：亮度 < 128 (深色背景) -> 用 'theme-light-ui' (浅色按钮)
        //    否则 -> 用 'theme-dark-ui' (深色按钮)
        return brightness < 128 ? 'theme-light-ui' : 'theme-dark-ui';
    }

// 渲染按钮 (支持 Copy/Search 模式 和 Paste 模式)
    function renderButton(rect, mouseX, mouseY, text, html, mode = 'default', targetInput = null, isEditable = false) {
        // 清理旧的
        const oldBtn = shadowRoot.querySelector('.sc-container');
        if (oldBtn) oldBtn.remove();

        const container = document.createElement('div');
        container.className = 'sc-container';

        // 智能背景色检测与主题应用
        const forceWB = getConfig('forceWhiteBlack');
        
        if (forceWB) {
            // 如果用户强制开启"强制浅色"，则无视网页背景，始终应用浅色 UI
            container.classList.add('theme-light-ui');
        } else {
            // 否则，根据网页实际背景色，自动应用高对比度的主题
            const contrastTheme = getBestContrastTheme();
            container.classList.add(contrastTheme);
        }

        const isCol = getConfig('buttonStyle') === 'col';

        // ================
        // 模式: 编辑模式 (Edit Mode)
        // ================
        if (isEditMode) {
            // 1. 删除按钮
            const delBtn = document.createElement('div');
            delBtn.className = 'sc-btn';
            delBtn.innerHTML = `<svg viewBox="0 0 24 24" width="18" height="18" stroke="currentColor" stroke-width="2" fill="none" stroke-linecap="round" stroke-linejoin="round"><polyline points="3 6 5 6 21 6"></polyline><path d="M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2"></path><line x1="10" y1="11" x2="10" y2="17"></line><line x1="14" y1="11" x2="14" y2="17"></line></svg>`;
            delBtn.title = t('btn_delete');
            delBtn.onmousedown = (e) => { e.preventDefault(); e.stopPropagation(); };
            delBtn.onclick = (e) => {
                e.stopPropagation();
                document.execCommand('delete');
                hideUI();
            };
            container.appendChild(delBtn);

            // 分割线
            const div1 = document.createElement('div');
            div1.className = isCol ? 'divider divider-h' : 'divider divider-v';
            container.appendChild(div1);

            // 2. 加粗按钮
            const boldBtn = document.createElement('div');
            boldBtn.className = 'sc-btn';
            boldBtn.innerHTML = `<svg viewBox="0 0 24 24" width="18" height="18" stroke="currentColor" stroke-width="2" fill="none" stroke-linecap="round" stroke-linejoin="round"><path d="M6 4h8a4 4 0 0 1 4 4 4 4 0 0 1-4 4H6z"></path><path d="M6 12h9a4 4 0 0 1 4 4 4 4 0 0 1-4 4H6z"></path></svg>`;
            boldBtn.title = t('btn_bold');
            boldBtn.onmousedown = (e) => { e.preventDefault(); e.stopPropagation(); };
            boldBtn.onclick = (e) => {
                e.stopPropagation();
                document.execCommand('bold');
                // 加粗通常想保留选区继续操作，这里不立即隐藏，或者延迟隐藏
                // hideUI(); 
            };
            container.appendChild(boldBtn);

            // 分割线
            const div2 = document.createElement('div');
            div2.className = isCol ? 'divider divider-h' : 'divider divider-v';
            container.appendChild(div2);

            // 3. 标记按钮 (黄色背景)
            const highlightBtn = document.createElement('div');
            highlightBtn.className = 'sc-btn';
            highlightBtn.innerHTML = `<svg viewBox="0 0 24 24" width="18" height="18" stroke="currentColor" stroke-width="2" fill="none" stroke-linecap="round" stroke-linejoin="round"><path d="M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6"></path><path d="M15 3a3 3 0 0 1 3 3v6h-1"></path><path d="M10 6l4-3a3 3 0 1 1 3 3L7.5 15.5 6 18l2.5-1.5L18 7"></path></svg>`;
            highlightBtn.title = t('btn_highlight');
            highlightBtn.onmousedown = (e) => { e.preventDefault(); e.stopPropagation(); };
            highlightBtn.onclick = (e) => {
                e.stopPropagation();
                // 使用 hiliteColor (部分浏览器用 backColor)
                if (!document.execCommand('hiliteColor', false, 'yellow')) {
                    document.execCommand('backColor', false, 'yellow');
                }
                hideUI();
            };
            container.appendChild(highlightBtn);
        }
        else 
        // ================
        // 模式 A: 默认模式 
        // ================
        if (mode === 'default' || mode === PASTE_MODE_THREE_BTNS) {
            // 1. 创建复制按钮
            const copyBtn = document.createElement('div');
            copyBtn.className = 'sc-btn';
            copyBtn.innerHTML = `<svg viewBox="0 0 24 24" width="18" height="18" stroke="currentColor" stroke-width="2" fill="none" stroke-linecap="round" stroke-linejoin="round"><rect x="9" y="9" width="13" height="13" rx="2" ry="2"></rect><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"></path></svg>`;
            copyBtn.title = t('btn_copy');
            copyBtn.onmousedown = (e) => { e.preventDefault(); e.stopPropagation(); };
            copyBtn.onclick = async (e) => {
                e.stopPropagation();
                triggerSpringFestivalEffect(e.clientX, e.clientY, shadowRoot); // 触发春节特效 (传入鼠标点击坐标和shadowRoot)
                const contentToCopy = getConfig('enableCache') ? (cachedSelection.text || text) : text;
                const htmlToCopy = getConfig('enableCache') ? (cachedSelection.html || html) : html;
                
                await copyToClipboard(contentToCopy, htmlToCopy);
                
                // [新增] 写入闪电粘贴缓存 (8秒有效)
                if (getConfig('enablePaste')) {
        // 这里用 await 确保写入完成
        await safeSetValue('smart_paste_cache', {
                        text: contentToCopy,
                        timestamp: Date.now()
                    });
                }

                showToast(getSpringFestivalToastText());
                // 延迟50ms消失，人为增加视觉残影，避免立即消失让用户以为没有点到
                setTimeout(hideUI, 50);
            };
            container.appendChild(copyBtn);
const isInInput = targetInput !== null;   // 已由调用方传进来
            // 2. 创建剪切按钮 (仅在编辑区显示)
        if (isInInput && !isEditMode) {
            const div = document.createElement('div');
            div.className = isCol ? 'divider divider-h' : 'divider divider-v';
            container.appendChild(div);

            const cutBtn = document.createElement('div');
            cutBtn.className = 'sc-btn';
            // 剪刀 SVG 图标
            cutBtn.innerHTML = `<svg viewBox="0 0 24 24" width="18" height="18" stroke="currentColor" stroke-width="2" fill="none" stroke-linecap="round" stroke-linejoin="round"><circle cx="6" cy="6" r="3"></circle><circle cx="6" cy="18" r="3"></circle><line x1="20" y1="4" x2="8.12" y2="15.88"></line><line x1="14.47" y1="14.48" x2="20" y2="20"></line><line x1="8.12" y1="8.12" x2="12" y2="12"></line></svg>`;
            cutBtn.title = t('btn_cut'); 
            cutBtn.onmousedown = (e) => { e.preventDefault(); e.stopPropagation(); };
            cutBtn.onclick = async (e) => {
                e.stopPropagation();
                triggerSpringFestivalEffect(e.clientX, e.clientY, shadowRoot); 
                const contentToCopy = getConfig('enableCache') ? (cachedSelection.text || text) : text;
                const htmlToCopy = getConfig('enableCache') ? (cachedSelection.html || html) : html;

                // 尝试执行原生剪切，这样可以保留浏览器的撤销(Ctrl+Z)历史
                try {
                    const success = document.execCommand('cut');
                    if (!success) {
                        throw new Error('execCommand failed');
                    }
                } catch (err) {
                    // 如果原生剪切失败（极少见），则回退到：复制 -> 删除选区
                    await copyToClipboard(contentToCopy, htmlToCopy);
                    // 删除选区内容
                    const selection = window.getSelection();
                    if (selection.rangeCount > 0) {
                        selection.getRangeAt(0).deleteContents();
                    }
                }
                // 写入闪电粘贴缓存
                if (getConfig('enablePaste')) {
                    await safeSetValue('smart_paste_cache', {
                        text: contentToCopy,
                        timestamp: Date.now()
                    });
                }
                setTimeout(hideUI, 35);
            };
            container.appendChild(cutBtn);
        } 
        // 搜索按钮 (仅在非编辑区且字数较少时显示)
        else if (!isInInput && !isEditMode && text.trim().length <= 32) {
            const div = document.createElement('div');
            div.className = isCol ? 'divider divider-h' : 'divider divider-v';
            container.appendChild(div);

            const searchBtn = document.createElement('div');
            searchBtn.className = 'sc-btn';
            searchBtn.innerHTML = `<svg viewBox="0 0 24 24" width="18" height="18" stroke="currentColor" stroke-width="2" fill="none" stroke-linecap="round" stroke-linejoin="round"><circle cx="11" cy="11" r="8"></circle><line x1="21" y1="21" x2="16.65" y2="16.65"></line></svg>`;
            searchBtn.title = t('btn_search');
            searchBtn.onmousedown = (e) => { e.preventDefault(); e.stopPropagation(); };
            searchBtn.onclick = (e) => {
                e.stopPropagation();
                const query = getConfig('enableCache') ? (cachedSelection.text || text) : text;
                let engine = getConfig('searchEngine');
                let url = SEARCH_ENGINES[engine] ? SEARCH_ENGINES[engine].url : (engine.includes('%s') ? engine : SEARCH_ENGINES['google'].url);
                safeOpenTab(url.replace('%s', encodeURIComponent(query.trim())), { active: true });
                setTimeout(hideUI, 50);
            };
            container.appendChild(searchBtn);
        }

        //锁链按钮逻辑
            // 判定当前是否处于编辑状态 (输入框、文本域、富文本)
            const activeEl = document.activeElement;
            const isUserEditing = activeEl && (
                (['INPUT', 'TEXTAREA'].includes(activeEl.tagName) && !activeEl.readOnly) ||
                activeEl.isContentEditable ||
                document.designMode === 'on'
            );
            // 只有在非输入框环境下才进行链接检测
            if (!isUserEditing && !targetInput && mode !== PASTE_MODE_THREE_BTNS) {
                const linkData = extractLinkFromText(text);
                
                if (linkData) {
                    const div = document.createElement('div');
                    div.className = isCol ? 'divider divider-h' : 'divider divider-v';
                    container.appendChild(div);

                    const chainBtn = document.createElement('div');
                    chainBtn.className = 'sc-btn';
                    // CSS绘制锁链图标 (SVG Path)
                    chainBtn.innerHTML = `<svg viewBox="0 0 24 24" width="18" height="18" stroke="currentColor" stroke-width="2" fill="none" stroke-linecap="round" stroke-linejoin="round"><path d="M10 13a5 5 0 0 0 7.54.54l3-3a5 5 0 0 0-7.07-7.07l-1.72 1.71"></path><path d="M14 11a5 5 0 0 0-7.54-.54l-3 3a5 5 0 0 0 7.07 7.07l1.71-1.71"></path></svg>`;
                    chainBtn.title = t('btn_open_link');
                    chainBtn.onmousedown = (e) => { e.preventDefault(); e.stopPropagation(); };
                    
                    chainBtn.onclick = async (e) => {
                        e.stopPropagation();
                        
                        // 网盘密码逻辑
                        let panPassword = null;
                        if (getConfig('enablePaste')) {
                            // 使用上一轮提供的 PAN_DOMAINS
                            const isPan = PAN_DOMAINS.some(d => linkData.host.includes(d));
                            if (isPan) {
                                panPassword = extractPanCode(text);
                            }
                        }

                        if (panPassword) {
                            // 存储交接数据，5秒内打开新页面有效
                            await safeSetValue('pan_paste_handover', {
                                url: linkData.url,
                                code: panPassword,
                                timestamp: Date.now()
                            });
                            showToast(`Password: ${panPassword}`); // 提示用户已提取到密码
                        }

                        safeOpenTab(linkData.url, { active: true });
                        hideUI();
                    };
                    container.appendChild(chainBtn);
                }
            }

            // 检测是否需要显示“校正”按钮
            // 检查当前语言是否为中文
            const curLang = getConfig('language');
            const isChineseEnv = curLang === 'zh-CN' || (curLang === 'auto' && navigator.language.startsWith('zh'));
            
            // 检查是否有目标输入框
            if (isChineseEnv && targetInput) {
                // 预计算是否需要校正 (避免显示无效按钮)
                const isInputType = targetInput.tagName === 'INPUT';
                if (smartCorrectText(text, isInputType) !== null) {
                    
                    const div = document.createElement('div');
                    div.className = isCol ? 'divider divider-h' : 'divider divider-v';
                    container.appendChild(div);

                    const correctBtn = document.createElement('div');
                    correctBtn.className = 'sc-btn';
                    // 使用 SVG 绘制
                    correctBtn.innerHTML = `<svg viewBox="0 0 24 24" width="18" height="18" stroke="currentColor" stroke-width="2" fill="none" stroke-linecap="round" stroke-linejoin="round"><path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"></path><polyline points="14 2 14 8 20 8"></polyline><path d="M9 15l2 2 4-4"></path></svg>`;
                    correctBtn.title = "校正"; // 由于校正功能只面向中文用户，所以这里直接硬编码title
                    correctBtn.onmousedown = (e) => { e.preventDefault(); e.stopPropagation(); };
                    correctBtn.onclick = (e) => {
                        e.stopPropagation();
                        handleTextCorrection(targetInput, text);
                    };
                    container.appendChild(correctBtn);
                }
            }

    // 3. 若处于闪电粘贴三按钮模式，则再在复制和剪切按钮旁追加一个粘贴按钮
    if (mode === PASTE_MODE_THREE_BTNS) {
        const div = document.createElement('div');
        div.className = isCol ? 'divider divider-h' : 'divider divider-v';
        container.appendChild(div);
        const pasteBtn = document.createElement('div');
        pasteBtn.className = 'sc-btn';
        pasteBtn.innerHTML = `<svg viewBox="0 0 24 24" width="18" height="18" stroke="currentColor" stroke-width="2" fill="none" stroke-linecap="round" stroke-linejoin="round"><path d="M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2"></path><rect x="8" y="2" width="8" height="4" rx="1" ry="1"></rect></svg>`;
        pasteBtn.title = t('btn_paste');
        pasteBtn.onmousedown = e => { e.preventDefault(); e.stopPropagation(); };
        pasteBtn.onclick = async (e) => {
            e.stopPropagation();
            // [修改] 异步再次读取（防止缓存刚过期）或者直接传参
            // 为了稳妥，重新读一次
            const cache = await safeGetValue('smart_paste_cache', null);
            if (cache && cache.text) {
                // 由于划词时焦点仍在输入框，这里把 target 设成 document.activeElement 即可
                performPaste(document.activeElement, cache.text);
                await safeSetValue('smart_paste_cache', null);// 这样下次点击输入框就不会再出现粘贴按钮，直到你再次通过脚本复制新内容
            }
            hideUI();
        };
        container.appendChild(pasteBtn);
    }
        } 
        // ===============
        // 模式 B: 粘贴模式 (闪电粘贴)
        // ===============
        else if (mode === 'paste') {
            const pasteBtn = document.createElement('div');
            pasteBtn.className = 'sc-btn';
            // 使用相同风格的粘贴图标
            pasteBtn.innerHTML = `<svg viewBox="0 0 24 24" width="18" height="18" stroke="currentColor" stroke-width="2" fill="none" stroke-linecap="round" stroke-linejoin="round"><path d="M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2"></path><rect x="8" y="2" width="8" height="4" rx="1" ry="1"></rect></svg>`;
            pasteBtn.title = t('btn_paste');
            pasteBtn.onmousedown = (e) => { e.preventDefault(); e.stopPropagation(); };
            pasteBtn.onclick = async (e) => {
                e.stopPropagation();
                // [新增] 优先粘贴网盘密码
                if (typeof sessionPanCode !== 'undefined' && sessionPanCode) {
                    performPaste(targetInput || document.activeElement, sessionPanCode);
                    showToast(t('toast_password_pasted'));
                    // 粘贴后是否销毁？需求说"缓存仅在当前标签页有效"，未明确说粘贴一次就废弃
                    // 但为了体验，通常保留直到刷新，或者手动不销毁。
                    // 需求："即使销毁缓存的密码" -> 意味着粘贴一次后销毁？
                    // "点击即可将提取到的...并且即使销毁缓存的密码" -> 应该是即时销毁
                    sessionPanCode = null; 
                    hideUI();
                    return;
                }
                // 执行粘贴逻辑
                performPaste(targetInput, text); // 这里的 text 参数其实已经是传进来的 cache.text 了，可以直接用
                // 粘贴后异步清除缓存，防止重复出现粘贴按钮
                await safeSetValue('smart_paste_cache', null);
                hideUI();
            };
            container.appendChild(pasteBtn);
        }

        const btnCount = container.children.length;
        container.setAttribute('data-btn-count', btnCount);

        shadowRoot.appendChild(container);

        // 计算位置 (通用逻辑)
        container.style.left = '-9999px';
        
        requestAnimationFrame(() => {
            const btnRect = container.getBoundingClientRect();
            const btnW = btnRect.width;
            const btnH = btnRect.height;
            const offset = getConfig('offset');
            const viewportW = window.innerWidth;
            const viewportH = window.innerHeight;

            let targetX, targetY;

            // 如果有 rect (Endchar模式 或 ContentEditable光标)，优先跟随 rect
            if (rect) { 
                // 如果 rect 对象包含了我们注入的方向信息 (来自 getSmartSelectionState)
                const isBackward = rect.isBackward || false;
                const isVertical = rect.isVertical || false;
                if (isVertical) {
                    // === 垂直排版处理 (vertical-rl / vertical-lr) ===
                    // 简单处理：正向(下/左)放左侧，反向(上/右)放右侧
                    if (isBackward) {
                        targetX = rect.right + offset;
                        targetY = rect.top; 
                } else {
                    targetX = rect.left - btnW - offset;
                    targetY = rect.bottom - btnH; 
                }
            } else {
                // === 水平排版处理 (默认) ===
                if (isBackward) {
                    // 反向选区 (光标在左/上)：按钮显示在 Rect 的【正上方】
                    targetX = rect.left - (btnW / 2); 
                    targetY = rect.top - btnH - offset;
                } else {
                    // 正向选区 (光标在右/下)：按钮显示在 Rect 的【正下方】
                    targetX = rect.right - (btnW / 2);
                    // 智能避让：如果底部空间不足，自动放到上方 (仅针对正向)
                    const spaceBelow = viewportH - rect.bottom;
                            if (spaceBelow < (btnH + offset + 20)) {
                                targetY = rect.top - btnH - offset;
                            } else {
                                targetY = rect.bottom + offset;
                            }
                        }
                    }
                } else {
                        // Mouse 模式 或 Input 无 Rect 时的兜底
    
    // [修改] 纵向逻辑: 锚点位于视口纵向中线之下，按钮显示在上方；否则显示在下方
    if (mouseY > viewportH / 2) {
        targetY = mouseY - btnH - offset;
    } else {
        targetY = mouseY + offset;
    }

    // [新增] 横向逻辑: 锚点位于视口横向中线右侧，按钮显示在左侧；否则(左侧或重合)显示在右侧
    if (mouseX > viewportW / 2) {
        targetX = mouseX - btnW - offset;
    } else {
        targetX = mouseX + offset;
    }
                }

            // 边缘检测
            const margin = 10;
            targetX = Math.max(margin, Math.min(targetX, viewportW - btnW - margin));
            targetY = Math.max(margin, Math.min(targetY, viewportH - btnH - margin));

            container.style.left = `${targetX}px`;
            container.style.top = `${targetY}px`;
            container.classList.add('visible');

            // 设置自动消失
            const timeout = getConfig('timeout');
            if (timeout > 0) {
                if (uiTimer) clearTimeout(uiTimer);
                uiTimer = setTimeout(hideUI, timeout);
            }
        });
    }

    function hideUI() {
        const btn = shadowRoot && shadowRoot.querySelector('.sc-container');
        if (btn) {
            btn.classList.remove('visible');
            setTimeout(() => {
                if (btn && btn.parentNode) btn.remove();
            }, 200);
        }
        cachedSelection = { text: '', html: '' };
    }

    // ===========
    // 6. 事件监听 (Event Listeners)
    // ===========
function handleSelectionMouseUp(e) {
    if (hostElement && e.composedPath().includes(hostElement)) {return;} //如果点击的是脚本自身的UI内部，直接忽略，以防点击按钮时全局mouseup事件再次触发按钮重绘
    if (!hostElement) initContainer();
    if (isScrolling) return;
    setTimeout(async () => {
        const selection = window.getSelection();
        if (!selection || selection.rangeCount === 0) {
            hideUI();
            return;
        }
        const text = selection.toString();
        if (!text || text.trim().length === 0) {
                hideUI();
            return;
        }
        const range = selection.getRangeAt(0);
        if (getConfig('enableCache')) {
            const container = document.createElement('div');
            container.appendChild(range.cloneContents());
            cachedSelection = {
                text: text,
                html: container.innerHTML
            };
        }
        let rect = null;
        if (getConfig('positionMode') === 'endchar') {
            const smartState = getSmartSelectionState(selection, e);// 使用新算法获取智能 Rect，传入 e (MouseEvent) 以便在框架销毁DOM节点时进行第三级降级定位
            if (smartState) {
                rect = smartState.rect;
                // 将方向信息挂载到 rect 对象上，传递给 renderButton
                // 这样做是为了避免修改 renderButton 的参数签名，保持兼容
                if (rect) {
                    rect.isBackward = smartState.isBackward;
                    rect.isVertical = smartState.isVertical;
                }
            }
        }
        
        initContainer();
        let cache = null;
        if (getConfig('enablePaste')) {
            cache = await safeGetValue('smart_paste_cache', null);
        }
        const cacheValid = cache && (Date.now() - cache.timestamp < 8000);
        const target = document.activeElement;
        const isInput = target && (
            (['INPUT', 'TEXTAREA'].includes(target.tagName) && !target.disabled && !target.readOnly) ||
            target.isContentEditable
        );
        const mode = (cacheValid && isInput) ? PASTE_MODE_THREE_BTNS : 'default';
        renderButton(rect, e.clientX, e.clientY, text, cachedSelection.html || '', mode, isInput ? target : null, isInput);
    }, 10);
}
    // 监听 mousedown，如果点击非按钮区域，取消UI的timeout（准备隐藏）
    function handleGlobalMouseDown(e) {
        if (hostElement && e.composedPath().includes(hostElement)) {
            // 点击了按钮内部，保持
        } else {
            // 点击了页面其他位置，虽然mouseup会触发hideUI，
            // 但这里可以做一个预判，或者清空timer让其立即生效
            const btn = shadowRoot && shadowRoot.querySelector('.sc-container');
            if (btn) btn.classList.remove('visible'); // 视觉上立即消失
        }
    }

    // 滚动与调整大小处理
    const handleResizeOrScroll = () => {
        if (!hostElement) return;
        
        // 隐藏按钮
        const btn = shadowRoot.querySelector('.sc-container');
        if (btn && btn.classList.contains('visible')) {
            btn.classList.remove('visible'); // 临时隐藏
            isScrolling = true;
            
            if (scrollTimeout) clearTimeout(scrollTimeout);
            scrollTimeout = setTimeout(() => {
                isScrolling = false;
                // 停止滚动后，检查选区是否还存在
                const selection = window.getSelection();
                if (selection && selection.toString().trim().length > 0) {
                    // 重新定位
                    // 为了简化，这里触发一次模拟的逻辑，或者简单地重新获取位置
                    // 由于丢失了 mouseX/Y，如果原先是Mouse定位可能会有问题
                    // 所以这里强制尝试用 endchar 重新定位，如果不行则保持隐藏
                    // 实际上 Req 4 要求重新定位。
                    
                    const range = selection.getRangeAt(0);
                    const rects = range.getClientRects();
                    if (rects.length > 0) {
                        const rect = rects[rects.length - 1];
                        // 传入模拟的 mouseX Y (rect center) 作为 fallback
                        renderButton(rect, rect.right, rect.top, selection.toString(), getConfig('enableCache')?cachedSelection.html:'');
                    }
                }
            }, 300); // debounce 300ms
        }
    };

    function handleContextMenu(e) {
    hideUI(); // 右键立即清除按钮
    
    // 右键清除缓存
    if (getConfig('enablePaste')) {
        // 清除本地缓存
        safeSetValue('smart_paste_cache', null);
        // 清除网盘密码缓存
        sessionPanCode = null;
        // 清除网盘密码交接缓存
        safeSetValue('pan_paste_handover', null);
        
        // 可选：显示提示（可根据需要决定是否显示）
        // showToast('粘贴缓存已清除');
    }
}

    function handleKeydownHideUI(e) {if (isUnlockMode) return;hideUI();} // 任意键按下立即无条件隐藏按钮，但超级划词模式下不隐藏按钮

// [新增] 智能文本校正核心算法
    function smartCorrectText(text, isInputType) {
        // 0. 基础判定
        const hasHanzi = /[\u4e00-\u9fa5]/.test(text);
        const hasCNPunct = /[，。：；？！“”‘’（）【】《》]/.test(text);
        const hasNum = /\d/.test(text);

        // 判定生效条件
        let activeRules = {
            basic: hasHanzi, // 规范 1, 2, 5, 9 (依赖汉字)
            punct: hasHanzi || hasCNPunct, // 规范 3, 8
            unit: hasHanzi || hasCNPunct || hasNum, // 规范 4, 7
            pureCN: hasHanzi && !/[a-zA-Z]/.test(text.replace(/[a-zA-Z]+(?=[%℃$])/, '')) // 规范 6 (排除单位后无英文字母)
        };

        if (!activeRules.basic && !activeRules.punct && !activeRules.unit) return null;

        // 辅助：正则替换，跳过引号内的内容 ("..." 或 “...”)
        // 使用 split 分割法：偶数索引为引号外，奇数索引为引号内
        const applyRule = (txt, regex, replacement) => {
            const parts = txt.split(/(".*?"|“.*?”)/g);
            return parts.map((part, i) => {
                if (i % 2 === 1) return part; // 引号内，保持原样
                return part.replace(regex, replacement);
            }).join('');
        };

        let result = text;

        // --- 规范 9: 换行/删空判定 (优先级最高，先处理结构) ---
        // 模式：汉字/句号 + 2空格 + 汉字/数字
        if (activeRules.basic) {
            const rule9Regex = /([\u4e00-\u9fa5。])(\s{2,})(?=[\u4e00-\u9fa5]|\d{1,3}(?:[、.]|\s))/g;
            result = applyRule(result, rule9Regex, (match, p1, p2) => {
                return p1 + (isInputType ? '' : '\n'); // Input删空格，Textarea换行
            });
        }

        // --- 规范 6: 纯中文环境下的英文标点转中文 ---
        if (activeRules.pureCN) {
            // 句号特殊处理
            const parts = result.split(/(".*?"|“.*?”)/g);
            result = parts.map((part, i) => {
                if (i % 2 === 1) return part;
                let p = part;
                // 3个及以上点 -> ……
                p = p.replace(/\.{3,}/g, '……');
                // 2个点 -> 。
                p = p.replace(/\.{2}/g, '。');
                // 单个点：两边是数字不改，否则改
                p = p.replace(/(?<!\d)\.(?!\d)|(?<=\d)\.(?!\d)|(?<!\d)\.(?=\d)/g, '。');
                
                // 其他标点映射
                const map = {',':'，', '?':'？', '!':'！', ':':'：', ';':'；', '(':'（', ')':'）'};
                p = p.replace(/[,?!:;()]/g, m => map[m]);
                // 引号简单的成对替换逻辑比较复杂，这里仅处理明显情况，复杂情况交由后续规范
                return p;
            }).join('');
        }

        // --- 规范 1: 中英之间加空格 ---
        if (activeRules.basic) {
            result = applyRule(result, /([\u4e00-\u9fa5])([a-zA-Z])/g, '$1 $2');
            result = applyRule(result, /([a-zA-Z])([\u4e00-\u9fa5])/g, '$1 $2');
        }

        // --- 规范 2: 中文与数字(含运算)加空格 ---
        // 只有当选区包含明确的数学运算符 (+, *, /, =) 或 "等于" 时，才将 "-" 视为减号并加空格；否则将其视为连词符，不加空格。
        if (activeRules.basic) {
            // 1. 检查是否存在数学语境
            const isMathContext = /[+*/=]|等于/.test(text);
            
            // 2. 构建字符集
            // 如果是数学语境，匹配 [\d+\-*/=] (注意 - 需要转义)
            // 如果非数学语境，仅匹配 [\d] (数字)
            const charSet = isMathContext ? '[\\d+\\-*/=]' : '[\\d]';

            // 构造正则：中文前看/后看
            // 解释：new RegExp 需要双重转义 \\
            const regex1 = new RegExp(`([\\u4e00-\\u9fa5])(?=${charSet})`, 'g'); // 中文 + [数字/符号]
            const regex2 = new RegExp(`(${charSet})(?=[\\u4e00-\\u9fa5])`, 'g'); // [数字/符号] + 中文

            result = applyRule(result, regex1, '$1 ');
            result = applyRule(result, regex2, '$1 ');
        }

        // --- 规范 3: 字符/数字与后方标点去空格 ---
        if (activeRules.punct) {
            result = applyRule(result, /([a-zA-Z0-9\u4e00-\u9fa5])\s+([,.:;?!，。：；？！、\])}（）】【《》[({“^”‘^’"'])/g, '$1$2');
        }

        // --- 规范 4: 数字/字符与单位 (%, ℃, $) ---
        if (activeRules.unit) {
            // 数字 + 空格 + 单位 -> 去空格
            result = applyRule(result, /(\d)\s+([%℃$])/g, '$1$2');
            // 非空非数字 + 无空格 + 单位 -> 加空格
            result = applyRule(result, /([^\s\d])([%℃$])/g, '$1 $2');
        }

        // --- 规范 5: 中文句号去重 ---
        if (activeRules.basic) {
            const parts = result.split(/(".*?"|“.*?”)/g);
            result = parts.map((part, i) => {
                if (i % 2 === 1) return part;
                // >8个: 不改 (忽略)
                // 3-8个: ……
                part = part.replace(/。{3,8}/g, '……');
                // 2个: 。
                part = part.replace(/。{2}/g, '。');
                return part;
            }).join('');
        }

        // --- 规范 7: 数字间中文冒号转英文 ---
        if (activeRules.unit) {
            result = applyRule(result, /(\d)\s*：\s*(\d)/g, '$1:$2');
        }

        // --- 规范 8: 双引号修正 (仅当只有一对时) ---
        if (activeRules.punct) {
            const quoteCount = (result.match(/[“”]/g) || []).length;
            if (quoteCount === 2) {
                let qIndex = 0;
                result = result.replace(/[“”]/g, () => {
                    qIndex++;
                    return qIndex === 1 ? '“' : '”';
                });
            }
        }

        return result === text ? null : result;
    }

    // [新增] 执行校正操作
    async function handleTextCorrection(target, originalText) {
        const isInput = target.tagName === 'INPUT';
        const newText = smartCorrectText(originalText, isInput);
        
        if (!newText) {
            showToast('无需校正');
            return;
        }

        // 尝试写入
        if (document.execCommand && typeof document.execCommand === 'function') {
            try {
                target.focus();
                // 选中当前选区 (因为点击按钮可能丢失了部分焦点状态，或者需要全选替换选中部分)
                // 实际上 PicKit 的逻辑是基于 selection 的，这里直接执行 insertText 会替换选区
                document.execCommand('insertText', false, newText);
            } catch (e) {
                performPaste(target, newText); // 降级使用 paste 逻辑
            }
        } else {
            performPaste(target, newText);
        }
        
        showToast('文本已校正');
        hideUI();
    }

    // [新增] 执行粘贴的核心逻辑
    function performPaste(target, text) {
        if (!target) return;
        target.focus();

        // 策略 1: document.execCommand (保留撤销能力，最稳妥)
        try {
            const success = document.execCommand('insertText', false, text);
            if (success) {
                showToast(t('toast_pasted'));
                return;
            }
        } catch (e) {

        // 策略 2: 直接赋值 + 触发事件 (兼容 Vue/React)
        try {
            // 针对 ContentEditable
            if (target.isContentEditable) {
                // 简单的 HTML 插入或 Text 插入
                const sel = window.getSelection();
                if (sel.rangeCount > 0) {
                    const range = sel.getRangeAt(0);
                    range.deleteContents();
                    range.insertNode(document.createTextNode(text));
                    range.collapse(false); // 光标后移
                } else {
                    target.innerText += text;
                }
            } else {
                // 针对 Input / Textarea
                // 拼接字符串 (防止覆盖原有内容)
                const start = target.selectionStart || 0;
                const end = target.selectionEnd || 0;
                const oldVal = target.value;
                const newVal = oldVal.slice(0, start) + text + oldVal.slice(end);
                
                // 获取 Prototype Setter
                // 必须区分 Input 和 TextArea
                let proto = window.HTMLInputElement.prototype;
                if (target.tagName === 'TEXTAREA') {
                    proto = window.HTMLTextAreaElement.prototype;
                }

                const nativeValueSetter = Object.getOwnPropertyDescriptor(proto, "value").set;
                
                // 执行赋值
                if (nativeValueSetter && nativeValueSetter.call) {
                     nativeValueSetter.call(target, newVal);
                } else {
                    target.value = newVal;
                }
                
                // 触发事件通知框架
                target.dispatchEvent(new Event('input', { bubbles: true }));
                target.dispatchEvent(new Event('change', { bubbles: true }));
                
                // 恢复光标(移动到粘贴内容之后)
                const newCursorPos = start + text.length;
                target.setSelectionRange(newCursorPos, newCursorPos);
            }
            showToast(t('toast_paste_compat'));
        } catch (e) {
            // console.error('Paste failed', e);
            showToast(t('toast_paste_fail'));
            }
        }
    }

function handleInputPasteMouseUp(e) {
    if (!getConfig('enablePaste')) return;
    const target = e.target;
    const isInput = (['INPUT', 'TEXTAREA'].includes(target.tagName) && !target.disabled && !target.readOnly) || target.isContentEditable;
    if (!isInput) return;
    setTimeout(async () => { // 延迟执行，确保在 handleSelectionMouseUp 之后运行 (后者通常延迟10ms，我们用20ms覆盖它)
        // 如果有网盘提取的密码 (优先级高于普通缓存)
        if (sessionPanCode) {
            initContainer(); // 确保容器存在
            // 计算输入框位置
            const rect = target.getBoundingClientRect();
            // 渲染特殊的粘贴按钮
            renderButton(rect, e.clientX, e.clientY, '', '', 'paste'); 
            
            // 劫持该按钮的点击事件 (通过修改 renderButton 里的逻辑比较复杂，
            // 建议在这里通过 DOM 操作覆盖 onclick，或者在 renderButton 的 'paste' 模式里处理)
            // 更简单的做法是：让 renderButton 的 paste 模式优先读取 sessionPanCode
            return;
        }
        // 1. 获取剪贴板缓存
        const cache = await safeGetValue('smart_paste_cache', null);
        if (!cache || !cache.text) return; // 如果没有有效缓存，通常不做处理（交由主划词逻辑），但由于主逻辑对 input 支持不佳，这里可以不做任何操作，或者仅仅依靠缓存存在才触发
        if (Date.now() - cache.timestamp > 8000) { // 缓存过期检查 (8秒)
            await safeSetValue('smart_paste_cache', null);
            return;
        }
    // 2. 核心修正：检测输入框内是否真正选中了文本
    let selectedText = ''; 
    let hasSelection = false;
    if (['INPUT', 'TEXTAREA'].includes(target.tagName)) {
        const start = target.selectionStart;
        const end = target.selectionEnd;
        if (typeof start === 'number' && typeof end === 'number' && start !== end) {
            selectedText = target.value.substring(start, end);
            hasSelection = true;
        }
    } else if (target.isContentEditable) {
        // 对于 contentEditable，window.getSelection 通常有效
        const sel = window.getSelection();
        if (sel && sel.rangeCount > 0 && !sel.isCollapsed) {
            selectedText = sel.toString();
            hasSelection = true;
        }
    }

    // 3. 决定模式
    // 有选区，如果选中了无意义字符（单个空格或中文逗号），视作用户想要“替换”该字符，仍使用单按钮粘贴模式，否则使用三按钮模式 (复制当前选区文本 + 搜索当前选区文本 + 粘贴缓存文本)
    // 无选区 (仅仅是点击)则直接使用单按钮模式 (粘贴缓存文本)
    const isReplaceIntent = selectedText === ' ' || selectedText === '，';
    const mode = (hasSelection && !isReplaceIntent) ? PASTE_MODE_THREE_BTNS : 'paste';

    // 4. 准备参数
    // renderButton 的 text 参数：
    // - 在 'paste' 模式下，它代表"要粘贴的内容" (即 cache.text)
    // - 在 'copy-search-paste' 模式下，它代表"要复制/搜索的内容" (即 selectedText)
    const textArg = (mode === 'paste') ? cache.text : selectedText;

    // 5. 计算位置 (输入框内通常无法获取精确光标 Rect，降级使用鼠标位置)
        let rect = null;
        if (target.isContentEditable && hasSelection) {
            const sel = window.getSelection();
            if (sel.rangeCount > 0) {
                const range = sel.getRangeAt(0);
                const rects = range.getClientRects();
                if (rects.length > 0) {
                    rect = rects[rects.length - 1];
                }
            }
        }
        if (!hostElement) initContainer();
        renderButton(rect, e.clientX, e.clientY, textArg, '', mode, target);
    }, 20);
}

// ====================
    // 7. 元素屏蔽子系统 (Element Blocker Subsystem)
    // ================

    let pickerOverlay = null;
    let pickerHandler = null;
    let pickerClickHandler = null;
    let pickerEscHandler = null;
    let pickerRightClickHandler = null;

    // 自动应用已保存的规则
    function applySavedBlockingRules() {
        const rules = configCache['blocked_elements'] || {}; 
        const domain = location.hostname;
        if (rules[domain] && Array.isArray(rules[domain])) {
            // 将选择器合并为一条CSS规则
            const cssText = rules[domain].join(', ') + ' { display: none !important; visibility: hidden !important; opacity: 0 !important; pointer-events: none !important; }';
            GM_addStyle(cssText);
            // console.log('Smart Copy: Applied blocking rules for', rules[domain]);
        }
    }

    // 激活拾取模式
    function activateElementPicker() {
        // 如果已经在运行，先清理
        if (pickerOverlay) disablePicker();

        showToast(t('picker_active'));

        // 创建高亮遮罩
        pickerOverlay = document.createElement('div');
        pickerOverlay.style.all = 'initial';
        pickerOverlay.style.position = 'fixed';
        pickerOverlay.style.pointerEvents = 'none';
        pickerOverlay.style.border = '2px solid #ff0000';
        pickerOverlay.style.background = 'rgba(255, 0, 0, 0.1)';
        pickerOverlay.style.zIndex = '2147483646'; // 略低于脚本主容器
        pickerOverlay.style.transition = 'all 0.1s ease';
        pickerOverlay.style.display = 'none';
        document.body.appendChild(pickerOverlay);

        // 鼠标移动处理
        pickerHandler = (e) => {
            const target = e.target;
            // 忽略脚本自身UI 和 遮罩本身
            if (target === hostElement || hostElement.contains(target) || target === pickerOverlay) return;

            const rect = target.getBoundingClientRect();
            pickerOverlay.style.display = 'block';
            pickerOverlay.style.top = rect.top + 'px';
            pickerOverlay.style.left = rect.left + 'px';
            pickerOverlay.style.width = rect.width + 'px';
            pickerOverlay.style.height = rect.height + 'px';
        };

        // 点击处理
        pickerClickHandler = (e) => {
            e.preventDefault();
            e.stopPropagation();
            e.stopImmediatePropagation();

            const target = e.target;
            // 防自杀
            if (target === hostElement || hostElement.contains(target)) {
                showToast(t('picker_cant_block_self'));
                return;
            }

            const selector = generateCssSelector(target);
            if (confirm(t('picker_confirm', selector) + `\n(Domain: ${location.hostname})`)) {
                saveBlockRule(selector);
                // 立即隐藏
                target.style.display = 'none';
                showToast(t('picker_saved'));
                disablePicker();
            }
        };

        // ESC 退出
        pickerEscHandler = (e) => {
            if (e.key === 'Escape') {
                disablePicker();
                showToast(t('picker_exit'));
            }
        };

        // 右键 取消
        pickerRightClickHandler = (e) => {
        e.preventDefault();
        e.stopPropagation();
        disablePicker();
        };

        document.addEventListener('contextmenu', pickerRightClickHandler, true);
        document.addEventListener('mousemove', pickerHandler, true);
        document.addEventListener('click', pickerClickHandler, true);
        document.addEventListener('keydown', pickerEscHandler, true);
    }

    // 退出拾取模式
    function disablePicker() {
        if (pickerOverlay) {
            pickerOverlay.remove();
            pickerOverlay = null;
        }
        document.removeEventListener('mousemove', pickerHandler, true);
        document.removeEventListener('click', pickerClickHandler, true);
        document.removeEventListener('keydown', pickerEscHandler, true);
        document.removeEventListener('contextmenu', pickerRightClickHandler, true);
        pickerRightClickHandler = null;

    }

    // 生成尽可能短且唯一的 CSS 选择器
    function generateCssSelector(el) {
        if (el.id) return '#' + CSS.escape(el.id);
        
        const tagName = el.tagName.toLowerCase();
        let selector = tagName;
        
        // 尝试使用 class
        if (el.className && typeof el.className === 'string' && el.className.trim().length > 0) {
            // 过滤掉可能动态变化的随机类名（简单启发式：过长的通常是乱码，这里暂不过滤，全取）
            const classes = el.className.trim().split(/\s+/);
            // 拼接前两个类名通常够用了，避免选择器太长
            classes.slice(0, 3).forEach(c => {
                selector += '.' + CSS.escape(c);
            });
        }
        
        // 如果没有ID也没有Class，或者只有TagName，为了避免误伤全站标签，尝试加父级
        if (selector === tagName) {
            if (el.parentElement && el.parentElement !== document.body) {
                return generateCssSelector(el.parentElement) + ' > ' + tagName;
            }
        }

        return selector;
    }

    // 保存规则到 GM 存储
    function saveBlockRule(selector) {
        const rules = configCache['blocked_elements'] || {};
        const domain = location.hostname;
        
        if (!rules[domain]) rules[domain] = [];
        if (!rules[domain].includes(selector)) {
            rules[domain].push(selector);
            // 更新缓存
            configCache['blocked_elements'] = rules;
            // 异步保存
            safeSetValue('blocked_elements', rules);
        }
    }

    // 启动时应用规则
    applySavedBlockingRules();
    // ===============
    // 烟花粒子特效模块
    // ===============
// 春节/圣诞 彩蛋逻辑判断
    function getFestivalType() {
        const now = new Date();
        // 1. 尝试检测农历 (Chinese Lunar)
        try {
            const formatter = new Intl.DateTimeFormat("zh-CN-u-ca-chinese", { month: "numeric", day: "numeric" });
            // 关键：检查浏览器是否真的支持并使用了农历，否则 Intl 会静默回退到公历
            if (formatter.resolvedOptions().calendar === 'chinese') {
                const parts = formatter.formatToParts(now);
                const monthPart = parts.find(p => p.type === 'month').value;
                const dayPart = parts.find(p => p.type === 'day').value;

                // 宽松解析月份：兼容 "正月"、"1月"、"1"
                const isLunarJan = monthPart.includes('正') || monthPart.replace(/[^\d]/g, '') === '1';
                // 解析日期
                const day = parseInt(dayPart.replace(/[^\d]/g, ''));

                // 如果能读到农历，则规则为：仅在农历正月初一生效
                if (isLunarJan && day === 1) return 'CNY'; 
                return 'NONE'; // 既然支持农历但不是初一，则强制不生效（不回退到圣诞判断）
            }
        } catch (e) {
            // 忽略错误，进入下方回退逻辑
        }

        // 2. 回退逻辑：如果不支持农历，则判断是否为公历 12月25日
        if (now.getMonth() === 11 && now.getDate() === 25) {
            return 'XMAS';
        }
        
        return 'NONE';
    }

    // 触发烟花特效
    function triggerSpringFestivalEffect(x, y, shadowRoot) {
        const festival = getFestivalType();
        if (festival === 'NONE') return;

        // 根据节日配置颜色
        let colors = [];
        if (festival === 'CNY') {
            // 春节：红、金、橙、紫红
            colors = ['#FF0000', '#FFD700', '#FF4500', '#DC143C', '#FFFF00'];
        } else if (festival === 'XMAS') {
            // 圣诞：红、绿、金、白
            colors = ['#FF0000', '#228B22', '#FFD700', '#FFFFFF', '#006400'];
        }

        const activeColors = [];
        for (let i = 0; i < 3; i++) {
            activeColors.push(colors[Math.floor(Math.random() * colors.length)]);
        }

        const particleCount = 20 + Math.floor(Math.random() * 21);
        const fragment = document.createDocumentFragment();

        for (let i = 0; i < particleCount; i++) {
            const p = document.createElement('div');
            const size = 4 + Math.random() * 3;
            const color = activeColors[Math.floor(Math.random() * activeColors.length)];
            
            p.style.cssText = `
                position: fixed;
                left: ${x}px;
                top: ${y}px;
                width: ${size}px;
                height: ${size}px;
                background-color: ${color};
                border-radius: 50%;
                pointer-events: none;
                z-index: 2147483647;
                box-shadow: 0 0 6px ${color};
                will-change: transform, opacity;
            `;

            const angle = Math.random() * Math.PI * 2;
            const speed = 2 + Math.random() * 5;
            let vx = Math.cos(angle) * speed;
            let vy = Math.sin(angle) * speed;
            let opacity = 1.0;
            const gravity = 0.2 + Math.random() * 0.1;
            const friction = 0.96; 
            const decay = 0.01 + Math.random() * 0.02;

            let posX = x;
            let posY = y;

            const animate = () => {
                if (opacity <= 0) {
                    p.remove();
                    return;
                }
                vx *= friction;
                vy *= friction;
                vy += gravity;
                posX += vx;
                posY += vy;
                opacity -= decay;

                p.style.transform = `translate(${posX - x}px, ${posY - y}px)`;
                p.style.opacity = opacity;
                requestAnimationFrame(animate);
            };

            fragment.appendChild(p);
            requestAnimationFrame(animate);
        }
        shadowRoot.appendChild(fragment);
    }

    // 获取 Toast 提示文案
    function getSpringFestivalToastText() {
        const festival = getFestivalType();
        if (festival === 'CNY') {
            return t('festival_cny');
        } else if (festival === 'XMAS') {
            return t('festival_xmas');
        }
        return t('toast_copied');
    }
    // 9. 码字防丢子系统 (Input Recovery Subsystem)
    let inputDebounceTimer = null;

    // 获取用于缓存的 URL Key
    function getRecoveryUrlKey() {
        const mode = getConfig('inputRecoveryMode');
        // 禁用功能
        if (mode === 'off') return null;

        // 启用为严格模式：整段 URL 完全匹配
        if (mode === 'strict') return location.href;

        // 启用为宽松模式：只要出现 ? 就把后面的内容全部扔掉（粗略地剔除跟踪参数）
        const raw = location.href;
        const qMark = raw.indexOf('?');
        return qMark === -1 ? raw : raw.slice(0, qMark);
    }

    // 生成元素的唯一标识符 (这是复用或简化版本)
    function getRecoverySelector(el) {
        if (el.id) return '#' + CSS.escape(el.id);
        if (el.name) return el.tagName.toLowerCase() + `[name="${CSS.escape(el.name)}"]`;
        
        // 生成基于路径的简易选择器
        let path = [];
        let curr = el;
        while (curr && curr !== document.body && curr !== document.documentElement) {
            let tag = curr.tagName.toLowerCase();
            let index = 1;
            let sibling = curr.previousElementSibling;
            while (sibling) {
                if (sibling.tagName === curr.tagName) index++;
                sibling = sibling.previousElementSibling;
            }
            path.unshift(`${tag}:nth-of-type(${index})`);
            curr = curr.parentElement;
        }
        return path.join(' > ');
    }

    // 执行保存逻辑
    async function handleInputSave(e) {
        const target = e.target;
        if (target.dataset.tmScRestoring === 'true') return;// [新增] 如果该元素正在被脚本恢复数据，则忽略此次 Input 事件，避免将刚恢复的文本再次存入缓存
        const mode = getConfig('inputRecoveryMode');
        if (mode === 'off') return;

        // 仅针对文本类输入框
        if (!['TEXTAREA', 'INPUT'].includes(target.tagName)) return;
        if (target.tagName === 'INPUT' && !['text', 'search', 'email', 'url', 'tel', 'number'].includes(target.type)) return;
        
        // 这里的 value 是用户当前的输入
        const val = target.value;
        const selector = getRecoverySelector(target);
        const urlKey = getRecoveryUrlKey();

        if (!urlKey) return;

        if (inputDebounceTimer) clearTimeout(inputDebounceTimer);
        
        inputDebounceTimer = setTimeout(async () => {
            const cache = await safeGetValue('tm_input_recovery_cache', {});
            
            if (!cache[urlKey]) cache[urlKey] = {};
            
            if (!val || val.trim() === '') {
                // 如果值为空（用户主动删除或JS清空），则从缓存移除
                delete cache[urlKey][selector];
                // 如果该URL下没数据了，清理URL Key
                if (Object.keys(cache[urlKey]).length === 0) delete cache[urlKey];
            } else {
                // 更新缓存
                cache[urlKey][selector] = {
                    text: val,
                    ts: Date.now()
                };
            }
            
            // 写入存储
            await safeSetValue('tm_input_recovery_cache', cache);
        }, 500); // 500ms 防抖
    }

    // 表单提交时主动清除缓存
    async function handleFormSubmit(e) {
        const mode = getConfig('inputRecoveryMode');
        if (mode === 'off') return;
        
        // 尝试找到被提交表单内的所有输入框并清除其缓存
        const form = e.target;
        if (!form || form.tagName !== 'FORM') return;

        const inputs = form.querySelectorAll('input, textarea');
        if (inputs.length === 0) return;

        const cache = await safeGetValue('tm_input_recovery_cache', {});
        const urlKey = getRecoveryUrlKey();
        
        if (!cache[urlKey]) return;

        let modified = false;
        inputs.forEach(el => {
            const sel = getRecoverySelector(el);
            if (cache[urlKey][sel]) {
                delete cache[urlKey][sel];
                modified = true;
            }
        });

        if (modified) {
            if (Object.keys(cache[urlKey]).length === 0) delete cache[urlKey];
            await safeSetValue('tm_input_recovery_cache', cache);
        }
    }

    // 恢复文本逻辑
    async function restoreInputData() {
        const mode = getConfig('inputRecoveryMode');
        if (mode === 'off') return;

        const urlKey = getRecoveryUrlKey();
        const cache = await safeGetValue('tm_input_recovery_cache', {});
        const pageData = cache[urlKey];

        if (!pageData) return;

        // 遍历缓存的选择器
        Object.keys(pageData).forEach(selector => {
            const entry = pageData[selector];
            // 缓存有效期 24小时，超过则忽略
            if (Date.now() - entry.ts > 24 * 60 * 60 * 1000) return;

            const el = document.querySelector(selector);
            // 只有当元素存在，且当前值为空（防止覆盖用户刚输入的内容或浏览器自带填充）时才恢复
            if (el && (!el.value || el.value.trim() === '')) {
                // 模拟 React/Vue 的原生 Setter 逻辑 (复用 performPaste 的一部分逻辑)
                const nativeInputValueSetter = Object.getOwnPropertyDescriptor(
                    window.HTMLInputElement.prototype, 
                    "value"
                ).set;
                const nativeTextAreaValueSetter = Object.getOwnPropertyDescriptor(
                    window.HTMLTextAreaElement.prototype, 
                    "value"
                ).set;

                const setter = el.tagName === 'INPUT' ? nativeInputValueSetter : nativeTextAreaValueSetter;

                if (setter && setter.call) {
                    setter.call(el, entry.text);
                } else {
                    el.value = entry.text;
                }

                // 触发事件以通知框架
                el.dispatchEvent(new Event('input', { bubbles: true }));
                el.dispatchEvent(new Event('change', { bubbles: true }));
                
                // 视觉反馈（可选：背景微闪一下表示已恢复）
                const originalBg = el.style.backgroundColor;
                el.style.transition = 'background-color 0.5s';
                el.style.backgroundColor = 'rgba(0, 255, 0, 0.1)';
                setTimeout(() => {
                    el.style.backgroundColor = originalBg;
                }, 1000);
            }
        });
    }
    // ============
    // 8. 启动引导 (Bootstrap)
    // ============

    (async function main() {
        try {
            // 1. 等待配置加载
            await initConfiguration();
            
            // 2. 配置加载完后，再注册菜单 (这样菜单里的 getConfig 才能读到正确的值)
            registerMenus();
            
            // 3. 应用屏蔽规则
            applySavedBlockingRules();

            // 4. unlock mode 下，智能拦截 Ctrl+滚轮
            const handleWheelZoom = (e) => {
                // 核心优化：
                // 只有当 e.ctrlKey 为真（按下了Ctrl） 且 脚本判定已进入解锁模式（isUnlockMode为true，即按下了指定的 ControlLeft/Right）时才拦截
                // 如果你按的是另一侧的 Ctrl，isUnlockMode 会是 false，代码将在此处 return，从而保留原生缩放功能
                if (!e.ctrlKey || !isUnlockMode) return;

                const hotkey = getConfig('unlockHotkey') || '';
                // 双重校验：确保当前配置的解锁键确实是 Control 系列 (防止配置为 Alt 时误拦截 Ctrl 滚轮)
                const isCtrlConfigured = hotkey.includes('Control') || hotkey.toLowerCase() === 'ctrl';

                if (isCtrlConfigured) {
                    // 阻止原生缩放
                    e.preventDefault();
                    e.stopPropagation();
                    
                    // 手动执行垂直滚动
                    window.scrollBy({
                        top: e.deltaY,
                        behavior: 'auto'
                    });
                }
            };
            // 必须设置 passive: false 才能阻止默认行为，capture: true 保证最先捕获
            window.addEventListener('wheel', handleWheelZoom, { passive: false, capture: true });

            // 5. 统一注册所有事件监听器 (防止配置没读完就触发划词)
        document.addEventListener('mouseup', handleSelectionMouseUp, false);
        document.addEventListener('mouseup', handleInputPasteMouseUp, true); // capture 阶段
        document.addEventListener('mousedown', handleGlobalMouseDown, false);
        document.addEventListener('contextmenu', handleContextMenu, true);
        window.addEventListener('scroll', handleResizeOrScroll, { passive: true });
        window.addEventListener('resize', handleResizeOrScroll, { passive: true });
        document.addEventListener('keydown', handleKeydownHideUI, true);
        // 6.拖拽预览事件监听
            // 仅在主窗口生效，防止预览弹窗内部递归触发
            if (window.name !== PREVIEW_WIN_NAME) {
                document.addEventListener('dragstart', handleLinkDragStart, false);
                document.addEventListener('dragend', handleLinkDragEnd, false); 
            }
        // 7.启动码字防丢监听
            document.addEventListener('input', handleInputSave, true);
            document.addEventListener('submit', handleFormSubmit, true); // 监听表单提交
            
            // 延迟一点时间恢复数据，确保页面框架（如Vue/React）已挂载 DOM
            if (document.readyState === 'complete') {
                setTimeout(restoreInputData, 500);
            } else {
                window.addEventListener('load', () => setTimeout(restoreInputData, 500));
            }
        
        // 8.检查是否有来自网盘链接的密码交接
            // 放在 main 函数的 try-catch 块内部靠后的位置，或者 restoreInputData 附近
            const checkPanHandover = async () => {
                if (!getConfig('enablePaste')) return;
                
                const handover = await safeGetValue('pan_paste_handover', null);
                if (handover && handover.code) {
                    // 检查时间戳（15秒内有效，防止旧数据干扰）
                    if (Date.now() - handover.timestamp < 15000) {
                        // 简单的URL匹配：如果当前URL包含了提取时的URL关键部分
                        // 由于跳转等原因，只比对 host 或部分 path
                        // 这里做宽松匹配：如果当前页面的URL包含 handover.url 的 host 部分
                        try {
                            const currentUrl = window.location.href;
                            const targetUrlObj = new URL(handover.url); // 如果 handover.url 不规范可能会报错，try-catch捕获
                            
                            if (currentUrl.includes(targetUrlObj.host)) {
                                sessionPanCode = handover.code;
                                // 销毁存储中的密码，保证一次性使用且不污染剪贴板
                                safeSetValue('pan_paste_handover', null);
                                // 显示提示
                                showToast(`${t('btn_paste') || 'Paste'} Code: ${sessionPanCode}`);
                            }
                        } catch(e) {}
                    }
                }
            };
            // 页面加载完成后稍微延迟执行检查
            setTimeout(checkPanHandover, 300);

            // 注意：原本你的代码里事件监听是散落在各处的。
            // 为了安全起见，你可以把原本的 document.addEventListener('mouseup', ...) 
            // 包裹在一个 function startEventListeners() {} 中，然后在这里调用它。
            
        } catch (e) {
            //console.error('Smart Copy 启动失败:', e);
        }
    })();
})();