qr-auto-decoder.user.js

// ==UserScript==
// @name         二维码自动解析
// @description  鼠标悬停时自动在本地解析二维码
// @namespace    http://tampermonkey.net/
// @require      https://cdn.jsdelivr.net/npm/jsqr@1.4.0/dist/jsQR.min.js
// @require      https://unpkg.com/@zxing/library@latest/umd/index.min.js
// @match        *://*/*
// @match        file:///*
// @grant        GM_setClipboard
// @grant        GM_openInTab
// @grant        GM_addStyle
// @grant        GM_xmlhttpRequest
// @connect      cdnimg.hxcy.top
// @connect      pic.hxcy.top
// @connect      image.acg.lol
// @connect      zxing.org
// @connect      api.2dcode.biz
// @connect      *
// @run-at       document-start
// @version      3.4.4
// @author       Gemini
// @license      GPLv3
// @icon      data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGAAAABgCAYAAADimHc4AAAABmJLR0QA/wD/AP+gvaeTAAABZElEQVR4nO3cQUrEMBiAURXv5QFceVJXHsCT6VYGpA5J+6X2vbVI4OPvZNJpHx4AAICredz6g5e3j68jFvKbz/fXzTX+dLb1Pu21EP5GgJgAMQFiAsQEiAkQex79B/fue28dvW9fbb0mICZATIDY8GfAra1r5Og1eLZ6vSYgJkBMgJgAMQFiAsQEiE3/HrDaPn9LvV4TEBMgJkBs+DOg/h3OvVZbrwmICRATICZATICYADEBYrufg4zecx3dt89+vmD22ZEJiAkQEyAmQEyAmAAxAWLDe9p6nz/b6Ho9J3wyAsQEiG3eEx69Rq92jV+NCYgJEBMgdvr3BdXPeI0yATEBYgLELveuiL3PrpwFncz0J2Rmq3dhezMBscu/K6JmAmICxASILb8Lmm21syUTEFt+As72q4p7mYDY5d8VUTMBMQFiAsSWvye85ehnwNwP+GcEiAkQEyAmQEyAmAAAAAAAcJBvjUVu7tMNP9IAAAAASUVORK5CYII=
// ==/UserScript==

(function() {
    'use strict';

    // === 配置 ===
    const AUTO_PENDING_RETRY_MS = 100;
    const AUTO_RESCAN_DISTANCE_PX = 120;
    const AUTO_IMAGE_MIN_EDGE_PX = 48;
    const AUTO_IMAGE_MAX_RATIO = (4 / 3) + 0.03;
    const AUTO_CONTENT_SCORE_MIN = 2;
    const AUTO_CONTENT_SCORE_HIGH = 5;
    const AUTO_QUICK_MAX_SIZE = 720;
    const AUTO_DETAIL_MAX_SIZE = 1152;
    const AUTO_LOCAL_QUICK_SIZE_PX = 320;
    const AUTO_LOCAL_DETAIL_SIZE_PX = 520;
    const AUTO_CORS_MAX_SOURCE_DIMENSION = 6000;
    const AUTO_CANVAS_MAX_SIZE = 2000;
    const CANVAS_SQUARE_TOLERANCE = 2;
    const CROP_TARGET_SIZE = 500; // 框选解析的最大尺寸 (超过此尺寸才缩小)
    const INPUT_SUPPRESSION_TIMEOUT_MS = 1500;
    // 与现有右键+左键次数一致：请求越深入，结果等级越高。
    const SCAN_PRIORITY = Object.freeze({
        AUTO: 0,
        FORCE_LOCAL: 10,
        REMOTE: 20,
        CROP_SCALED: 30,
        CROP_ORIGINAL: 40
    });

    // === ZXing 初始化 ===
    let zxingReaderStrict = null; // 仅用于悬停 (只识二维码)
    let zxingReaderAll = null;    // 用于强制解析 (识别所有)

    function getZXingReader(isForce) {
        if (!window.ZXing) return null;

        if (isForce) {
            // --- 模式 B: 强制解析 (全格式) ---
            if (!zxingReaderAll) {
                const hints = new Map();
                // 不设置 POSSIBLE_FORMATS 默认识别所有格式 (EAN, Code128, QR等)
                hints.set(ZXing.DecodeHintType.TRY_HARDER, true);
                zxingReaderAll = new ZXing.BrowserMultiFormatReader(hints);
            }
            return zxingReaderAll;
        } else {
            // --- 模式 A: 悬停自动解析 (仅二维码) ---
            if (!zxingReaderStrict) {
                const hints = new Map();
                // 显式限制只识别 QR Code 和 Data Matrix
                const formats = [ZXing.BarcodeFormat.QR_CODE, ZXing.BarcodeFormat.DATA_MATRIX];
                hints.set(ZXing.DecodeHintType.POSSIBLE_FORMATS, formats);
                // 悬停时也可以开启深度扫描 或者为了性能设为 false (这里建议开启以保证识别率)
                hints.set(ZXing.DecodeHintType.TRY_HARDER, true);
                zxingReaderStrict = new ZXing.BrowserMultiFormatReader(hints);
            }
            return zxingReaderStrict;
        }
    }

    // === 全局变量 ===
    let autoHoverState = null;
    let autoScanSequence = 0;
    let tooltip = null;
    let currentTarget = null;
    let displayedResultState = null;
    let tooltipRenderRevision = 0;

    // 坐标相关
    let lastMouseScreenX = 0;
    let lastMouseScreenY = 0;
    let lastMouseClientX = 0;
    let lastMouseClientY = 0;
    let topWinOffset = null;

    // 组合键状态控制
    let isRightClickHolding = false;
    let leftClickCount = 0;
    let interactionTarget = null;
    let pendingContextMenuSuppression = null;
    let pendingClickSuppression = null;
    let longPressTimer = null;

    // 框选相关
    let isCropping = false;
    let isNoScaleCrop = false;
    let cropOverlay = null;
    let cropBox = null;
    let cropStart = { x: 0, y: 0 };
    let cropTarget = null;
    let cropDragCleanup = null;

    // 会话缓存
    const qrCache = new Map();
    const canvasCache = new WeakMap();
    const autoAttemptCache = new Map();

    function getImageSource(img) {
        if (!img || img.tagName !== 'IMG') return '';
        return img.currentSrc || img.src || '';
    }

    function normalizePriority(priority) {
        return Number.isFinite(priority) ? priority : SCAN_PRIORITY.AUTO;
    }

    function getResultIdentity(text) {
        const value = String(text ?? '');
        return isUrl(value) ? value.trim() : value;
    }

    function getCachedEntry(type, cacheKey, targetEl) {
        if (type === 'IMG' && cacheKey) return qrCache.get(cacheKey);
        if (type === 'CANVAS' && targetEl) return canvasCache.get(targetEl);
        return null;
    }

    function setCachedEntry(type, cacheKey, targetEl, entry) {
        if (type === 'IMG' && cacheKey) qrCache.set(cacheKey, entry);
        else if (type === 'CANVAS' && targetEl) canvasCache.set(targetEl, entry);
    }

    function commitCacheEntry(type, cacheKey, targetEl, candidate) {
        const existing = getCachedEntry(type, cacheKey, targetEl);

        if (existing && existing.status === 'success') {
            if (!candidate || candidate.status !== 'success') return existing;

            const existingPriority = normalizePriority(existing.priority);
            const candidatePriority = normalizePriority(candidate.priority);

            if (getResultIdentity(candidate.text) === getResultIdentity(existing.text)) {
                if (candidatePriority > existingPriority) {
                    const upgraded = { ...existing, priority: candidatePriority };
                    setCachedEntry(type, cacheKey, targetEl, upgraded);
                    return upgraded;
                }
                return existing;
            }

            if (candidatePriority <= existingPriority) return existing;
        }

        const committed = candidate && candidate.status === 'success'
            ? { ...candidate, priority: normalizePriority(candidate.priority) }
            : candidate;
        setCachedEntry(type, cacheKey, targetEl, committed);
        return committed;
    }

    function clamp(value, min, max) {
        return Math.min(Math.max(value, min), max);
    }

    function getRepeatedImageCount(source) {
        if (!source) return 0;

        let count = 0;
        for (const image of document.images) {
            if (getImageSource(image) === source && ++count >= 3) return count;
        }
        return count;
    }

    function hasFixedOrStickyAncestor(element) {
        let node = element;
        let depth = 0;

        while (node && node !== document.documentElement && depth < 8) {
            const position = getComputedStyle(node).position;
            if (position === 'fixed' || position === 'sticky') return true;
            node = node.parentElement;
            depth++;
        }
        return false;
    }

    function evaluateAutoImageCandidate(img) {
        if (!img.complete || !img.naturalWidth || !img.naturalHeight) {
            return { eligible: false, reason: 'not_loaded' };
        }

        const rect = img.getBoundingClientRect();
        const style = getComputedStyle(img);
        const visibleWidth = Math.min(rect.right, window.innerWidth) - Math.max(rect.left, 0);
        const visibleHeight = Math.min(rect.bottom, window.innerHeight) - Math.max(rect.top, 0);

        if (style.display === 'none' || style.visibility !== 'visible' || Number(style.opacity) <= 0.01 ||
            rect.width < AUTO_IMAGE_MIN_EDGE_PX || rect.height < AUTO_IMAGE_MIN_EDGE_PX ||
            visibleWidth <= 0 || visibleHeight <= 0) {
            return { eligible: false, reason: 'not_visible' };
        }

        const ratio = Math.max(rect.width, rect.height) / Math.min(rect.width, rect.height);
        if (ratio > AUTO_IMAGE_MAX_RATIO) {
            return { eligible: false, reason: 'invalid_ratio' };
        }

        const minEdge = Math.min(rect.width, rect.height);
        const area = rect.width * rect.height;
        const source = getImageSource(img);
        if (!source) return { eligible: false, reason: 'missing_source' };
        const sourceName = source.startsWith('data:') ? '' : source.split(/[?#]/)[0].slice(-160);
        const descriptor = `${img.id || ''} ${img.className || ''} ${img.alt || ''} ${img.title || ''} ${sourceName}`;
        let score = minEdge >= 64 ? 2 : -1;

        if (area >= 20000) score++;
        if (area >= 90000) score++;
        if (img.closest('main, article, figure, [role="main"]')) score += 3;
        if (/(?:qr(?:code)?|二维码|收款码|付款码|weixin|wechat|alipay|payment|scan[-_ ]?code)/i.test(descriptor)) score += 3;

        if (img.closest('nav, header, footer, [role="navigation"], [role="menu"], [role="menubar"], [role="toolbar"], button, [role="button"]')) {
            score -= 5;
        }
        if (img.closest('aside, [role="complementary"]')) score -= 2;
        if (hasFixedOrStickyAncestor(img)) score -= 3;
        if (/(?:^|[\s_./-])(?:logo|icon|avatar|badge|emoji|sprite|favicon|toolbar|menu)(?:$|[\s_.-])/i.test(descriptor)) {
            score -= 5;
        }
        if (getRepeatedImageCount(source) >= 3) score -= 3;

        return {
            eligible: score >= AUTO_CONTENT_SCORE_MIN,
            highConfidence: score >= AUTO_CONTENT_SCORE_HIGH,
            score,
            rect,
            ratio,
            source,
            reason: score >= AUTO_CONTENT_SCORE_MIN ? 'accepted' : 'low_content_score'
        };
    }

    function getObjectPositionTokens(value) {
        const parts = String(value || '50% 50%').trim().split(/\s+/);
        if (parts.length === 1) {
            return /^(top|bottom)$/i.test(parts[0]) ? ['50%', parts[0]] : [parts[0], '50%'];
        }

        if (parts.length === 2 && /^(top|bottom)$/i.test(parts[0]) && /^(left|right|center)$/i.test(parts[1])) {
            return [parts[1], parts[0]];
        }
        return parts.length === 2 ? parts : ['50%', '50%'];
    }

    function resolveObjectPosition(token, freeSpace, axis) {
        const value = String(token || '50%').toLowerCase();
        if (value === 'center') return freeSpace * 0.5;
        if (value === (axis === 'x' ? 'left' : 'top')) return 0;
        if (value === (axis === 'x' ? 'right' : 'bottom')) return freeSpace;
        if (value.endsWith('%')) return freeSpace * (parseFloat(value) || 0) / 100;

        const pixels = parseFloat(value);
        return Number.isFinite(pixels) ? pixels : freeSpace * 0.5;
    }

    function getDisplayedImageMapping(img) {
        const naturalWidth = img.naturalWidth;
        const naturalHeight = img.naturalHeight;
        if (!naturalWidth || !naturalHeight) return null;

        const rect = img.getBoundingClientRect();
        const style = getComputedStyle(img);
        const number = value => parseFloat(value) || 0;
        const insetLeft = number(style.borderLeftWidth) + number(style.paddingLeft);
        const insetRight = number(style.borderRightWidth) + number(style.paddingRight);
        const insetTop = number(style.borderTopWidth) + number(style.paddingTop);
        const insetBottom = number(style.borderBottomWidth) + number(style.paddingBottom);
        const contentWidth = rect.width - insetLeft - insetRight;
        const contentHeight = rect.height - insetTop - insetBottom;
        if (contentWidth <= 0 || contentHeight <= 0) return null;

        const contentLeft = rect.left + insetLeft;
        const contentTop = rect.top + insetTop;
        const objectFit = style.objectFit || 'fill';
        let scaleX = contentWidth / naturalWidth;
        let scaleY = contentHeight / naturalHeight;

        if (objectFit !== 'fill') {
            const containScale = Math.min(scaleX, scaleY);
            let uniformScale;
            if (objectFit === 'cover') uniformScale = Math.max(scaleX, scaleY);
            else if (objectFit === 'none') uniformScale = 1;
            else if (objectFit === 'scale-down') uniformScale = Math.min(1, containScale);
            else uniformScale = containScale;
            scaleX = uniformScale;
            scaleY = uniformScale;
        }

        const objectWidth = naturalWidth * scaleX;
        const objectHeight = naturalHeight * scaleY;
        const [positionX, positionY] = getObjectPositionTokens(style.objectPosition);
        const objectLeft = contentLeft + resolveObjectPosition(positionX, contentWidth - objectWidth, 'x');
        const objectTop = contentTop + resolveObjectPosition(positionY, contentHeight - objectHeight, 'y');
        const visibleLeft = Math.max(contentLeft, objectLeft);
        const visibleTop = Math.max(contentTop, objectTop);
        const visibleRight = Math.min(contentLeft + contentWidth, objectLeft + objectWidth);
        const visibleBottom = Math.min(contentTop + contentHeight, objectTop + objectHeight);
        if (visibleRight <= visibleLeft || visibleBottom <= visibleTop) return null;

        const sourceX = clamp((visibleLeft - objectLeft) / scaleX, 0, naturalWidth);
        const sourceY = clamp((visibleTop - objectTop) / scaleY, 0, naturalHeight);
        const sourceRight = clamp((visibleRight - objectLeft) / scaleX, 0, naturalWidth);
        const sourceBottom = clamp((visibleBottom - objectTop) / scaleY, 0, naturalHeight);

        return {
            naturalWidth,
            naturalHeight,
            objectFit,
            objectPosition: style.objectPosition || '50% 50%',
            scaleX,
            scaleY,
            objectLeft,
            objectTop,
            visibleDisplayRect: {
                left: visibleLeft,
                top: visibleTop,
                right: visibleRight,
                bottom: visibleBottom,
                width: visibleRight - visibleLeft,
                height: visibleBottom - visibleTop
            },
            visibleSourceRect: {
                x: sourceX,
                y: sourceY,
                width: sourceRight - sourceX,
                height: sourceBottom - sourceY
            }
        };
    }

    function mapPointerToSource(mapping, pointer) {
        const visible = mapping.visibleDisplayRect;
        const clientX = clamp(pointer.clientX, visible.left, visible.right);
        const clientY = clamp(pointer.clientY, visible.top, visible.bottom);
        return {
            x: clamp((clientX - mapping.objectLeft) / mapping.scaleX, 0, mapping.naturalWidth),
            y: clamp((clientY - mapping.objectTop) / mapping.scaleY, 0, mapping.naturalHeight)
        };
    }

    function getCenteredSourceRect(mapping, pointer, displaySize) {
        const bounds = mapping.visibleSourceRect;
        const center = mapPointerToSource(mapping, pointer);
        const width = Math.min(bounds.width, displaySize / mapping.scaleX);
        const height = Math.min(bounds.height, displaySize / mapping.scaleY);
        const maxX = bounds.x + bounds.width - width;
        const maxY = bounds.y + bounds.height - height;

        return {
            x: clamp(center.x - width / 2, bounds.x, maxX),
            y: clamp(center.y - height / 2, bounds.y, maxY),
            width,
            height
        };
    }

    function buildAutoAttemptKey(img, mapping, pointer) {
        const source = getImageSource(img);
        const visible = mapping.visibleSourceRect;
        const sourcePoint = mapPointerToSource(mapping, pointer);
        const relativeX = (sourcePoint.x - visible.x) / Math.max(1, visible.width);
        const relativeY = (sourcePoint.y - visible.y) / Math.max(1, visible.height);
        const round = value => Math.round(value / 4) * 4;

        return [
            'auto-v3',
            source,
            `${mapping.naturalWidth}x${mapping.naturalHeight}`,
            `${round(mapping.visibleDisplayRect.width)}x${round(mapping.visibleDisplayRect.height)}`,
            `${round(visible.x)},${round(visible.y)},${round(visible.width)},${round(visible.height)}`,
            `${mapping.objectFit}:${mapping.objectPosition}`,
            `${Math.round(relativeX * 12)},${Math.round(relativeY * 12)}`
        ].join('|');
    }

    const isTop = window.self === window.top;

    // === 样式注入 ===
    GM_addStyle(`
        #qr-custom-tooltip {
            position: fixed;
            z-index: 2147483647;
            background: rgba(0, 0, 0, 0.9);
            color: #fff;
            padding: 8px 12px;
            font-size: 12px;
            max-width: 320px;
            word-break: break-all;
            pointer-events: none;
            display: none;
            border: 1px solid #555;
            border-radius: 0px !important;
            box-shadow: none !important;
            line-height: 1.5;
            text-align: left;
        }
        .qr-detected-style {
            cursor: pointer !important;
            outline: none !important;
        }
        /* 框选遮罩 */
        #qr-crop-overlay {
            position: fixed;
            top: 0; left: 0; width: 100vw; height: 100vh;
            background: rgba(0, 0, 0, 0.3);
            z-index: 2147483646;
            cursor: crosshair;
            display: none;
        }
        #qr-crop-box {
            position: absolute;
            border: 2px solid #4CAF50;
            background: rgba(76, 175, 80, 0.2);
            pointer-events: none;
            display: none;
        }
    `);

    // ==========================================
    //      通信模块 (跨域支持)
    // ==========================================

    function sendToTop(type, payload = {}) {
        if (isTop) {
            handleMessage({ data: { type, payload } });
        } else {
            window.top.postMessage({ type: 'QR_SCRIPT_MSG', action: type, payload }, '*');
        }
    }

    if (isTop) {
        window.addEventListener('message', (event) => {
            if (event.data && event.data.type === 'QR_SCRIPT_MSG') {
                handleMessage({ data: { type: event.data.action, payload: event.data.payload } });
            }
        });
    }

    function handleMessage(e) {
        const { type, payload } = e.data;
        switch (type) {
            case 'SHOW_TOOLTIP':
                renderTooltip(
                    payload.text,
                    payload.coords,
                    payload.isLink,
                    payload.method,
                    payload.kind,
                    payload.priority
                );
                break;
            case 'HIDE_TOOLTIP':
                hideTooltipDOM();
                break;
            case 'SHOW_FEEDBACK':
                showFeedbackDOM();
                break;
        }
    }

    // ==========================================
    //      UI 渲染模块 (仅顶层窗口)
    // ==========================================

    function getTooltip() {
        if (!tooltip) {
            tooltip = document.getElementById('qr-custom-tooltip');
            if (!tooltip) {
                tooltip = document.createElement('div');
                tooltip.id = 'qr-custom-tooltip';
                document.body.appendChild(tooltip);
            }
        }
        return tooltip;
    }

    function shouldRenderTooltip(text, kind, priority) {
        if (!displayedResultState) return true;
        if (kind !== 'result') return false;

        const displayedIdentity = displayedResultState.identity ?? getResultIdentity(displayedResultState.text);
        if (getResultIdentity(text) === displayedIdentity) {
            displayedResultState.priority = Math.max(displayedResultState.priority, priority);
            return false;
        }

        return priority > displayedResultState.priority;
    }

    function renderTooltip(text, coords, isLink, method, kind, priority) {
        const resolvedKind = kind || (text.startsWith('⌛') ? 'status' : text.startsWith('❌') ? 'error' : 'result');
        const resolvedPriority = normalizePriority(priority);
        if (!shouldRenderTooltip(text, resolvedKind, resolvedPriority)) return;

        const tip = getTooltip();
        const contentColor = isLink ? '#4dabf7' : '#ffffff';
        const actionColor = '#4CAF50';
        const bracketColor = '#F6B64E';
        const parenColor = '#B28BF7';

        const isLoading = text.startsWith('⌛');
        const isError = text.startsWith('❌');

        // --- 修改开始：标题构建逻辑 ---
        let titleHtml = '';

        // 检查是否以 "远程解析" 开头
        if (method && method.startsWith('远程解析')) {
            // 提取括号内的源 (如果有)
            let source = "";
            const match = method.match(/\((.+?)\)/);
            if (match) source = match[1];

            titleHtml = `<div style="margin-bottom:4px;">
                <span style="color:${bracketColor}; font-weight:bold;">[远程解析]</span>
                ${source ? `<span style="color:${parenColor}; font-weight:bold;"> (${escapeHtml(source)})</span>` : ''}
            </div>`;
        } else {
            // 本地解析
            titleHtml = `<div style="margin-bottom:4px;">
                <span style="color:${bracketColor}; font-weight:bold;">[本地解析]</span>
                <span style="color:${parenColor}; font-weight:bold;"> (${escapeHtml(method || '未知')})</span>
            </div>`;
        }

        let htmlContent = '';
        if (isLoading) {
            htmlContent = `<div style="color:#FFD700; font-weight:bold;">${escapeHtml(text)}</div>`;
        } else if (isError) {
            htmlContent = `<div style="color:#FF5252; font-weight:bold;">${escapeHtml(text)}</div>`;
        } else {
            htmlContent = `
                ${titleHtml}
                <div style="color:${contentColor}; margin-bottom:6px;">${escapeHtml(text)}</div>
                <div style="color:${actionColor}; font-weight:bold; border-top:1px solid #444; padding-top:4px;">
                    ${isLink ? '🔗 点击打开 | 📋 按住复制' : '📋 点击复制文本'}
                </div>
            `;
        }

        tip.innerHTML = htmlContent;
        tip.style.display = 'block';
        tooltipRenderRevision++;
        displayedResultState = resolvedKind === 'result'
            ? { text, identity: getResultIdentity(text), priority: resolvedPriority }
            : null;

        // --- 坐标计算 ---
        let offsetY, offsetX;
        if (topWinOffset) {
            offsetX = topWinOffset.x;
            offsetY = topWinOffset.y;
        } else {
            const winScreenX = window.screenX !== undefined ? window.screenX : window.screenLeft;
            const winScreenY = window.screenY !== undefined ? window.screenY : window.screenTop;
            offsetX = winScreenX + (window.outerWidth - window.innerWidth);
            offsetY = winScreenY + (window.outerHeight - window.innerHeight);
        }

        let left = coords.absLeft - offsetX;
        let top = coords.absBottom - offsetY + 10;

        const tipRect = tip.getBoundingClientRect();
        const winHeight = window.innerHeight;
        const winWidth = window.innerWidth;

        if (top + tipRect.height > winHeight) {
            top = (coords.absTop - offsetY) - tipRect.height - 10;
        }
        if (left + tipRect.width > winWidth) left = winWidth - tipRect.width - 10;
        if (left < 0) left = 10;

        tip.style.top = top + 'px';
        tip.style.left = left + 'px';
    }

    function hideTooltipDOM() {
        if (tooltip) tooltip.style.display = 'none';
        displayedResultState = null;
        tooltipRenderRevision++;
    }

    function showFeedbackDOM() {
        const tip = getTooltip();
        if (tip.style.display === 'none') return;
        const originalHTML = tip.innerHTML;
        const revision = ++tooltipRenderRevision;
        tip.innerHTML = `<div style="font-size:14px; text-align:center; color:#4dabf7; font-weight:bold;">✅ 已复制到剪贴板</div>`;
        setTimeout(() => {
            if (tip.style.display !== 'none' && tooltipRenderRevision === revision) {
                tip.innerHTML = originalHTML;
            }
        }, 1000);
    }

    // ==========================================
    //      逻辑处理模块 (所有 Frame)
    // ==========================================

    function requestShowTooltip(text, element, method = "JSQR", options = {}) {
        if (currentTarget !== element) currentTarget = element;

        const isLink = isUrl(text);
        const kind = options.kind || (text.startsWith('⌛') ? 'status' : text.startsWith('❌') ? 'error' : 'result');
        const priority = normalizePriority(options.priority);
        const rect = element.getBoundingClientRect();

        const frameOffsetX = (lastMouseScreenX && lastMouseClientX) ? (lastMouseScreenX - lastMouseClientX) : 0;
        const frameOffsetY = (lastMouseScreenY && lastMouseClientY) ? (lastMouseScreenY - lastMouseClientY) : 0;

        const coords = {
            absLeft: rect.left + frameOffsetX,
            absTop: rect.top + frameOffsetY,
            absBottom: rect.bottom + frameOffsetY
        };

        sendToTop('SHOW_TOOLTIP', { text, coords, isLink, method, kind, priority });
    }

    function requestHideTooltip() {
        currentTarget = null;
        sendToTop('HIDE_TOOLTIP');
    }

    function requestFeedback() {
        sendToTop('SHOW_FEEDBACK');
    }

    // ==========================================
    //      框选逻辑
    // ==========================================

    function startCropMode(target, noScale = false) {
        if (isCropping) return;
        stopAutoHover(true);
        isCropping = true;
        isNoScaleCrop = noScale;
        cropTarget = target;

        if (!cropOverlay) {
            cropOverlay = document.createElement('div');
            cropOverlay.id = 'qr-crop-overlay';
            cropBox = document.createElement('div');
            cropBox.id = 'qr-crop-box';
            cropOverlay.appendChild(cropBox);
            document.body.appendChild(cropOverlay);

            // 辅助函数
            const clamp = (val, min, max) => Math.min(Math.max(val, min), max);

            // 右键取消
            cropOverlay.addEventListener('contextmenu', (e) => {
                e.preventDefault();
                e.stopPropagation();
                const target = cropTarget;
                const priority = isNoScaleCrop ? SCAN_PRIORITY.CROP_ORIGINAL : SCAN_PRIORITY.CROP_SCALED;
                endCropMode();
                if (target) requestShowTooltip("❌ 已取消框选", target, "JSQR", { priority });
                return false;
            });

            // 鼠标按下开始框选
            cropOverlay.addEventListener('mousedown', (e) => {
                if (e.button !== 0 || !cropTarget) return;
                e.preventDefault();

                // 关键修复 2: 在点击瞬间动态获取当前目标的 Rect
                // 确保获取的是当前 cropTarget 的位置 而不是第一次初始化时的位置
                const target = cropTarget;
                const imgRect = target.getBoundingClientRect();

                // 限制起点坐标
                const startX = clamp(e.clientX, imgRect.left, imgRect.right);
                const startY = clamp(e.clientY, imgRect.top, imgRect.bottom);

                cropStart = { x: startX, y: startY };

                cropBox.style.left = startX + 'px';
                cropBox.style.top = startY + 'px';
                cropBox.style.width = '0px';
                cropBox.style.height = '0px';
                cropBox.style.display = 'block';

                const onMove = (ev) => {
                    // 鼠标在窗口外释放时可能收不到 mouseup；重新进入后立即取消框选。
                    if ((ev.buttons & 1) === 0) {
                        endCropMode();
                        return;
                    }

                    // 限制终点坐标
                    const curX = clamp(ev.clientX, imgRect.left, imgRect.right);
                    const curY = clamp(ev.clientY, imgRect.top, imgRect.bottom);

                    const width = Math.abs(curX - cropStart.x);
                    const height = Math.abs(curY - cropStart.y);
                    const left = Math.min(curX, cropStart.x);
                    const top = Math.min(curY, cropStart.y);

                    cropBox.style.width = width + 'px';
                    cropBox.style.height = height + 'px';
                    cropBox.style.left = left + 'px';
                    cropBox.style.top = top + 'px';
                };

                const onUp = (ev) => {
                    if (ev.button !== 0) return;
                    if (!isCropping) {
                        if (cropDragCleanup) cropDragCleanup();
                        return;
                    }

                    const rect = cropBox.getBoundingClientRect();
                    endCropMode();

                    if (rect.width < 5 || rect.height < 5) return;

                    // 关键修复 3: 将当前的 cropTarget 传递给处理函数
                    processCropScan(target, rect);
                };

                window.addEventListener('mousemove', onMove);
                window.addEventListener('mouseup', onUp);
                cropDragCleanup = () => {
                    window.removeEventListener('mousemove', onMove);
                    window.removeEventListener('mouseup', onUp);
                    cropDragCleanup = null;
                };
            });
        }

        cropOverlay.style.display = 'block';
        const tipText = noScale ? "⌛ 原图框选" : "⌛ 缩放框选";
        const priority = noScale ? SCAN_PRIORITY.CROP_ORIGINAL : SCAN_PRIORITY.CROP_SCALED;
        requestShowTooltip(tipText, target, "JSQR", { priority });
    }

    function endCropMode() {
        isCropping = false;
        if (cropDragCleanup) cropDragCleanup();
        if (cropOverlay) cropOverlay.style.display = 'none';
        if (cropBox) cropBox.style.display = 'none';
        cropTarget = null;
    }

    function processCropScan(target, selectionRect) {
        const targetRect = target.getBoundingClientRect();
        const selX = selectionRect.left;
        const selY = selectionRect.top;
        const selW = selectionRect.width;
        const selH = selectionRect.height;
        const imgX = targetRect.left;
        const imgY = targetRect.top;
        const relX = selX - imgX;
        const relY = selY - imgY;

        const cropRect = {
            x: relX,
            y: relY,
            w: selW,
            h: selH,
            noScale: isNoScaleCrop
        };

        scanElement(target, true, cropRect);
    }

    // === 统一入口 ===
    function scanElement(target, force = false, cropRect = null) {
        const priority = cropRect
            ? (cropRect.noScale ? SCAN_PRIORITY.CROP_ORIGINAL : SCAN_PRIORITY.CROP_SCALED)
            : (force ? SCAN_PRIORITY.FORCE_LOCAL : SCAN_PRIORITY.AUTO);

        // 获取当前缓存状态 (用于强制解析时的判断)
        let prevCache = null;
        if (target.tagName === 'IMG' && getImageSource(target)) prevCache = getCachedEntry('IMG', getImageSource(target), target);
        else if (target.tagName === 'CANVAS') prevCache = getCachedEntry('CANVAS', target, target);

        if (target.tagName === 'IMG') {
            scanImage(target, force, cropRect, prevCache, priority);
        } else if (target.tagName === 'CANVAS') {
            scanCanvas(target, force, cropRect, prevCache, priority);
        }
    }

    // === 远程解析 ===

    // === 远程解析辅助函数 ===
    // 1. 请求 zxing.org
    function fetchZxing(src) {
        return new Promise((resolve, reject) => {
            GM_xmlhttpRequest({
                method: "GET",
                url: "https://zxing.org/w/decode?u=" + encodeURIComponent(src),
                timeout: 10000, // 10秒超时
                onload: function(response) {
                    if (response.status === 200) {
                        const parser = new DOMParser();
                        const doc = parser.parseFromString(response.responseText, "text/html");
                        const tds = doc.querySelectorAll('td');
                        let resultText = null;
                        for (let i = 0; i < tds.length; i++) {
                            if (tds[i].textContent.trim() === "Parsed Result") {
                                const nextTd = tds[i].nextElementSibling;
                                if (nextTd) {
                                    const pre = nextTd.querySelector('pre');
                                    if (pre) { resultText = pre.textContent; break; }
                                }
                            }
                        }
                        if (resultText) resolve({ text: resultText, source: "zxing.org" });
                        else reject("zxing parse error");
                    } else {
                        reject("zxing status " + response.status);
                    }
                },
                onerror: (e) => reject("zxing network error"),
                ontimeout: () => reject("zxing timeout")
            });
        });
    }

    // 2. 请求 api.2dcode.biz
    function fetch2dCode(src) {
        return new Promise((resolve, reject) => {
            GM_xmlhttpRequest({
                method: "GET",
                url: "https://api.2dcode.biz/v1/read-qr-code?file_url=" + encodeURIComponent(src),
                timeout: 10000,
                onload: function(response) {
                    if (response.status === 200) {
                        try {
                            const json = JSON.parse(response.responseText);
                            // 检查 code: 0 和 data.contents 数组
                            if (json.code === 0 && json.data && json.data.contents && json.data.contents.length > 0) {
                                resolve({ text: json.data.contents[0], source: "api.2dcode.biz" });
                            } else {
                                reject("2dcode api error: " + (json.message || "no data"));
                            }
                        } catch (e) {
                            reject("2dcode json parse error");
                        }
                    } else {
                        reject("2dcode status " + response.status);
                    }
                },
                onerror: (e) => reject("2dcode network error"),
                ontimeout: () => reject("2dcode timeout")
            });
        });
    }

    // 3. Promise.any Polyfill (确保兼容性)
    // 返回最先成功的那个 如果全部失败则报错
    function promiseAny(promises) {
        if (Promise.any) return Promise.any(promises);
        return new Promise((resolve, reject) => {
            let errors = [];
            let rejectedCount = 0;
            promises.forEach((p, index) => {
                Promise.resolve(p).then(resolve).catch(error => {
                    errors[index] = error;
                    rejectedCount++;
                    if (rejectedCount === promises.length) {
                        reject(new Error("All promises rejected"));
                    }
                });
            });
        });
    }

    // === 远程解析主入口 ===
    function scanExternal(target) {
        const priority = SCAN_PRIORITY.REMOTE;
        const src = getImageSource(target);
        if (target.tagName !== 'IMG' || !src || !/^https?:/i.test(src)) {
            requestShowTooltip("❌ 远程解析仅支持 http/https 图片链接", target, "JSQR", { priority });
            return;
        }
        requestShowTooltip("⌛ 正在连接远程服务器解析...", target, "JSQR", { priority });

        // 并行发起请求
        const p1 = fetchZxing(src);
        const p2 = fetch2dCode(src);

        // 竞速：谁先成功用谁
        promiseAny([p1, p2])
            .then(result => {
                const methodStr = `远程解析 (${result.source})`;

                const committed = commitCacheEntry('IMG', src, target, {
                    status: 'success',
                    text: result.text,
                    method: methodStr,
                    priority
                });
                if (committed && committed.status === 'success') {
                    applyQrSuccess(target, committed.text, committed.method, committed.priority);
                }
            })
            .catch(err => {
                const committed = commitCacheEntry('IMG', src, target, {
                    status: 'failed',
                    reason: 'remote_all_failed'
                });
                if (committed && committed.status === 'success') {
                    applyQrSuccess(target, committed.text, committed.method, committed.priority);
                } else {
                    requestShowTooltip("❌ 远程解析失败", target, "JSQR", { priority });
                }
            });
    }

    // ==========================================
    //      图像获取与预处理
    // ==========================================

    function rememberAutoAttempt(key, entry) {
        autoAttemptCache.set(key, entry);
        if (autoAttemptCache.size > 500) {
            autoAttemptCache.delete(autoAttemptCache.keys().next().value);
        }
    }

    function forgetAutoAttempt(key, scanId) {
        const current = autoAttemptCache.get(key);
        if (current && current.scanId === scanId) autoAttemptCache.delete(key);
    }

    function loadImageWithCors(src) {
        return new Promise((resolve, reject) => {
            const image = new Image();
            image.crossOrigin = 'Anonymous';
            image.decoding = 'async';
            image.onload = () => resolve({ image, release: null });
            image.onerror = () => reject(new Error('cors_image_load_failed'));
            image.src = src;
        });
    }

    function loadImageWithRequest(src) {
        return new Promise((resolve, reject) => {
            GM_xmlhttpRequest({
                method: 'GET',
                url: src,
                responseType: 'arraybuffer',
                headers: {
                    Accept: 'image/avif,image/webp,image/apng,image/svg+xml,image/*,*/*;q=0.8'
                },
                onload: response => {
                    if (response.status < 200 || response.status >= 300 || !response.response) {
                        reject(new Error(`image_status_${response.status}`));
                        return;
                    }

                    const contentTypeMatch = String(response.responseHeaders || '')
                        .match(/^content-type:\s*([^;\r\n]+)/im);
                    const blob = new Blob([response.response], {
                        type: contentTypeMatch ? contentTypeMatch[1].trim() : 'application/octet-stream'
                    });
                    const blobUrl = URL.createObjectURL(blob);
                    const image = new Image();
                    image.decoding = 'async';
                    image.onload = () => resolve({
                        image,
                        release: () => URL.revokeObjectURL(blobUrl)
                    });
                    image.onerror = () => {
                        URL.revokeObjectURL(blobUrl);
                        reject(new Error('blob_image_load_failed'));
                    };
                    image.src = blobUrl;
                },
                onerror: () => reject(new Error('image_request_failed')),
                ontimeout: () => reject(new Error('image_request_timeout')),
                timeout: 12000
            });
        });
    }

    function canReuseLoadedImage(img, src) {
        if (!img.complete || !img.naturalWidth || !img.naturalHeight) return false;
        try {
            const url = new URL(src, document.baseURI);
            return url.protocol === 'data:' || url.protocol === 'blob:' || url.origin === window.location.origin;
        } catch (error) {
            return false;
        }
    }

    async function loadAutoImage(img, candidate) {
        const src = getImageSource(img);
        if (canReuseLoadedImage(img, src)) return { image: img, release: null };

        // A page can display a cross-origin image without CORS, but drawing that
        // image to a canvas is forbidden. Use the userscript request path first
        // so automatic scanning does not emit a browser CORS error or depend on
        // the remote server exposing Access-Control-Allow-Origin.
        let isCrossOriginHttp = false;
        try {
            const url = new URL(src, document.baseURI);
            isCrossOriginHttp = /^https?:$/i.test(url.protocol) && url.origin !== window.location.origin;
        } catch (error) {
            isCrossOriginHttp = false;
        }

        // loadAutoImage is only called after evaluateAutoImageCandidate accepted
        // the hovered element, so requiring highConfidence again incorrectly
        // excludes valid content images with a moderate score.
        const canRequest = /^https?:/i.test(src) &&
            Math.max(img.naturalWidth, img.naturalHeight) <= AUTO_CORS_MAX_SOURCE_DIMENSION;

        if (isCrossOriginHttp && canRequest) {
            try {
                return await loadImageWithRequest(src);
            } catch (requestError) {
                console.warn('[二维码自动解析 3.4.4] 油猴跨域图片读取失败，将尝试自动远程回退：', {
                    src,
                    error: requestError
                });
                throw requestError;
            }
        }

        try {
            return await loadImageWithCors(src);
        } catch (error) {
            if (!canRequest) throw error;
            return loadImageWithRequest(src);
        }
    }

    function areSourceRectsEqual(first, second) {
        return Math.abs(first.x - second.x) < 1 &&
            Math.abs(first.y - second.y) < 1 &&
            Math.abs(first.width - second.width) < 1 &&
            Math.abs(first.height - second.height) < 1;
    }

    function getAutoScanProfiles(mapping, pointer, detail) {
        const maxSize = detail ? AUTO_DETAIL_MAX_SIZE : AUTO_QUICK_MAX_SIZE;
        const localDisplaySize = detail ? AUTO_LOCAL_DETAIL_SIZE_PX : AUTO_LOCAL_QUICK_SIZE_PX;
        const localRect = getCenteredSourceRect(mapping, pointer, localDisplaySize);
        const visibleRect = mapping.visibleSourceRect;
        const profiles = [{
            sourceRect: localRect,
            maxSize,
            label: detail ? '指针附近细节' : '指针附近'
        }];

        if (!areSourceRectsEqual(localRect, visibleRect)) {
            profiles.push({
                sourceRect: { ...visibleRect },
                maxSize,
                label: detail ? '可见整图细节' : '可见整图'
            });
        }
        return profiles;
    }

    function renderAutoScanCanvas(image, profile) {
        const source = profile.sourceRect;
        const scale = Math.min(1, profile.maxSize / Math.max(source.width, source.height));
        const targetWidth = Math.max(1, Math.round(source.width * scale));
        const targetHeight = Math.max(1, Math.round(source.height * scale));
        const padding = 40;
        const canvas = document.createElement('canvas');
        canvas.width = targetWidth + padding * 2;
        canvas.height = targetHeight + padding * 2;

        const context = canvas.getContext('2d', { willReadFrequently: true });
        context.fillStyle = '#FFFFFF';
        context.fillRect(0, 0, canvas.width, canvas.height);
        context.imageSmoothingEnabled = true;
        context.imageSmoothingQuality = 'high';
        context.drawImage(
            image,
            source.x,
            source.y,
            source.width,
            source.height,
            padding,
            padding,
            targetWidth,
            targetHeight
        );
        return { canvas, context };
    }

    function getRenderedProfileKey(profile) {
        const source = profile.sourceRect;
        const scale = Math.min(1, profile.maxSize / Math.max(source.width, source.height));
        const targetWidth = Math.max(1, Math.round(source.width * scale));
        const targetHeight = Math.max(1, Math.round(source.height * scale));
        const round = value => Math.round(value * 10) / 10;
        return `${round(source.x)},${round(source.y)},${round(source.width)},${round(source.height)}:${targetWidth}x${targetHeight}`;
    }

    function renderAutoProfiles(image, profiles) {
        return profiles.map(profile => ({
            profile,
            ...renderAutoScanCanvas(image, profile)
        }));
    }

    async function decodeAutoProfilesWithJsQR(renderedProfiles) {
        if (typeof jsQR !== 'function') return null;

        for (const rendered of renderedProfiles) {
            await yieldToMain();
            const { canvas, context, profile } = rendered;
            const imageData = context.getImageData(0, 0, canvas.width, canvas.height);
            const result = jsQR(imageData.data, imageData.width, imageData.height);
            if (result) return { text: result.data, method: `JSQR ${profile.label}` };
        }
        return null;
    }

    async function decodeAutoProfilesWithZXing(renderedProfiles) {
        for (const rendered of renderedProfiles) {
            await yieldToMain();
            const result = await tryZXing(rendered.canvas, false);
            if (result) return { text: result, method: `ZXing ${rendered.profile.label}` };
        }
        return null;
    }

    function hasPointerMovedSince(state, pointer) {
        return Math.hypot(
            state.pointer.clientX - pointer.clientX,
            state.pointer.clientY - pointer.clientY
        ) >= AUTO_RESCAN_DISTANCE_PX;
    }

    function isAutoScanActive(state, source) {
        return autoHoverState === state &&
            state.target.isConnected &&
            getImageSource(state.target) === source;
    }

    function markQrSuccess(el) {
        el.dataset.hasQr = 'true';
        el.classList.add('qr-detected-style');
    }

    function commitAutoSuccess(state, source, attemptKey, decoded) {
        const committed = commitCacheEntry('IMG', source, state.target, {
            status: 'success',
            text: decoded.text,
            method: decoded.method,
            priority: SCAN_PRIORITY.AUTO
        });
        rememberAutoAttempt(attemptKey, { status: 'success' });

        if (committed && committed.status === 'success') {
            markQrSuccess(state.target);
            if (isAutoScanActive(state, source)) {
                requestShowTooltip(committed.text, state.target, committed.method, {
                    kind: 'result',
                    priority: committed.priority
                });
            }
        }
        return !!(committed && committed.status === 'success');
    }

    async function tryAutoRemoteFallback(state, candidate, attemptKey) {
        const source = candidate.source;
        if (!/^https?:/i.test(source)) return false;

        console.info('[二维码自动解析 3.4.4] 启动自动远程回退：', {
            src: source,
            score: candidate.score
        });

        try {
            const result = await promiseAny([
                fetchZxing(source),
                fetch2dCode(source)
            ]);
            if (!isAutoScanActive(state, source)) {
                forgetAutoAttempt(attemptKey, state.id);
                return false;
            }

            return commitAutoSuccess(state, source, attemptKey, {
                text: result.text,
                method: `远程解析自动回退 (${result.source})`
            });
        } catch (error) {
            console.warn('[二维码自动解析 3.4.4] 自动远程回退失败：', {
                src: source,
                error
            });
            return false;
        }
    }

    async function scanAutoImage(state, candidate, mapping, pointer, attemptKey) {
        const source = candidate.source;
        let loaded = null;

        try {
            loaded = await loadAutoImage(state.target, candidate);
            if (!isAutoScanActive(state, source)) {
                forgetAutoAttempt(attemptKey, state.id);
                return false;
            }

            const quickProfiles = getAutoScanProfiles(mapping, pointer, false);
            const quickRendered = renderAutoProfiles(loaded.image, quickProfiles);
            let decoded = await decodeAutoProfilesWithJsQR(quickRendered);
            if (decoded) return commitAutoSuccess(state, source, attemptKey, decoded);

            if (!isAutoScanActive(state, source) || hasPointerMovedSince(state, pointer)) {
                forgetAutoAttempt(attemptKey, state.id);
                return false;
            }

            const quickKeys = new Set(quickProfiles.map(getRenderedProfileKey));
            const detailProfiles = getAutoScanProfiles(mapping, pointer, true)
                .filter(profile => !quickKeys.has(getRenderedProfileKey(profile)));
            const detailRendered = renderAutoProfiles(loaded.image, detailProfiles);
            decoded = await decodeAutoProfilesWithJsQR(detailRendered);
            if (decoded) return commitAutoSuccess(state, source, attemptKey, decoded);

            if (!isAutoScanActive(state, source) || hasPointerMovedSince(state, pointer)) {
                forgetAutoAttempt(attemptKey, state.id);
                return false;
            }

            decoded = await decodeAutoProfilesWithZXing(quickRendered);
            if (decoded) return commitAutoSuccess(state, source, attemptKey, decoded);

            if (!isAutoScanActive(state, source) || hasPointerMovedSince(state, pointer)) {
                forgetAutoAttempt(attemptKey, state.id);
                return false;
            }

            decoded = await decodeAutoProfilesWithZXing(detailRendered);
            if (decoded) return commitAutoSuccess(state, source, attemptKey, decoded);

            rememberAutoAttempt(attemptKey, { status: 'failed', reason: 'standard_failed' });
            return false;
        } catch (error) {
            if (!loaded && await tryAutoRemoteFallback(state, candidate, attemptKey)) {
                return true;
            }
            rememberAutoAttempt(attemptKey, { status: 'failed', reason: error.message || 'auto_scan_failed' });
            return false;
        } finally {
            if (loaded && loaded.release) loaded.release();
        }
    }

    function scanImage(img, force, cropRect, prevCache, priority) {
        const src = getImageSource(img);
        if (!src) return;
        // 如果非强制且已有缓存(且非skipped) 则跳过
        // 注意：如果是 skipped (too_large) force 模式下应该允许继续
        if (!force && !cropRect && qrCache.has(src)) return;

        let displayWidth = img.width || img.clientWidth || 0;
        let displayHeight = img.height || img.clientHeight || 0;

        const canvas = document.createElement('canvas');
        const context = canvas.getContext('2d');
        const tempImg = new Image();
        tempImg.crossOrigin = "Anonymous";
        tempImg.onload = () => processImage(tempImg, canvas, context, img, src, force, 'IMG', displayWidth, displayHeight, cropRect, prevCache, priority);
        tempImg.onerror = () => scanImage_Fallback(img, src, force, displayWidth, displayHeight, cropRect, prevCache, priority);
        tempImg.src = src;
    }

    function scanImage_Fallback(originalImg, src, force, w, h, cropRect, prevCache, priority) {
        GM_xmlhttpRequest({
            method: "GET",
            url: src,
            responseType: "blob",
            onload: function(response) {
                if (response.status === 200) {
                    const blob = response.response;
                    const blobUrl = URL.createObjectURL(blob);
                    const tempImg = new Image();
                    tempImg.onload = () => {
                        const canvas = document.createElement('canvas');
                        const context = canvas.getContext('2d');
                        processImage(tempImg, canvas, context, originalImg, src, force, 'IMG', w, h, cropRect, prevCache, priority);
                        URL.revokeObjectURL(blobUrl);
                    };
                    tempImg.onerror = () => {
                        if (!cropRect) commitCacheEntry('IMG', src, originalImg, null);
                        URL.revokeObjectURL(blobUrl);
                    };
                    tempImg.src = blobUrl;
                } else {
                    if (!cropRect) commitCacheEntry('IMG', src, originalImg, null);
                }
            },
            onerror: () => { if (!cropRect) commitCacheEntry('IMG', src, originalImg, null); }
        });
    }

    function scanCanvas(canvasEl, force, cropRect, prevCache, priority) {
        if (!force && !cropRect && canvasCache.has(canvasEl)) return;

        try {
            let context = canvasEl.getContext('2d');
            if (context) {
                try {
                    const imageData = context.getImageData(0, 0, canvasEl.width, canvasEl.height);

                    // 1. 确定源尺寸
                    const sourceW = canvasEl.width;
                    const sourceH = canvasEl.height;

                    // 2. 计算裁剪
                    let drawX = 0, drawY = 0, drawW = sourceW, drawH = sourceH;
                    if (cropRect) {
                        const clientW = canvasEl.clientWidth || sourceW;
                        const clientH = canvasEl.clientHeight || sourceH;
                        const scaleX = sourceW / clientW;
                        const scaleY = sourceH / clientH;

                        drawX = cropRect.x * scaleX;
                        drawY = cropRect.y * scaleY;
                        drawW = cropRect.w * scaleX;
                        drawH = cropRect.h * scaleY;
                    }

                    // 3. 计算缩放 (仅缩小 不放大)
                    let targetW = drawW;
                    let targetH = drawH;
                    if (cropRect) {
                        const maxDim = Math.max(drawW, drawH);
                        // 只有当尺寸超过目标尺寸时才缩放
                        if (maxDim > CROP_TARGET_SIZE) {
                            const scale = CROP_TARGET_SIZE / maxDim;
                            targetW = drawW * scale;
                            targetH = drawH * scale;
                        }
                    }

                    // 4. 绘制到新 Canvas (加白边)
                    const padding = 50;
                    const finalCanvas = document.createElement('canvas');
                    finalCanvas.width = targetW + (padding * 2);
                    finalCanvas.height = targetH + (padding * 2);
                    const finalCtx = finalCanvas.getContext('2d');
                    finalCtx.fillStyle = '#FFFFFF';
                    finalCtx.fillRect(0, 0, finalCanvas.width, finalCanvas.height);

                    // 绘制并缩放
                    finalCtx.drawImage(canvasEl, drawX, drawY, drawW, drawH, padding, padding, targetW, targetH);

                    runScanPipeline(finalCanvas, finalCtx, canvasEl, force, 'CANVAS', canvasEl, !!cropRect, prevCache, priority);
                } catch (e) {
                    commitCacheEntry('CANVAS', canvasEl, canvasEl, null);
                }
            } else {
                const dataUrl = canvasEl.toDataURL();
                const tempImg = new Image();
                tempImg.onload = () => {
                    const tempCanvas = document.createElement('canvas');
                    const tempCtx = tempCanvas.getContext('2d');
                    processImage(tempImg, tempCanvas, tempCtx, canvasEl, null, force, 'CANVAS', canvasEl.width, canvasEl.height, cropRect, prevCache, priority);
                };
                tempImg.src = dataUrl;
            }
        } catch (e) {
            commitCacheEntry('CANVAS', canvasEl, canvasEl, null);
        }
    }

    // === 高质量缩放辅助函数 (模拟 Lanczos 效果) ===
    function smartDownscale(imageObj, ctx, sourceX, sourceY, sourceW, sourceH, targetX, targetY, targetW, targetH) {
        // 1. 开启浏览器最高质量插值
        ctx.imageSmoothingEnabled = true;
        ctx.imageSmoothingQuality = 'high';

        // 2. 如果缩放比例小于 2 倍 直接绘制 (分步缩放收益不大)
        if (sourceW <= targetW * 2 && sourceH <= targetH * 2) {
            ctx.drawImage(imageObj, sourceX, sourceY, sourceW, sourceH, targetX, targetY, targetW, targetH);
            return;
        }

        // 3. 分步缩放逻辑
        // 创建临时 Canvas 进行中间态处理
        let tempCanvas = document.createElement('canvas');
        let tempCtx = tempCanvas.getContext('2d');
        let curW = sourceW;
        let curH = sourceH;

        tempCanvas.width = curW;
        tempCanvas.height = curH;

        // 第一步：裁剪原图到临时 Canvas
        tempCtx.drawImage(imageObj, sourceX, sourceY, sourceW, sourceH, 0, 0, curW, curH);

        // 循环减半缩放 直到接近目标尺寸
        while (curW > targetW * 2) {
            const newW = Math.floor(curW * 0.5);
            const newH = Math.floor(curH * 0.5);

            // 创建更小的临时 Canvas
            let nextCanvas = document.createElement('canvas');
            nextCanvas.width = newW;
            nextCanvas.height = newH;
            let nextCtx = nextCanvas.getContext('2d');

            // 绘制缩小版
            nextCtx.drawImage(tempCanvas, 0, 0, curW, curH, 0, 0, newW, newH);

            // 更新引用
            curW = newW;
            curH = newH;
            tempCanvas = nextCanvas; // 丢弃旧的大 Canvas
        }

        // 4. 最后一步：绘制到目标 Canvas
        ctx.drawImage(tempCanvas, 0, 0, curW, curH, targetX, targetY, targetW, targetH);
    }

    function processImage(imageObj, canvas, context, targetEl, cacheKey, force, type, displayWidth, displayHeight, cropRect, prevCache, priority) {
        // 1. 获取原始尺寸
        let naturalW = imageObj.naturalWidth;
        let naturalH = imageObj.naturalHeight;

        // SVG 检测
        const isSVG = /\.svg($|\?|#)/i.test(imageObj.src) || /^data:image\/svg/i.test(imageObj.src);
        const isUnknownSize = !naturalW || naturalW === 0;

        // 标记：是否必须使用 5 参数模式 (SVG 或 无尺寸图片)
        const forceSimpleMode = isSVG || isUnknownSize;

        if (isUnknownSize) {
            naturalW = displayWidth || 300;
            naturalH = displayHeight || 300;
        }

        // 2. 计算目标尺寸 (初始为原图尺寸)
        let targetW = naturalW;
        let targetH = naturalH;

        // 如果是框选模式 先计算裁剪后的理论尺寸
        if (cropRect && !forceSimpleMode) {
            const scaleX = naturalW / displayWidth;
            const scaleY = naturalH / displayHeight;
            targetW = cropRect.w * scaleX;
            targetH = cropRect.h * scaleY;
        }

        // === 关键修改：缩放限制逻辑 ===
        let shouldDownscale = false;

        if (cropRect) {
            // 场景 A: 框选模式
            // 默认缩小 除非开启了 noScale (原图框选)
            if (!cropRect.noScale) shouldDownscale = true;
        } else {
            // 场景 B: 全图模式
            if (!force) {
                // 1. 悬停自动解析 -> 强制缩小 (提升性能)
                shouldDownscale = true;
            } else {
                // 2. 右键强制解析 -> 不缩小 (保留原图细节)
                shouldDownscale = false;
            }
        }

        // 执行缩小计算
        if (shouldDownscale) {
            const maxDim = Math.max(targetW, targetH);
            if (maxDim > CROP_TARGET_SIZE) {
                const scale = CROP_TARGET_SIZE / maxDim;
                targetW *= scale;
                targetH *= scale;
            }
        }

        const padding = 50;
        canvas.width = targetW + (padding * 2);
        canvas.height = targetH + (padding * 2);

        // 3. 绘制背景
        context.fillStyle = '#FFFFFF';
        context.fillRect(0, 0, canvas.width, canvas.height);

        // 4. 绘制图像
        if (cropRect && !forceSimpleMode) {
            // 【模式 A：位图裁剪】
            const scaleX = naturalW / displayWidth;
            const scaleY = naturalH / displayHeight;

            let sourceX = cropRect.x * scaleX;
            let sourceY = cropRect.y * scaleY;
            let sourceW = cropRect.w * scaleX;
            let sourceH = cropRect.h * scaleY;

            // 边界保护
            if (sourceX < 0) sourceX = 0;
            if (sourceY < 0) sourceY = 0;
            if (sourceX + sourceW > naturalW) sourceW = naturalW - sourceX;
            if (sourceY + sourceH > naturalH) sourceH = naturalH - sourceY;

            smartDownscale(imageObj, context, sourceX, sourceY, sourceW, sourceH, padding, padding, targetW, targetH);

        } else {
            // 【模式 B：全图模式】
            if (forceSimpleMode) {
                // SVG: 浏览器原生绘制
                context.imageSmoothingEnabled = true;
                context.imageSmoothingQuality = 'high';
                context.drawImage(imageObj, padding, padding, targetW, targetH);
            } else {
                // 位图全图: 使用 smartDownscale
                // 如果 shouldDownscale 为 true 这里会自动执行高质量缩小
                // 如果 shouldDownscale 为 false 这里就是原图绘制
                smartDownscale(imageObj, context, 0, 0, naturalW, naturalH, padding, padding, targetW, targetH);
            }
        }

        runScanPipeline(canvas, context, targetEl, force, type, cacheKey, !!cropRect, prevCache, priority);
    }

    // ==========================================
    //      核心扫描管道 (JSQR + ZXing)
    // ==========================================

    // 让浏览器有机会渲染一帧 (避免 UI 假死)
    function yieldToMain() {
        return new Promise(resolve => setTimeout(resolve, 0));
    }

    async function runScanPipeline(canvas, context, targetEl, force, type, cacheKey, isCrop, prevCache, priority) {
        if (force) requestShowTooltip("⌛ 正在进行强制解析...", targetEl, "JSQR", { priority });

        await yieldToMain();

        let result = null;
        const imageData = context.getImageData(0, 0, canvas.width, canvas.height);
        const suffix = isCrop ? " 框选" : "";

        // === 智能跳过逻辑 ===
        // 如果是强制解析 且之前的失败原因是 "standard_failed" (标准解析已尝试过且失败)
        // 则直接跳过 Phase 1 进入 Phase 2
        let skipStandard = false;
        if (force && prevCache && prevCache.status === 'failed' && prevCache.reason === 'standard_failed') {
            skipStandard = true;
            requestShowTooltip("⌛ 深度解析...", targetEl, "JSQR", { priority });
            await yieldToMain();
        }

        // --- 阶段 1: 标准解析 ---
        if (!skipStandard) {
            // 1.1 JSQR 标准
            result = jsQR(imageData.data, imageData.width, imageData.height);
            if (result) {
                handleSuccess(result.data, "JSQR" + suffix, type, cacheKey, targetEl, priority);
                return;
            }

            await yieldToMain();

            // 1.2 ZXing 标准
            result = await tryZXing(canvas, force);
            if (result) {
                handleSuccess(result, "ZXing" + suffix, type, cacheKey, targetEl, priority);
                return;
            }
        }

        // 如果不是强制模式 且标准解析失败 则记录失败原因并退出
        if (!force) {
            handleFail(type, cacheKey, targetEl, false, "standard_failed", priority); // <--- 记录原因
            return;
        }

        // --- 阶段 2: 增强解析 (仅强制模式) ---

        requestShowTooltip("⌛ 正在尝试反色解析...", targetEl, "JSQR", { priority });
        await yieldToMain();

        // 反色数据准备
        const invertedData = new Uint8ClampedArray(imageData.data);
        for (let i = 0; i < invertedData.length; i += 4) {
            invertedData[i] = 255 - invertedData[i];
            invertedData[i + 1] = 255 - invertedData[i + 1];
            invertedData[i + 2] = 255 - invertedData[i + 2];
            invertedData[i + 3] = 255;
        }

        // 2.1 JSQR 反色
        result = jsQR(invertedData, imageData.width, imageData.height);
        if (result) {
            handleSuccess(result.data, "JSQR 反色" + suffix, type, cacheKey, targetEl, priority);
            return;
        }

        await yieldToMain();

        // 2.2 ZXing 反色
        const invertedImageData = new ImageData(invertedData, canvas.width, canvas.height);
        context.putImageData(invertedImageData, 0, 0);
        result = await tryZXing(canvas, force);
        if (result) {
            handleSuccess(result, "ZXing 反色" + suffix, type, cacheKey, targetEl, priority);
            return;
        }

        requestShowTooltip("⌛ 正在尝试二值化解析...", targetEl, "JSQR", { priority });
        await yieldToMain();

        // 二值化数据准备
        const binarizedData = new Uint8ClampedArray(imageData.data);
        const len = binarizedData.length;
        let totalLum = 0;
        for (let i = 0; i < len; i += 4) {
            totalLum += 0.299 * binarizedData[i] + 0.587 * binarizedData[i+1] + 0.114 * binarizedData[i+2];
        }
        const avgLum = totalLum / (len / 4);
        for (let i = 0; i < len; i += 4) {
            const lum = 0.299 * binarizedData[i] + 0.587 * binarizedData[i+1] + 0.114 * binarizedData[i+2];
            const val = lum > avgLum ? 255 : 0;
            binarizedData[i] = val;
            binarizedData[i+1] = val;
            binarizedData[i+2] = val;
            binarizedData[i+3] = 255;
        }

        // 2.3 JSQR 二值化
        result = jsQR(binarizedData, imageData.width, imageData.height);
        if (result) {
            handleSuccess(result.data, "JSQR 二值化" + suffix, type, cacheKey, targetEl, priority);
            return;
        }

        await yieldToMain();

        // 2.4 ZXing 二值化
        const binarizedImageData = new ImageData(binarizedData, canvas.width, canvas.height);
        context.putImageData(binarizedImageData, 0, 0);
        result = await tryZXing(canvas, force);
        if (result) {
            handleSuccess(result, "ZXing 二值化" + suffix, type, cacheKey, targetEl, priority);
            return;
        }

        handleFail(type, cacheKey, targetEl, true, "force_failed", priority);
    }

    function tryZXing(canvas, isForce) {
        return new Promise((resolve) => {
            if (typeof ZXing === 'undefined') { resolve(null); return; }

            const dataUrl = canvas.toDataURL('image/png');
            const img = new Image();
            img.onload = () => {
                // 关键修改：将 isForce 传入获取对应的 Reader
                const reader = getZXingReader(isForce);
                if (!reader) { resolve(null); return; }

                reader.decodeFromImageElement(img)
                    .then(res => resolve(res.text))
                    .catch(() => resolve(null));
            };
            img.onerror = () => resolve(null);
            img.src = dataUrl;
        });
    }

    function handleSuccess(text, method, type, cacheKey, targetEl, priority) {
        const committed = commitCacheEntry(type, cacheKey, targetEl, {
            status: 'success',
            text,
            method,
            priority
        });

        if (committed && committed.status === 'success') {
            applyQrSuccess(targetEl, committed.text, committed.method, committed.priority);
        }
    }

    function handleFail(type, cacheKey, targetEl, isForce, reason = "unknown", priority = SCAN_PRIORITY.AUTO) {
        let committed = getCachedEntry(type, cacheKey, targetEl);

        if (!isForce) {
            const failObj = { status: 'failed', reason: reason };
            committed = commitCacheEntry(type, cacheKey, targetEl, failObj);
        }

        if (isForce) {
            if (committed && committed.status === 'success') {
                applyQrSuccess(targetEl, committed.text, committed.method, committed.priority);
            } else {
                requestShowTooltip("❌ 强制解析失败", targetEl, "JSQR", { priority });
            }
        }
    }

    // ==========================================
    //      公共辅助函数
    // ==========================================

    function applyQrSuccess(el, text, method, priority = SCAN_PRIORITY.AUTO) {
        markQrSuccess(el);

        requestShowTooltip(text, el, method, { kind: 'result', priority });
    }

    function isUrl(text) {
        if (!text) return false;
        // ^ : 开始
        // \s*: 允许开头有空格
        // https?:\/\/: 协议
        // [^\s]+: 链接主体不能包含空格
        // \s*: 允许结尾有空格
        // $ : 结束
        return /^\s*https?:\/\/[^\s]+\s*$/i.test(text);
    }
    function escapeHtml(text) {
        if (!text) return "";
        return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#039;");
    }

    function isScanTarget(target) {
        return target instanceof Element && (target.tagName === 'IMG' || target.tagName === 'CANVAS');
    }

    function areRelatedTargets(first, second) {
        if (first === second) return true;
        if (!(first instanceof Node) || !(second instanceof Node)) return false;
        return first.contains(second) || second.contains(first);
    }

    function clearLongPressTimer() {
        if (!longPressTimer) return;
        clearTimeout(longPressTimer);
        longPressTimer = null;
    }

    function resetCombinationState() {
        isRightClickHolding = false;
        leftClickCount = 0;
        interactionTarget = null;
    }

    function clearPendingClickSuppression() {
        pendingClickSuppression = null;
    }

    function armClickSuppression(target) {
        pendingClickSuppression = {
            target,
            expiresAt: Date.now() + INPUT_SUPPRESSION_TIMEOUT_MS
        };
    }

    function consumeClickSuppression(event) {
        if (!event.isTrusted || !pendingClickSuppression) return false;

        const pending = pendingClickSuppression;
        pendingClickSuppression = null;
        return Date.now() <= pending.expiresAt && areRelatedTargets(pending.target, event.target);
    }

    function clearPendingContextMenuSuppression() {
        pendingContextMenuSuppression = null;
    }

    function armContextMenuSuppression(target) {
        pendingContextMenuSuppression = {
            target,
            expiresAt: Date.now() + INPUT_SUPPRESSION_TIMEOUT_MS
        };
    }

    function consumeContextMenuSuppression(event) {
        if (!event.isTrusted || !pendingContextMenuSuppression) return false;

        const pending = pendingContextMenuSuppression;
        pendingContextMenuSuppression = null;
        return Date.now() <= pending.expiresAt && areRelatedTargets(pending.target, event.target);
    }

    function resetInteractionState(cancelCrop = false) {
        clearLongPressTimer();
        clearPendingClickSuppression();
        clearPendingContextMenuSuppression();
        resetCombinationState();
        if (cancelCrop) stopAutoHover(true);
        if (cancelCrop && isCropping) endCropMode();
    }

    function findScanTargetAtPoint(event) {
        if (isScanTarget(event.target)) return event.target;
        if (typeof document.elementsFromPoint !== 'function') return null;
        const stack = document.elementsFromPoint(event.clientX, event.clientY);
        const image = stack.find(element => element.tagName === 'IMG');
        if (image) return image;
        return stack.find(element => element.tagName === 'CANVAS' && getComputedStyle(element).pointerEvents !== 'none') || null;
    }

    function stopAutoHover(hideTooltip = false) {
        const state = autoHoverState;
        if (!state) return;

        if (state.timer) clearTimeout(state.timer);
        if (state.loadCleanup) state.loadCleanup();
        autoHoverState = null;
        if (hideTooltip && currentTarget === state.target && !isCropping) {
            requestHideTooltip();
        }
    }

    function scheduleAutoHoverTick(state, delay = 0) {
        if (autoHoverState !== state || state.timer || state.completed) return;
        state.timer = setTimeout(() => {
            state.timer = null;
            void runAutoHoverTick(state);
        }, delay);
    }

    function waitForHoveredImageLoad(state) {
        if (state.loadCleanup || state.target.tagName !== 'IMG') return;

        const target = state.target;
        const cleanup = () => {
            target.removeEventListener('load', onLoad);
            target.removeEventListener('error', onError);
            state.loadCleanup = null;
        };
        const onLoad = () => {
            cleanup();
            if (autoHoverState === state) scheduleAutoHoverTick(state);
        };
        const onError = () => cleanup();
        state.loadCleanup = cleanup;
        target.addEventListener('load', onLoad);
        target.addEventListener('error', onError);

        // 避免图片恰好在检查和绑定事件之间完成加载。
        if (target.complete && target.naturalWidth) {
            setTimeout(onLoad, 0);
        } else if (target.complete && getImageSource(target)) {
            setTimeout(onError, 0);
        }
    }

    function showCachedAutoResult(state) {
        const target = state.target;
        const cacheData = target.tagName === 'IMG'
            ? qrCache.get(getImageSource(target))
            : canvasCache.get(target);

        if (!cacheData) return false;
        state.completed = true;
        if (cacheData.status === 'success') {
            applyQrSuccess(target, cacheData.text, cacheData.method, cacheData.priority);
        }
        return true;
    }

    function beginAutoHover(target, event) {
        if (isCropping || !target) return;
        if (autoHoverState && autoHoverState.target === target) {
            autoHoverState.pointer = { clientX: event.clientX, clientY: event.clientY };
            return;
        }

        stopAutoHover(true);
        const state = {
            id: ++autoScanSequence,
            target,
            pointer: { clientX: event.clientX, clientY: event.clientY },
            lastScanPoint: null,
            timer: null,
            inFlight: false,
            completed: false,
            canvasAttempted: false,
            loadCleanup: null
        };
        autoHoverState = state;
        if (!showCachedAutoResult(state)) scheduleAutoHoverTick(state);
    }

    function updateAutoHover(event) {
        if (isCropping) return;
        const target = findScanTargetAtPoint(event);
        if (!target) {
            stopAutoHover(true);
            return;
        }

        if (!autoHoverState || autoHoverState.target !== target) {
            beginAutoHover(target, event);
            return;
        }

        const state = autoHoverState;
        state.pointer = { clientX: event.clientX, clientY: event.clientY };
        if (state.completed || state.canvasAttempted || state.timer || state.inFlight) return;

        const moved = !state.lastScanPoint || Math.hypot(
            state.pointer.clientX - state.lastScanPoint.clientX,
            state.pointer.clientY - state.lastScanPoint.clientY
        ) >= AUTO_RESCAN_DISTANCE_PX;
        if (moved) scheduleAutoHoverTick(state);
    }

    async function runAutoHoverTick(state) {
        if (autoHoverState !== state || isCropping || state.inFlight || state.completed) return;

        const target = state.target;
        const pointer = { ...state.pointer };
        state.lastScanPoint = pointer;

        if (target.tagName === 'CANVAS') {
            const width = target.width || target.clientWidth;
            const height = target.height || target.clientHeight;
            state.canvasAttempted = true;
            if (width > AUTO_CANVAS_MAX_SIZE || height > AUTO_CANVAS_MAX_SIZE ||
                Math.abs(width - height) > CANVAS_SQUARE_TOLERANCE || width < 30) {
                commitCacheEntry('CANVAS', target, target, {
                    status: 'skipped',
                    reason: 'invalid_auto_canvas'
                });
                return;
            }
            scanElement(target, false);
            return;
        }

        const cached = qrCache.get(getImageSource(target));
        if (cached && cached.status === 'success') {
            state.completed = true;
            applyQrSuccess(target, cached.text, cached.method, cached.priority);
            return;
        }

        const candidate = evaluateAutoImageCandidate(target);
        if (!candidate.eligible) {
            if (candidate.reason === 'not_loaded') waitForHoveredImageLoad(state);
            return;
        }
        if (state.loadCleanup) state.loadCleanup();

        const mapping = getDisplayedImageMapping(target);
        if (!mapping) return;
        const attemptKey = buildAutoAttemptKey(target, mapping, pointer);
        const previousAttempt = autoAttemptCache.get(attemptKey);
        if (previousAttempt && previousAttempt.status !== 'scanning') return;
        if (previousAttempt && Date.now() - previousAttempt.startedAt < 5000) {
            scheduleAutoHoverTick(state, AUTO_PENDING_RETRY_MS);
            return;
        }

        state.inFlight = true;
        rememberAutoAttempt(attemptKey, { status: 'scanning', startedAt: Date.now(), scanId: state.id });
        try {
            const succeeded = await scanAutoImage(state, candidate, mapping, pointer, attemptKey);
            if (succeeded) state.completed = true;
        } finally {
            state.inFlight = false;
            if (autoHoverState === state && !state.completed) {
                const sourceChanged = getImageSource(state.target) !== candidate.source;
                const moved = Math.hypot(
                    state.pointer.clientX - pointer.clientX,
                    state.pointer.clientY - pointer.clientY
                ) >= AUTO_RESCAN_DISTANCE_PX;
                if (moved || sourceChanged) scheduleAutoHoverTick(state);
            }
        }
    }

    // ==========================================
    //      事件监听
    // ==========================================

    document.addEventListener('mousemove', (e) => {
        lastMouseScreenX = e.screenX;
        lastMouseScreenY = e.screenY;
        lastMouseClientX = e.clientX;
        lastMouseClientY = e.clientY;

        if (isTop) {
            topWinOffset = {
                x: e.screenX - e.clientX,
                y: e.screenY - e.clientY
            };
        }

        // 如果在文档外释放了右键，buttons 是浏览器提供的真实按键状态。
        if (isRightClickHolding && (e.buttons & 2) === 0) {
            resetCombinationState();
        }

        updateAutoHover(e);
    }, true);

    document.addEventListener('mouseover', (e) => {
        if (!isCropping) updateAutoHover(e);
    });

    document.addEventListener('mouseout', (e) => {
        // 清除长按定时器
        clearLongPressTimer();

        if (autoHoverState && e.target === autoHoverState.target &&
            !areRelatedTargets(autoHoverState.target, e.relatedTarget)) {
            stopAutoHover(true);
        }
    });

    // === 交互逻辑 ===

    document.addEventListener('mousedown', (e) => {
        if (isCropping) return;

        // 右键逻辑
        if (e.button === 2) {
            clearLongPressTimer();
            clearPendingClickSuppression();
            clearPendingContextMenuSuppression();
            resetCombinationState();

            // 只有从图片或画布上开始的右键才进入脚本的组合手势。
            if (isScanTarget(e.target)) {
                isRightClickHolding = true;
                interactionTarget = e.target;
            }
        }
        // 左键逻辑
        else if (e.button === 0) {
            // 上一次操作如果没有产生 click，不能让抑制状态泄漏到这次点击。
            clearLongPressTimer();
            clearPendingClickSuppression();

            const isRightButtonActuallyDown = (e.buttons & 2) !== 0;
            if (isRightClickHolding && !isRightButtonActuallyDown) {
                resetCombinationState();
            }

            // 1. 组合键逻辑 (右键按住 + 左键点击)
            if (isRightClickHolding && isRightButtonActuallyDown && e.target === interactionTarget) {
                e.preventDefault();
                e.stopPropagation();
                e.stopImmediatePropagation();

                leftClickCount++;
                armContextMenuSuppression(interactionTarget);
                armClickSuppression(interactionTarget);
                return;
            }

            // 右键确实按着但不属于有效组合手势时，不干预页面，也不触发长按。
            if (isRightButtonActuallyDown) {
                return;
            }

            // 2. 长按复制逻辑
            const target = e.target;
            if (isScanTarget(target) && target.dataset.hasQr === "true") {
                // 获取数据
                let data = null;
                let cacheData = null;
                if (target.tagName === 'IMG') cacheData = qrCache.get(getImageSource(target));
                else cacheData = canvasCache.get(target);

                if (cacheData && cacheData.status === 'success') {
                    data = cacheData.text;
                }

                // 只有当结果是链接时 才启用长按复制
                if (data && isUrl(data)) {
                    longPressTimer = setTimeout(() => {
                        GM_setClipboard(data);
                        requestFeedback(); // 显示 "已复制"
                        armClickSuppression(target); // 只阻止本次长按随后产生的 click
                        longPressTimer = null; // 重置定时器
                    }, 500);
                }
            }
        }
    }, true);

    document.addEventListener('mouseup', (e) => {
        // 清除长按定时器
        clearLongPressTimer();

        if (isCropping) return;

        if (e.button === 2) {
            const target = interactionTarget;
            const clickCount = leftClickCount;
            resetCombinationState();

            if (clickCount > 0 && target) {
                // 1次点击 -> 强制本地解析 (全策略)
                if (clickCount === 1) {
                    scanElement(target, true);
                }
                // 2次点击 -> 远程解析
                else if (clickCount === 2) {
                    scanExternal(target);
                }
                // 3次点击 -> 普通框选 (会缩小到 500px)
                else if (clickCount === 3) {
                    startCropMode(target, false);
                }
                // 4次点击 -> 原图框选 (不缩小)
                else if (clickCount === 4) {
                    startCropMode(target, true);
                }
            }
        } else if (e.button === 0 && isRightClickHolding && (e.buttons & 2) === 0) {
            resetCombinationState();
        }
    }, true);

    document.addEventListener('contextmenu', (e) => {
        if (consumeContextMenuSuppression(e)) {
            e.preventDefault();
            e.stopPropagation();
            e.stopImmediatePropagation();
        }
    }, true);

    document.addEventListener('click', (e) => {
        if (consumeClickSuppression(e)) {
            e.preventDefault();
            e.stopPropagation();
            e.stopImmediatePropagation();
            return;
        }

        const target = e.target;
        if ((target.tagName === 'IMG' || target.tagName === 'CANVAS') && target.dataset.hasQr === "true") {
            let data = null;
            let cacheData = null;

            if (target.tagName === 'IMG') cacheData = qrCache.get(getImageSource(target));
            else cacheData = canvasCache.get(target);

            // 检查 status === 'success'
            if (cacheData && cacheData.status === 'success') {
                data = cacheData.text;
            }

            if (data) {
                e.preventDefault();
                e.stopPropagation();

                if (isUrl(data)) {
                    GM_openInTab(data, { active: true, insert: true });
                } else {
                    GM_setClipboard(data);
                    requestFeedback();
                }
            }
        }
    }, true);

    document.addEventListener('keydown', (e) => {
        if (e.key === 'Escape' && isCropping) {
            const target = cropTarget || currentTarget || document.body;
            const priority = isNoScaleCrop ? SCAN_PRIORITY.CROP_ORIGINAL : SCAN_PRIORITY.CROP_SCALED;
            endCropMode();
            requestShowTooltip("❌ 已取消框选", target, "JSQR", { priority });
        }
    });

    // 浏览器可能在窗口外释放鼠标而不派发 mouseup，必须主动回收状态。
    window.addEventListener('blur', () => resetInteractionState(true), true);
    window.addEventListener('pagehide', () => resetInteractionState(true), true);
    document.documentElement.addEventListener('mouseleave', (e) => {
        if (e.target === document.documentElement && !e.relatedTarget) {
            resetInteractionState(true);
        }
    }, true);
    document.addEventListener('visibilitychange', () => {
        if (document.hidden) resetInteractionState(true);
    }, true);

})();