// ==UserScript==
// @name         麦田影院(mtyy4.com) 广告净化
// @namespace    https://github.com/mtyy-adblock
// @version      3.5.1
// @description  ① 移除麦田影院(mtyy4.com)的横幅/悬浮/弹窗广告、点击劫持透明层与第三方广告统计脚本；② 播放器增强（设置项全部集成在播放器自带的设置面板内）：自动跳过片头片尾（全局配置、带校验、多路检测+巡检重试、换集自动重开）、记住播放倍速、临时 2 倍速（桌面端长按方向键，移动端长按播放区两侧透明热区）
// @author       You
// @match        *://*.mtyy4.com/*
// @match        *://*.mtyy1.cc/*
// @run-at       document-start
// @grant        GM_addStyle
// @grant        GM_setValue
// @grant        GM_getValue
// @grant        GM_registerMenuCommand
// @grant        unsafeWindow
// @license MIT
// ==/UserScript==

(function () {
    'use strict';

    // ========================= 运行环境 =========================
    // 使用 unsafeWindow 确保对页面全局的修改真正生效（脚本猫沙箱下 window 可能被代理）
    const w = (typeof unsafeWindow !== 'undefined' && unsafeWindow) ? unsafeWindow : window;
    const d = w.document;

    // ========================= 配置 =========================
    const CONFIG = {
        // 已确认的广告/推广/统计域名（首页内联混淆脚本会动态拼装这些域名）
        adHosts: [
            'f0cmqjk.com',      // 主广告脚本（:9003/sc/1198）
            '480ipil.com',      // 移动端点位，会强制跳转
            'cb1nvdt.com',      // WebSocket 广告通道
            'z8ioqja.com',      // WebSocket 广告通道
            '2svk4ps.com',      // WebSocket 广告通道
            'aizhantj.com',     // 爱站统计追踪（:21233/tjjs）
            'ieo0s3m.cc',       // 横幅广告落地页（share_utm 推广）
        ],
        // 广告服务常用端口（非本站域名命中即拦截，防止域名轮换）
        adPorts: ['9003', '9903', '21233'],
        // 广告代码特征码：站点内联脚本里出现这些串，说明是广告逻辑（用于拦截其注册的劫持监听）
        adCodeMarkers: [
            'f0cmqjk.com', '480ipil.com', 'cb1nvdt.com', 'z8ioqja.com', '2svk4ps.com',
            'aizhantj.com', 'ieo0s3m.cc', 'gvbqxwcb', ':9003', ':9903', ':21233', '/1198',
        ],
        // 本站及资源站白名单，永不拦截
        selfHosts: ['mtyy4.com', 'mtyy1.cc', 'mtzy2.com', 'mtyy2.com'],
        // 站内广告图片目录
        adPathKeys: ['/static/images/gg/'],
        // 广告容器选择器（data-id="ad-*" 为该站广告位标识）
        adSelectors: [
            '.ec-ad',
            '.ec-ad-double',
            '.ads_w',
            '.ads_close_btn',
            '.slide-wap',
            '[data-id^="ad-"]',
            '[class*="ads_w"]',
            '[id*="gvbqxwcb"]',
            '[class*="gvbqxwcb"]',
        ],
        // 运行时开关
        blockAutoPopups: GM_getValue('block_auto_popups', true), // 拦截非用户触发的弹窗
        blockGhostLayer: GM_getValue('block_ghost_layer', true), // 拦截透明点击劫持层
        debug: GM_getValue('debug_mode', false),
    };

    // 拦截统计
    const STATS = { script: 0, element: 0, popup: 0, network: 0, ghost: 0, hijack: 0, total: 0 };

    function log(...args) {
        if (CONFIG.debug) console.log('[麦田去广告]', ...args);
    }
    function hit(type, info) {
        STATS[type] = (STATS[type] || 0) + 1;
        STATS.total++;
        log('已拦截', type, info);
    }

    // ========================= URL 判定 =========================
    const hostCache = Object.create(null);

    function isSelfHost(host) {
        return CONFIG.selfHosts.some(h => host === h || host.endsWith('.' + h));
    }

    function isAdUrl(url) {
        if (!url || typeof url !== 'string') return false;
        // 站内广告图片
        if (CONFIG.adPathKeys.some(p => url.indexOf(p) !== -1)) return true;
        // 过滤 data: / blob: / javascript: 等
        if (/^(data|blob|javascript|about|chrome-extension|moz-extension):/i.test(url)) return false;
        if (url.charAt(0) === '#' || url.charAt(0) === '/') return false;

        let u;
        try {
            u = new w.URL(url, w.location.href);
        } catch (e) {
            return false;
        }
        const host = u.hostname;
        if (hostCache[host] !== undefined) return hostCache[host];

        let blocked = false;
        if (isSelfHost(host)) {
            blocked = false;
        } else if (CONFIG.adHosts.some(h => host === h || host.endsWith('.' + h))) {
            blocked = true;
        } else if (CONFIG.adPorts.indexOf(u.port) !== -1) {
            // 广告脚本固定的 9003 / 9903 / 21233 端口
            blocked = true;
        }
        hostCache[host] = blocked;
        return blocked;
    }

    // ========================= 1. 拦截第三方广告/统计脚本 =========================
    function hookScriptSrc() {
        const proto = w.HTMLScriptElement && w.HTMLScriptElement.prototype;
        if (!proto) return;
        const desc = Object.getOwnPropertyDescriptor(proto, 'src');
        if (!desc || !desc.set) return;
        Object.defineProperty(proto, 'src', {
            configurable: true,
            enumerable: desc.enumerable,
            get: function () {
                return desc.get.call(this);
            },
            set: function (value) {
                if (isAdUrl(value)) {
                    hit('script', value);
                    return; // 不写入 src，脚本永远不会发起请求
                }
                desc.set.call(this, value);
            }
        });
        log('已接管 HTMLScriptElement.src');
    }

    function hookSetAttribute() {
        const orig = w.Element.prototype.setAttribute;
        w.Element.prototype.setAttribute = function (name, value) {
            const n = String(name || '').toLowerCase();
            if ((n === 'src' || n === 'href') && isAdUrl(value)) {
                hit('script', value);
                return;
            }
            return orig.call(this, name, value);
        };
    }

    // ========================= 2. 拦截广告网络请求 =========================
    function hookNetwork() {
        // fetch
        const origFetch = w.fetch;
        if (origFetch) {
            w.fetch = function (input, init) {
                const url = typeof input === 'string' ? input : (input && input.url);
                if (isAdUrl(url)) {
                    hit('network', url);
                    return Promise.reject(new TypeError('Blocked by adblocker'));
                }
                return origFetch.call(w, input, init);
            };
        }

        // XMLHttpRequest（不抛异常，改为指向空地址，避免打断站点逻辑）
        const XHR = w.XMLHttpRequest;
        if (XHR) {
            const origOpen = XHR.prototype.open;
            const origSend = XHR.prototype.send;
            XHR.prototype.open = function (method, url) {
                if (isAdUrl(url)) {
                    hit('network', url);
                    this.__adblocked = true;
                    return origOpen.call(this, 'GET', 'about:blank');
                }
                this.__adblocked = false;
                return origOpen.apply(this, arguments);
            };
            XHR.prototype.send = function () {
                if (this.__adblocked) return;
                return origSend.apply(this, arguments);
            };
        }

        // sendBeacon
        if (w.navigator && w.navigator.sendBeacon) {
            const origBeacon = w.navigator.sendBeacon.bind(w.navigator);
            w.navigator.sendBeacon = function (url, data) {
                if (isAdUrl(url)) {
                    hit('network', url);
                    return true; // 假装已发送
                }
                return origBeacon(url, data);
            };
        }

        // WebSocket（广告通道 wss://...:9903）
        const OrigWS = w.WebSocket;
        if (OrigWS) {
            function GuardedWS(url, protocols) {
                if (isAdUrl(url)) {
                    hit('network', url);
                    // 返回一个"死"对象，防止广告脚本因异常而反复重试
                    const dummy = {
                        readyState: 3,
                        bufferedAmount: 0,
                        onopen: null, onmessage: null, onerror: null, onclose: null,
                        close: function () {}, send: function () {},
                        addEventListener: function () {}, removeEventListener: function () {}
                    };
                    return dummy;
                }
                return protocols === undefined ? new OrigWS(url) : new OrigWS(url, protocols);
            }
            GuardedWS.prototype = OrigWS.prototype;
            ['CONNECTING', 'OPEN', 'CLOSING', 'CLOSED'].forEach(function (k) {
                try { GuardedWS[k] = OrigWS[k]; } catch (e) {}
            });
            w.WebSocket = GuardedWS;
        }

        // EventSource
        if (w.EventSource) {
            const OrigES = w.EventSource;
            function GuardedES(url, cfg) {
                if (isAdUrl(url)) {
                    hit('network', url);
                    throw new w.DOMException('Blocked by adblocker', 'SecurityError');
                }
                return cfg === undefined ? new OrigES(url) : new OrigES(url, cfg);
            }
            GuardedES.prototype = OrigES.prototype;
            w.EventSource = GuardedES;
        }
    }

    // ========================= 3. 拦截跳转劫持与弹窗 =========================
    function hookNavigation() {
        // location.assign / location.replace
        const LP = w.Location && w.Location.prototype;
        if (LP) {
            ['assign', 'replace'].forEach(function (name) {
                const orig = LP[name];
                if (!orig) return;
                LP[name] = function (url) {
                    if (isAdUrl(url)) {
                        hit('popup', url);
                        return;
                    }
                    return orig.call(this, url);
                };
            });
            // 部分浏览器允许重定义 href（失败也无害）
            try {
                const hd = Object.getOwnPropertyDescriptor(LP, 'href');
                if (hd && hd.set && hd.configurable) {
                    Object.defineProperty(LP, 'href', {
                        configurable: true,
                        enumerable: hd.enumerable,
                        get: function () { return hd.get.call(this); },
                        set: function (value) {
                            if (isAdUrl(value)) {
                                hit('popup', value);
                                return;
                            }
                            hd.set.call(this, value);
                        }
                    });
                }
            } catch (e) {}
        }

        // 记录用户最后一次真实交互，用于区分"主动点击"和"自动弹窗"
        let lastInteract = Date.now();
        ['pointerdown', 'mousedown', 'touchstart', 'keydown', 'click'].forEach(function (t) {
            d.addEventListener(t, function () { lastInteract = Date.now(); },
                { capture: true, passive: true });
        });

        const origOpen = w.open;
        w.open = function (url) {
            if (isAdUrl(url)) {
                hit('popup', url);
                return null;
            }
            // 广告脚本常在页面加载后 1~2 秒自动 window.open
            if (CONFIG.blockAutoPopups && (Date.now() - lastInteract) > 1500) {
                hit('popup', url);
                return null;
            }
            return origOpen ? origOpen.apply(w, arguments) : null;
        };

        // 拦截广告链接点击 / 点击劫持
        d.addEventListener('click', function (e) {
            const link = e.target && e.target.closest ? e.target.closest('a[href]') : null;
            if (link && isAdUrl(link.getAttribute('href'))) {
                hit('popup', link.getAttribute('href'));
                e.preventDefault();
                e.stopImmediatePropagation();
                const box = link.closest('.ads_w, .ec-ad, [data-id^="ad-"]') || link;
                box.remove();
            }
        }, true);
    }

    // ===================== 1.5 拦截广告的「点击劫持监听」 =====================
    // 移动端恶性跳转的真凶：站点内联脚本会注册 document.addEventListener('touchend', fn)，
    // 命中屏幕下方区域就直接执行 top.location = 广告地址。
    // 这类 location 赋值（location.href / top.location / window.location）是 [LegacyUnforgeable]，
    // 无法用属性改写拦截，所以要在它「注册监听器」的那一刻按特征码直接丢弃。
    let guardInstalled = false;
    const HIJACK_EVENTS = ['touchend', 'touchstart', 'click', 'pointerup', 'pointerdown',
        'mouseup', 'mousedown', 'pointermove', 'touchmove'];

    function isAdCode(fn) {
        let src = '';
        try { src = String(fn); } catch (e) { return false; }
        if (!src || src.indexOf('[native code]') !== -1) return false;
        return CONFIG.adCodeMarkers.some(function (m) { return src.indexOf(m) !== -1; });
    }

    function installEventListenerGuard() {
        if (guardInstalled) return;
        guardInstalled = true;

        const proto = w.EventTarget && w.EventTarget.prototype;
        if (proto && proto.addEventListener) {
            const origAdd = proto.addEventListener;
            proto.addEventListener = function (type, listener, options) {
                if (typeof listener === 'function' &&
                    HIJACK_EVENTS.indexOf(String(type)) !== -1 &&
                    isAdCode(listener)) {
                    hit('hijack', '丢弃广告劫持监听 ' + type);
                    return;
                }
                return origAdd.call(this, type, listener, options);
            };
        }

        // 事件属性赋值（document.ontouchend = fn / window.onclick = fn ...）同样拦截
        const props = ['ontouchend', 'ontouchstart', 'onclick', 'onmousedown', 'onmouseup',
            'onpointerdown', 'onpointerup'];
        [w.Window && w.Window.prototype, w.Document && w.Document.prototype].forEach(function (pp) {
            if (!pp) return;
            props.forEach(function (name) {
                const d0 = Object.getOwnPropertyDescriptor(pp, name);
                if (!d0 || !d0.set || !d0.configurable) return;
                Object.defineProperty(pp, name, {
                    configurable: true,
                    enumerable: d0.enumerable,
                    get: function () { return d0.get.call(this); },
                    set: function (fn) {
                        if (typeof fn === 'function' && isAdCode(fn)) {
                            hit('hijack', '丢弃广告劫持事件属性 ' + name);
                            return;
                        }
                        d0.set.call(this, fn);
                    }
                });
            });
        });
        log('已开启广告劫持监听拦截');
    }

    // ========================= 4. 样式隐藏（兜底，防闪烁） =========================
    function injectCSS() {
        const css = [
            '.ec-ad,.ec-ad-double,.ads_w,.ads_close_btn,.slide-wap,',
            '[data-id^="ad-"],[class*="ads_w"],[id*="gvbqxwcb"],[class*="gvbqxwcb"]{',
            '  display:none!important;visibility:hidden!important;opacity:0!important;',
            '  width:0!important;height:0!important;min-height:0!important;max-height:0!important;',
            '  margin:0!important;padding:0!important;border:0!important;overflow:hidden!important;',
            '  pointer-events:none!important;}',
            'img[src*="/static/images/gg/"]{display:none!important;}',
            /* 广告脚本会给 body 加 100px 内边距占位，这里还原 */
            'body{padding-bottom:0!important;}'
        ].join('\n');

        try {
            if (typeof GM_addStyle === 'function') {
                GM_addStyle(css);
                log('CSS 已注入(GM_addStyle)');
                return;
            }
        } catch (e) {}

        const apply = function () {
            const host = d.head || d.documentElement;
            if (!host) return false;
            try {
                const st = d.createElement('style');
                st.setAttribute('data-mtyy-adblock', '1');
                st.textContent = css;
                host.appendChild(st);
                log('CSS 已注入(style 标签)');
                return true;
            } catch (e) {
                return false;
            }
        };
        if (!apply()) {
            // document-start 阶段 <head> 可能还不存在，稍后补注入
            d.addEventListener('DOMContentLoaded', apply, { once: true });
        }
    }

    // ========================= 5. DOM 清理 =========================
    function isGhostLayer(el) {
        if (!el || el.nodeType !== 1) return false;
        if (el.tagName !== 'DIV' && el.tagName !== 'A' && el.tagName !== 'SECTION') return false;
        // 播放器内部的遮罩/锁屏/加载层一律不碰（ArtPlayer 的 .art-mask/.art-state 等）
        if (el.closest && el.closest('.art-video-player,.MacPlayer,#playleft')) return false;
        const cs = w.getComputedStyle(el);
        if (!cs) return false;
        if (cs.position !== 'fixed' && cs.position !== 'absolute') return false;
        const op = parseFloat(cs.opacity);
        if (!(op >= 0 && op < 0.06)) return false;              // 近乎全透明
        if (parseInt(cs.zIndex || '0', 10) < 50) return false;   // 且层级很高
        if (cs.backgroundColor === 'rgba(0, 0, 0, 0)') return false;
        if ((el.textContent || '').trim()) return false;          // 无文字
        if (el.children.length) return false;                     // 无子元素
        const r = el.getBoundingClientRect();
        if (r.width < 30 || r.height < 30) return false;
        return true;
    }

    function cleanNode(node) {
        if (!node || node.nodeType !== 1) return;

        // 5.1 广告容器
        for (let i = 0; i < CONFIG.adSelectors.length; i++) {
            const sel = CONFIG.adSelectors[i];
            let matched = false;
            try { matched = node.matches && node.matches(sel); } catch (e) {}
            if (matched) {
                hit('element', sel);
                node.remove();
                return;
            }
        }

        // 5.2 指向广告域名的资源/链接
        const tag = node.tagName;
        if (tag === 'SCRIPT' || tag === 'IFRAME' || tag === 'IMG' ||
            tag === 'LINK' || tag === 'A' || tag === 'SOURCE' || tag === 'VIDEO') {
            const attr = (tag === 'LINK' || tag === 'A') ? 'href' : 'src';
            const val = node.getAttribute(attr);
            if (val && isAdUrl(val)) {
                hit('element', tag + '[' + attr + ']=' + val);
                node.remove();
                return;
            }
        }

        // 5.3 透明点击劫持层
        if (CONFIG.blockGhostLayer && isGhostLayer(node)) {
            hit('ghost', node.className || node.tagName);
            node.remove();
            return;
        }

        // 5.4 递归检查新增节点的子树
        try {
            const inner = node.querySelectorAll(CONFIG.adSelectors.join(','));
            for (let k = 0; k < inner.length; k++) {
                hit('element', 'sub');
                inner[k].remove();
            }
        } catch (e) {}

        if (CONFIG.blockGhostLayer) {
            try {
                const layers = node.querySelectorAll('div[style*="fixed"],div[style*="absolute"],div[style*="opacity"]');
                for (let k = 0; k < layers.length; k++) {
                    if (isGhostLayer(layers[k])) {
                        hit('ghost', 'sub');
                        layers[k].remove();
                    }
                }
            } catch (e) {}
        }
    }

    function cleanAll() {
        // 全量扫描（低频调用）
        CONFIG.adSelectors.forEach(function (sel) {
            try {
                d.querySelectorAll(sel).forEach(function (el) {
                    hit('element', sel);
                    el.remove();
                });
            } catch (e) {}
        });

        try {
            d.querySelectorAll('script[src],iframe[src],img[src],link[href],a[href],source[src]')
                .forEach(function (el) {
                    const tag = el.tagName;
                    const attr = (tag === 'LINK' || tag === 'A') ? 'href' : 'src';
                    const val = el.getAttribute(attr);
                    if (val && isAdUrl(val)) {
                        hit('element', tag + '=' + val);
                        el.remove();
                    }
                });
        } catch (e) {}

        if (CONFIG.blockGhostLayer) {
            try {
                d.querySelectorAll('div[style*="fixed"],div[style*="opacity"]').forEach(function (el) {
                    if (isGhostLayer(el)) {
                        hit('ghost', 'scan');
                        el.remove();
                    }
                });
            } catch (e) {}
        }
    }

    // 用 rAF 合并 MutationObserver 回调，避免频繁回流
    let pending = [];
    let scheduled = false;
    function schedule(nodes) {
        for (let i = 0; i < nodes.length; i++) pending.push(nodes[i]);
        if (scheduled) return;
        scheduled = true;
        const flush = function () {
            scheduled = false;
            const list = pending;
            pending = [];
            for (let i = 0; i < list.length; i++) {
                if (list[i].isConnected) cleanNode(list[i]);
            }
        };
        if (w.requestAnimationFrame) w.requestAnimationFrame(flush);
        else w.setTimeout(flush, 16);
    }

    function startObserver() {
        const target = d.documentElement || d;
        const mo = new w.MutationObserver(function (records) {
            for (let i = 0; i < records.length; i++) {
                const added = records[i].addedNodes;
                for (let j = 0; j < added.length; j++) schedule([added[j]]);
            }
        });
        mo.observe(target, { childList: true, subtree: true });
        log('MutationObserver 已启动');
    }

    // ========================= 6. 菜单 =========================
    function registerMenu() {
        if (typeof GM_registerMenuCommand !== 'function') return;

        GM_registerMenuCommand('立即清理广告', function () {
            cleanAll();
        });

        GM_registerMenuCommand('拦截统计', function () {
            alert(
                '麦田影院广告净化 + 播放增强 v3.4.0\n' +
                '本次已拦截：' + STATS.total + ' 次\n' +
                '  广告脚本/资源：' + STATS.script + '\n' +
                '  广告元素：' + STATS.element + '\n' +
                '  弹窗/劫持跳转：' + STATS.popup + '\n' +
                '  广告网络请求：' + STATS.network + '\n' +
                '  透明劫持层：' + STATS.ghost + '\n' +
                '  劫持跳转监听：' + STATS.hijack
            );
        });

        GM_registerMenuCommand('切换「自动弹窗拦截」：' + (CONFIG.blockAutoPopups ? '开' : '关'), function () {
            const v = !CONFIG.blockAutoPopups;
            GM_setValue('block_auto_popups', v);
            alert('自动弹窗拦截已' + (v ? '开启' : '关闭') + '，刷新页面生效');
        });

        GM_registerMenuCommand('切换「调试日志」：' + (CONFIG.debug ? '开' : '关'), function () {
            const v = !CONFIG.debug;
            GM_setValue('debug_mode', v);
            alert('调试日志已' + (v ? '开启' : '关闭') + '，刷新页面生效');
        });
    }

    // ================================================================
    // ============= 模块 B：播放设置（持久化 + 解析 + 校验） =============
    // ================================================================

    const SETTINGS_KEY = 'mtyy_player_cfg_v1';
    const RATE_MIN = 0.25;        // 倍速下限
    const RATE_MAX = 4;           // 倍速上限
    const HOLD_MULT = 2;          // 长按临时倍速（在基准倍速上 ×2）
    const HOLD_MS_KEY = 280;      // 桌面端长按方向键判定阈值（毫秒）
    const HOLD_MS_TOUCH = 250;    // 触屏端长按热区判定阈值（毫秒）
    const SEEK_STEP = 5;          // 短按方向键快进秒数（与 ArtPlayer 默认一致）
    const MAX_DURATION = 86400;   // 单项时长上限：24 小时

    // —— 片头 / 片尾自动跳过的时序常量（v3.5.0）——
    const SKIP_ARM_MS = 600;      // 元数据就绪后的静置期：避开播放器的自动定位 / 续播
    const SKIP_PATROL_MS = 250;   // 巡检间隔：timeupdate 不可靠时（暂停 / 卡顿）的兜底触发源
    const SKIP_MAX_TRIES = 8;     // 单轮最多尝试次数，防止 seek 失效时反复定位
    const SKIP_WINDOW_MS = 20000; // 元数据就绪后的最长尝试窗口
    const SKIP_TOL = 0.5;         // 时间容差（秒）
    const USER_SEEK_MS = 900;     // 「进度条手势 → seeking」的关联窗口，用于区分用户拖动

    const IS_TOP = (w.top === w.self);

    function GMget(key, def) {
        try {
            const v = GM_getValue(key);
            return (v === undefined || v === null) ? def : v;
        } catch (e) {
            return def;
        }
    }

    function GMset(key, value) {
        try { GM_setValue(key, value); } catch (e) {}
    }

    function clampRate(v) {
        v = Number(v);
        if (!isFinite(v) || v <= 0) return 1;
        v = Math.round(v * 100) / 100;                       // 避免浮点尾巴
        return Math.min(RATE_MAX, Math.max(RATE_MIN, v));
    }

    function normSeconds(v) {
        v = Number(v);
        if (!isFinite(v) || v <= 0) return 0;                 // 负数 / 0 / 空 → 关闭
        return Math.min(MAX_DURATION, Math.round(v));
    }

    function fmtDuration(sec) {
        sec = Math.max(0, Math.round(Number(sec) || 0));
        const hh = Math.floor(sec / 3600);
        const mm = Math.floor((sec % 3600) / 60);
        const ss = sec % 60;
        let out = '';
        if (hh) out += hh + '小时';
        if (mm) out += mm + '分';
        if (ss || !out) out += ss + '秒';
        return out;
    }

    function fmtRate(r) {
        return String(Math.round(Number(r) * 100) / 100);
    }

    // 倍速文案：与站内自带「倍速」控件保持一致（整数补一位小数，如 2 → 2.0）
    function rateText(r) {
        const v = clampRate(r);
        return (v % 1 === 0) ? v.toFixed(1) : String(v);
    }

    function isTyping(el) {
        if (!el || el.nodeType !== 1) return false;
        const tag = el.tagName;
        return tag === 'INPUT' || tag === 'TEXTAREA' || tag === 'SELECT' || el.isContentEditable === true;
    }

    function addStyle(css, onceKey) {
        try {
            if (typeof GM_addStyle === 'function') { GM_addStyle(css); return; }
        } catch (e) {}
        const apply = function () {
            const host = d.head || d.documentElement;
            if (!host) return false;
            try {
                const st = d.createElement('style');
                if (onceKey) st.setAttribute('data-mtyy', onceKey);
                st.textContent = css;
                host.appendChild(st);
                return true;
            } catch (e) {
                return false;
            }
        };
        if (!apply()) d.addEventListener('DOMContentLoaded', apply, { once: true });
    }

    // ---------- 配置读写（GM 存储 → 刷新/换页/换集后依然生效） ----------
    function loadPlayerCfg() {
        let raw = GMget(SETTINGS_KEY, null);
        let o = null;
        if (raw) {
            try { o = typeof raw === 'string' ? JSON.parse(raw) : raw; } catch (e) { o = null; }
        }
        if (!o || typeof o !== 'object') o = {};
        return {
            intro: normSeconds(o.intro),
            outro: normSeconds(o.outro),
            rate: clampRate(o.rate === undefined ? 1 : o.rate),
            lastDuration: normSeconds(o.lastDuration)
        };
    }

    let playerCfg = loadPlayerCfg();

    function savePlayerCfg() {
        GMset(SETTINGS_KEY, JSON.stringify(playerCfg));
    }

    function reloadPlayerCfg() {
        playerCfg = loadPlayerCfg();
        return playerCfg;
    }

    // ---------- 「x分x秒」/ 纯秒数 解析 ----------
    function parseDurationInput(text) {
        const raw = String(text == null ? '' : text).trim();
        if (raw === '') return { ok: true, seconds: 0, empty: true };   // 留空 = 关闭

        const s = raw
            .replace(/[０-９]/g, function (c) { return String.fromCharCode(c.charCodeAt(0) - 65248); })
            .replace(/：/g, ':')
            .replace(/\s+/g, '');

        if (/[-−﹣—]/.test(s)) return { ok: false, error: '不能填写负数' };
        if (!/^[0-9分秒ms:.]+$/i.test(s)) {
            return { ok: false, error: '含有非法字符，只支持「分/秒」写法（如 1分30秒）或纯秒数（如 90）' };
        }

        let seconds = null;
        let m = s.match(/^(\d+(?:\.\d+)?)分(?:(\d+(?:\.\d+)?)秒?)?$/);     // 1分 / 1分30 / 1分30秒 / 1.5分
        if (m) seconds = parseFloat(m[1]) * 60 + (m[2] ? parseFloat(m[2]) : 0);
        if (seconds === null) {
            m = s.match(/^(\d{1,3}):(\d{1,2})$/);                          // 1:30
            if (m) seconds = parseInt(m[1], 10) * 60 + parseInt(m[2], 10);
        }
        if (seconds === null) {
            m = s.match(/^(\d+(?:\.\d+)?)(?:秒|s)?$/i);                     // 90 / 90秒 / 90s
            if (m) seconds = parseFloat(m[1]);
        }
        if (seconds === null || !isFinite(seconds)) {
            return { ok: false, error: '格式无法识别，请填写如「1分30秒」「90」这样的形式' };
        }
        if (seconds < 0) return { ok: false, error: '不能填写负数' };
        if (seconds > MAX_DURATION) return { ok: false, error: '不能超过 24 小时（86400 秒）' };

        const val = Math.round(seconds);
        return { ok: true, seconds: val, empty: val === 0 };
    }

    // durationHint > 0 时执行「不得超过视频总时长」校验
    function validateDurationField(label, text, durationHint) {
        const p = parseDurationInput(text);
        if (!p.ok) return { ok: false, error: '「' + label + '」' + p.error };
        if (!p.empty && durationHint > 0 && p.seconds > durationHint) {
            return {
                ok: false,
                error: '「' + label + '」' + fmtDuration(p.seconds) + ' 超过了视频总时长 ' +
                       fmtDuration(durationHint) + '，已拒绝保存'
            };
        }
        return { ok: true, seconds: p.seconds, empty: p.empty };
    }

    // ================================================================
    // ========== 模块 C：播放器增强（跳过片头片尾 + 记忆倍速） ==========
    // ================================================================

    let rateHookInstalled = false;
    let lastGestureAt = 0;

    // 记录用户交互时刻，用于区分"用户主动调倍速"和"播放器内部重置倍速"
    ['pointerdown', 'mousedown', 'touchstart', 'keydown', 'click'].forEach(function (t) {
        d.addEventListener(t, function () { lastGestureAt = Date.now(); },
            { capture: true, passive: true });
    });

    // 只把「进度条上的手势」算作用户拖动，避免播放器自动定位被误判成用户拖动
    // （点击画面暂停、点设置按钮等都会触发全局手势，但不会改变播放位置）
    let lastSeekGestureAt = 0;
    const SEEK_CTL_SEL = '.art-progress,.art-progress-inner,.art-progress-loaded,.art-progress-played,' +
        '.art-progress-highlight,.art-progress-tip,.art-control-progress,[class*="progress"],' +
        '.art-control-time,.art-time,.art-control-time-duration';
    function isSeekCtl(el) {
        try {
            if (!el || el.nodeType !== 1) return false;
            if (typeof el.closest === 'function') return !!el.closest(SEEK_CTL_SEL);
        } catch (e) {}
        return false;
    }
    ['pointerdown', 'mousedown', 'touchstart'].forEach(function (t) {
        d.addEventListener(t, function (e) {
            if (isSeekCtl(e.target)) lastSeekGestureAt = Date.now();
        }, { capture: true, passive: true });
    });

    const PLAYER_CSS = [
        /* 移动端：播放区两侧的透明长按加速热区（不铺底、不遮画面、不拦截手势） */
        '.mtyy-zones{position:absolute;inset:0;z-index:15;pointer-events:none;}',
        '.mtyy-zone{position:absolute;top:0;bottom:0;width:22%;background:transparent;',
        ' pointer-events:none;}',
        '.mtyy-zone-left{left:0;}',
        '.mtyy-zone-right{right:0;}',
        /* 长按提示（热区无图标，靠这个提示告知位置） */
        '.mtyy-boost-hint{position:absolute;left:50%;bottom:18%;transform:translateX(-50%);z-index:40;',
        ' padding:7px 14px;border-radius:999px;background:rgba(0,0,0,.55);color:#fff;white-space:nowrap;',
        ' font:500 12px/1.4 system-ui,-apple-system,"PingFang SC","Microsoft YaHei",sans-serif;',
        ' letter-spacing:.5px;pointer-events:none;opacity:1;transition:opacity .4s ease;}',
        '.mtyy-boost-hint.mtyy-boost-hint-hide{opacity:0;}',
        /* 抑制 iOS/部分浏览器的长按原生菜单（视频信息 / 拷贝等） */
        '.art-video-player video{-webkit-touch-callout:none;-webkit-user-select:none;user-select:none;}',

        /* 播放器「设置」面板里的行（沿用 ArtPlayer 的行高与配色变量） */
        '.mtyy-set-row{display:flex;align-items:center;justify-content:space-between;gap:6px;',
        ' width:100%;height:100%;padding:0 5px;box-sizing:border-box;overflow:hidden;}',
        '.mtyy-set-left{display:flex;align-items:center;gap:5px;flex:0 0 auto;',
        ' font-size:12px;line-height:1;color:inherit;}',
        '.mtyy-set-left svg{display:block;}',
        '.mtyy-set-input{flex:1 1 auto;min-width:0;max-width:118px;height:24px;padding:0 6px;',
        ' border-radius:5px;background:#ffffff1f;border:1px solid #ffffff33;color:var(--art-font-color,#fff);',
        ' font-size:12px;line-height:1;text-align:center;outline:none;box-sizing:border-box;}',
        '.mtyy-set-input::placeholder{color:#ffffff66;font-size:11px;}',
        '.mtyy-set-input:focus{border-color:var(--art-theme,#FF6429);background:#ffffff2e;}',
        '.mtyy-set-input-bad,.mtyy-set-input-bad:focus{border-color:#ff5b5b!important;background:#ff5b5b33!important;}',
        '.mtyy-set-row-bad{background:#ff5b5b1f;}'
    ].join('\n');

    function showFallbackToast(msg) {
        try {
            const host = d.body || d.documentElement;
            if (!host) return;
            let el = d.getElementById('mtyy-toast');
            if (!el) {
                el = d.createElement('div');
                el.id = 'mtyy-toast';
                el.style.cssText = 'position:fixed;left:50%;bottom:12%;transform:translateX(-50%);' +
                    'z-index:2147483000;padding:8px 16px;border-radius:8px;background:rgba(0,0,0,.78);' +
                    'color:#fff;font:500 14px/1.5 system-ui,-apple-system,"PingFang SC","Microsoft YaHei",sans-serif;' +
                    'pointer-events:none;opacity:0;transition:opacity .18s;';
                host.appendChild(el);
            }
            el.textContent = msg;
            el.style.opacity = '1';
            w.clearTimeout(showFallbackToast._t);
            showFallbackToast._t = w.setTimeout(function () { el.style.opacity = '0'; }, 1800);
        } catch (e) {}
    }

    // ---------- 播放器内设置项用的图标与倍速档位（与站内「倍速」控件选项保持一致） ----------
    const ICON_CLOCK = '<svg viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor"' +
        ' stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round">' +
        '<circle cx="12" cy="12" r="9"></circle><path d="M12 7.5V12l3.2 2"></path></svg>';
    const ICON_SPEED = '<svg viewBox="0 0 24 24" width="18" height="18" fill="none" stroke="currentColor"' +
        ' stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round">' +
        '<path d="M4 18a9 9 0 1 1 16 0"></path><path d="M12 14.2l4.2-4.2"></path></svg>';

    const RATE_OPTIONS = [0.5, 0.75, 1, 1.25, 1.5, 2, 3, 4];

    // 是否「触屏为主」的设备：决定加速交互形态
    // 触屏（手机/平板）→ 播放区两侧透明热区；鼠标/触控板电脑 → 控制栏按钮 + 键盘
    const TOUCH_OK = (function () {
        try {
            if (typeof w.matchMedia === 'function') {
                if (w.matchMedia('(pointer: coarse)').matches) return true;   // 主输入为手指
            } else if (w.navigator && w.navigator.maxTouchPoints > 0) {
                return true;
            }
        } catch (e) {}
        const ua = (w.navigator && w.navigator.userAgent) || '';
        return /android|iphone|ipad|ipod|mobile|harmonyos|windows phone|miuibrowser/i.test(ua);
    })();

    // 长按结束后吞掉随之而来的那次 click，避免误触发播放器的「点击暂停/播放」
    // 注意：仅吞一次，且新的触摸开始时会立即作废，绝不吞用户真正的点击
    function suppressNextClick() {
        suppressNextClick.cancel();
        const swallow = function (ev) {
            suppressNextClick.cancel();
            if (ev.preventDefault) ev.preventDefault();
            if (ev.stopImmediatePropagation) ev.stopImmediatePropagation();
            ev.stopPropagation();
        };
        suppressNextClick._swallow = swallow;
        d.addEventListener('click', swallow, true);
        suppressNextClick._t = w.setTimeout(function () { suppressNextClick.cancel(); }, 700);
    }
    suppressNextClick.cancel = function () {
        if (suppressNextClick._swallow) {
            d.removeEventListener('click', suppressNextClick._swallow, true);
            suppressNextClick._swallow = null;
        }
        if (suppressNextClick._t) {
            w.clearTimeout(suppressNextClick._t);
            suppressNextClick._t = null;
        }
    };

    function rateKey(r) {
        return String(r).replace('.', '_');
    }

    // 用户主动选倍速：立即生效，并由倍速 hook 持久化为记忆值
    function applyUserRate(r) {
        const val = clampRate(r);
        lastGestureAt = Date.now();          // 标记为用户主动调整
        if (Player.art) {
            try { Player.art.playbackRate = val; return; } catch (e) {}
        }
        Player.writeRate(val);
    }

    // ---------- 倍速拦截：所有倍速写入都会经过这里（含站内自定义倍速控件） ----------
    function installRateHook() {
        if (rateHookInstalled) return;
        const proto = w.HTMLMediaElement && w.HTMLMediaElement.prototype;
        if (!proto) return;
        const desc = Object.getOwnPropertyDescriptor(proto, 'playbackRate');
        if (!desc || !desc.set) return;
        rateHookInstalled = true;

        Object.defineProperty(proto, 'playbackRate', {
            configurable: true,
            enumerable: desc.enumerable,
            get: function () { return desc.get.call(this); },
            set: function (value) {
                const raw = Number(value);
                const wanted = (isFinite(raw) && raw > 0) ? raw : 1;
                const fixed = clampRate(wanted);           // 上下限 0.25x - 4x，异常值直接收敛
                const fromScript = Player.internal;

                desc.set.call(this, fixed);                // 真正写入 <video>

                if (fromScript) return;
                if (Player.video && this !== Player.video) return;

                if (wanted !== fixed) log('倍速超范围已收敛：' + wanted + ' → ' + fixed);

                Player.baseRate = fixed;
                const userDriven = Player.boostOn || (Date.now() - lastGestureAt < 2000);
                if (userDriven && playerCfg.rate !== fixed) {
                    playerCfg.rate = fixed;                // 每次调整都持久保存
                    savePlayerCfg();
                    log('已记住倍速 ' + rateText(fixed) + 'x');
                }
                Player.syncSiteRateControl();              // 控制栏文案与当前倍速保持一致
                if (Player.boostOn) {
                    // 临时加速期间用户又改了基准倍速：更新基准并继续保持加速
                    Player.writeRate(clampRate(fixed * HOLD_MULT));
                }
            }
        });
        log('已接管 HTMLMediaElement.playbackRate');
    }

    const Player = {
        art: null,
        video: null,
        bound: null,
        duration: 0,
        token: 0,
        // —— 片头 / 片尾跳过状态机（v3.5.0）——
        armedAt: 0,             // 本轮武装时间戳（0 = 未就绪）
        skipArmed: false,       // 已过静置期，允许执行跳过
        introDone: true,
        outroDone: true,
        userSeeked: false,      // 用户在进度条上拖过 → 尊重用户，本轮不再自动跳片头
        skipTries: 0,           // 本轮已尝试次数
        skipApplied: false,     // 片头已真正跳过去（判断是否需要重新武装）
        skipDeadline: 0,        // 本轮尝试的截止时间
        skipPatrol: null,       // 巡检定时器（timeupdate 之外的兜底触发源）
        pendingSeekTo: -1,      // 脚本刚发起的定位目标，用于校验是否生效
        pendingSeekAt: 0,       // 上面那次定位的时间戳（超过 3s 就不再认领）
        endedAt: 0,             // 上一次播放结束的时间戳，用于识别「站点自动切下一集」
        warnedShort: false,
        internal: false,        // 脚本自身写入倍速的标记
        internalSeekUntil: 0,   // 脚本自身定位的时间窗，用于区分用户拖动
        baseRate: 1,
        boostOn: false,
        badge: null,
        settingsAdded: false,
        settingInputs: {},
        rateRow: null,
        rateControlEl: null,        // 站内「倍速」控件里显示倍速文案的节点

        // -------- 接入 --------
        bindArt: function (art) {
            if (!art || this.art === art) return;
            this.art = art;
            this.settingsAdded = false;
            this.settingInputs = {};
            this.rateRow = null;
            this.rateControlEl = null;
            if (this.zoneWrap && this.zoneWrap.parentNode) this.zoneWrap.parentNode.removeChild(this.zoneWrap);
            this.zoneWrap = null;
            this.sideZones = false;
            try { this.setupBoostUI(art); } catch (e) {}
            try { this.addSettingsPanel(art); } catch (e) { log('注入播放器设置项失败', e); }
            this.syncSiteRateControl();          // 控制栏倍速文案与记忆倍速对齐
            log('已接入 ArtPlayer 实例');
        },

        bindVideo: function (video) {
            if (!video) return;
            if (this.bound === video) return;
            if (this.bound && this.bound !== video) log('视频元素已更换，重新绑定');
            this.bound = video;
            this.video = video;
            const self = this;
            // 覆盖所有会改变播放位置 / 时长的时机：换源、时长后到、定位完成、恢复播放
            ['loadedmetadata', 'durationchange', 'timeupdate', 'seeking', 'seeked',
             'canplay', 'playing', 'emptied', 'loadstart', 'ended'].forEach(function (t) {
                video.addEventListener(t, function () { self.onMediaEvent(t); }, { passive: true });
            });
            installRateHook();
            if (video.readyState >= 1) this.onLoadedMetadata();
            // 4 秒后仍未接入 ArtPlayer，说明是其他播放器实现 → 上兜底交互（触屏两侧热区 / 鼠标悬浮按钮）
            w.setTimeout(function () {
                if (!Player.art && Player.video === video) Player.setupBoostUI(null);
            }, 4000);
            log('已绑定视频元素');
        },

        onMediaEvent: function (type) {
            switch (type) {
                case 'loadedmetadata':  this.onLoadedMetadata(); break;
                case 'emptied':
                case 'loadstart':       this.onSourceReset(); break;
                case 'durationchange':  this.onDurationChange(); break;
                case 'timeupdate':      this.onTimeUpdate(); break;
                case 'seeking':         this.onSeeking(); break;
                case 'seeked':          this.trySkip('seeked'); break;
                case 'canplay':         this.applySavedRate(); this.trySkip('canplay'); break;
                case 'playing':         this.trySkip('playing'); break;
                case 'ended':           this.onEnded(); break;
            }
        },

        // 当前视频总时长：优先取媒体元素的实时值（HLS 时长可能后到）
        currentDuration: function () {
            const v = this.video;
            if (v && isFinite(v.duration) && v.duration > 0) return v.duration;
            return (isFinite(this.duration) && this.duration > 0) ? this.duration : 0;
        },

        // ============================================================
        //  片头 / 片尾自动跳过（v3.5.0 重写，解决「间歇性失效」）
        // ------------------------------------------------------------
        //  原实现的两处致命点：
        //    ① 武装靠一个 1.2s 的一次性定时器，换源 / durationchange 会把 token 顶掉，
        //       定时器永不生效 → skipArmed 永远 false → 整集都不跳；
        //    ② onSeeking 无条件 introDone = true，播放器自己的定位（HLS 首帧对齐、
        //       自动续播、换清晰度）会被当成用户拖动 → 片头跳过被一次性作废。
        //  新实现：
        //    A 武装条件由「状态」判定（armedAt + 静置期），不依赖定时器；
        //    B 统一入口 trySkip()，由 timeupdate / seeked / canplay / playing /
        //      durationchange / 配置热更新 / 250ms 巡检 多路驱动；
        //    C 巡检兜底：视频暂停（移动端自动播放被拦截）时浏览器不派发 timeupdate，
        //       靠巡检在 20s 窗口内持续尝试；
        //    D 跳过落点校验 + 最多 8 次重试，seek 被播放器拉回也不会就此放弃；
        //    E 只有「进度条上的真实手势」才算用户拖动，播放器内部定位不误杀。
        // ============================================================
        applySavedRate: function () {
            const v = this.video;
            if (!v) return;
            this.syncSiteRateControl();               // 先让控制栏显示记忆倍速
            if (this.boostOn) return;
            const want = playerCfg.rate;
            const cur = (this.art && typeof this.art.playbackRate === 'number')
                ? this.art.playbackRate : v.playbackRate;
            if (Math.abs(cur - want) < 0.001) return;
            if (this.art) {
                try { this.art.playbackRate = want; return; } catch (e) {}
            }
            this.writeRate(want);
        },

        writeRate: function (r) {
            if (!this.video) return;
            this.internal = true;
            try { this.video.playbackRate = clampRate(r); } finally { this.internal = false; }
        },

        reportDuration: function () {
            const dur = this.duration;
            if (!dur || !isFinite(dur)) return;
            const r = Math.round(dur);
            if (playerCfg.lastDuration === r) return;
            playerCfg.lastDuration = r;
            savePlayerCfg();
        },

        // -------- 定位 --------
        seekTo: function (t) {
            const v = this.video;
            if (!v) return;
            this.internalSeekUntil = Date.now() + 250;
            this.pendingSeekTo = t;
            this.pendingSeekAt = Date.now();
            try { v.currentTime = Math.max(0, t); } catch (e) {}
        },

        seekBy: function (sec) {
            const v = this.video;
            if (!v) return;
            const dur = (isFinite(v.duration) && v.duration > 0) ? v.duration : 0;
            let target = v.currentTime + sec;
            if (dur) target = Math.min(target, Math.max(0, dur - 0.2));
            this.seekTo(target);
        },

        onLoadedMetadata: function () {
            const v = this.video;
            if (!v) return;
            this.armSkip('loadedmetadata', true);
            log('视频就绪：时长 ' + fmtDuration(this.duration) +
                '，片头 ' + fmtDuration(playerCfg.intro) +
                '，片尾 ' + fmtDuration(playerCfg.outro) +
                '，记忆倍速 ' + fmtRate(playerCfg.rate) + 'x');
        },

        // 换源 / 重新加载：清空本轮状态，等 loadedmetadata 重新武装
        onSourceReset: function () {
            this.skipArmed = false;
            this.introDone = false;
            this.outroDone = false;
            this.skipTries = 0;
            this.skipApplied = false;
            this.pendingSeekTo = -1;
            this.pendingSeekAt = 0;
            this.userSeeked = false;      // 「用户拖过进度条」只对当前这一集有效
            this.armedAt = 0;
            this.stopPatrol();
        },

        // 开一轮「可跳过窗口」
        armSkip: function (reason, full) {
            const v = this.video;
            if (!v) return;
            this.token++;
            this.duration = isFinite(v.duration) ? v.duration : this.duration;
            this.introDone = false;
            this.outroDone = false;
            this.skipTries = 0;
            this.skipApplied = false;
            this.pendingSeekTo = -1;
            this.pendingSeekAt = 0;
            this.userSeeked = false;      // 每集独立：上一集拖过进度条不影响这一集
            this.endedAt = 0;
            this.warnedShort = false;
            this.skipArmed = false;
            this.armedAt = Date.now();
            this.skipDeadline = this.armedAt + SKIP_WINDOW_MS;
            if (full) {
                this.baseRate = playerCfg.rate;
                this.applySavedRate();          // 播放器就绪即套用上次记忆的倍速
                this.showBoostHint();           // 触屏设备每次播放提示一次长按加速
                this.reportDuration();
            }
            this.startPatrol();
            this.trySkip(reason || 'arm');
        },

        // 时长后到（HLS）/ 换清晰度后重新武装：不动倍速与提示，避免重复打扰
        rearmSkip: function (reason) {
            if (this.userSeeked || this.skipApplied) return;
            if (this.armedAt && Date.now() - this.armedAt < 2000) return;   // 刚武装过，防止抖动
            this.skipArmed = false;
            this.skipTries = 0;
            this.introDone = false;
            this.armedAt = Date.now();
            this.skipDeadline = this.armedAt + SKIP_WINDOW_MS;
            this.startPatrol();
            log('[' + (reason || 'rearm') + '] 时长/源变化，重新武装片头跳过');
            this.trySkip(reason || 'rearm');
        },

        // 明确的触发前置条件（全部满足才允许执行跳过）
        canSkipNow: function () {
            const v = this.video;
            if (!v || !v.isConnected) return false;
            if (v.error) return false;
            if (v.readyState < 1) return false;                        // 元数据未到
            if (v.seeking) return false;                               // 定位进行中，不抢
            return true;
        },

        // -------- 巡检：timeupdate 之外的兜底触发源 --------
        startPatrol: function () {
            this.stopPatrol();
            const self = this;
            this.skipPatrol = w.setInterval(function () {
                if (!self.shouldPatrol()) { self.stopPatrol(); return; }
                self.trySkip('patrol');
            }, SKIP_PATROL_MS);
        },

        stopPatrol: function () {
            if (this.skipPatrol) { w.clearInterval(this.skipPatrol); this.skipPatrol = null; }
        },

        shouldPatrol: function () {
            const intro = playerCfg.intro, outro = playerCfg.outro;
            if (intro <= 0 && outro <= 0) return false;
            if (!this.video || !this.video.isConnected) return false;
            if ((intro <= 0 || this.introDone) && (outro <= 0 || this.outroDone)) return false;
            if (this.userSeeked && (outro <= 0 || this.outroDone)) return false;
            if (Date.now() > this.skipDeadline) return false;
            return true;
        },

        // -------- 唯一的跳过判定入口：幂等，可被任意事件源反复调用 --------
        trySkip: function (reason) {
            const v = this.video;
            if (!v || !v.isConnected) return;
            const intro = playerCfg.intro, outro = playerCfg.outro;
            if (intro <= 0 && outro <= 0) return;
            if (!this.canSkipNow()) return;                            // 未到触发条件 → 下一路再试
            if (!this.skipArmed) {
                this.skipArmed = true;
                log('跳过逻辑已武装（' + (reason || '?') + '）');
            }

            const dur = this.currentDuration();
            if (!dur) return;                                          // 直播 / 时长未知 → 继续等

            // 兜底武装：万一 loadedmetadata 因故没派发（HLS 直出 / 事件被其它脚本拦掉），
            // 只要时长已知就自行开一轮，绝不出现「永远没武装」的死路
            if (!this.armedAt) {
                this.armedAt = Date.now();
                this.skipDeadline = this.armedAt + SKIP_WINDOW_MS;
                this.startPatrol();
            }
            if (Date.now() < this.armedAt + SKIP_ARM_MS) return;       // 静置期：避开播放器自动定位

            // 边界：总时长比「片头 + 片尾」还短 → 不触发跳过
            if (intro > 0 && outro > 0 && dur <= intro + outro) {
                if (!this.warnedShort) {
                    this.warnedShort = true;
                    this.toast('视频总时长 ' + fmtDuration(dur) + ' 小于片头+片尾之和，已停用跳过');
                }
                this.stopPatrol();
                return;
            }

            // 兜底自检：从没真正跳过片头（skipApplied=false），位置却还停在片头区间内，
            // 也没有用户拖动 —— 说明状态被意外置位了，这里复位重来。
            // 有了它，任何未知原因造成的「片头卡死」都会在下一个 timeupdate / 巡检里自愈。
            if (intro > 0 && this.introDone && !this.skipApplied && !this.userSeeked &&
                dur > intro + 1 && v.currentTime < intro - SKIP_TOL) {
                log('片头状态异常（从未跳过却在片头区间内），复位重来');
                this.introDone = false;
                this.skipTries = 0;
            }

            // —— 片头 ——
            if (intro > 0 && dur > intro + 1 && !this.introDone && !this.userSeeked) {
                if (v.currentTime < intro - SKIP_TOL) {
                    if (this.skipTries >= SKIP_MAX_TRIES || Date.now() > this.skipDeadline) {
                        this.introDone = true;                         // 反复失败 → 本轮放弃，不再打扰
                        log('片头跳过重试已达上限，本轮放弃');
                    } else {
                        this.doSkipIntro(intro);
                        return;
                    }
                } else {
                    this.introDone = true;                             // 当前位置已过片头区间
                }
            }

            // —— 片尾 ——（跳到结尾触发 ended，站点的「下一集」逻辑照常接管）
            if (outro > 0 && !this.outroDone && dur - intro > SKIP_TOL) {
                if (dur - v.currentTime <= outro) {
                    this.outroDone = true;
                    this.seekTo(Math.max(0, dur - 0.15));
                    this.toast('已跳过片尾 ' + fmtDuration(outro));
                }
            }

            if (!this.shouldPatrol()) this.stopPatrol();
        },

        doSkipIntro: function (intro) {
            const v = this.video;
            this.skipTries++;
            this.pendingSeekTo = intro;
            this.skipApplied = true;
            this.introDone = true;
            this.seekTo(intro);
            this.toast('已跳过片头 ' + fmtDuration(intro));
            log('已跳过片头 → ' + fmtDuration(intro) + '（第 ' + this.skipTries + ' 次尝试）');
            // 落点校验：HLS 未缓冲到位时播放器可能把位置拉回，这里确认真的跳过去了，
            // 没跳过去就复位状态，交给巡检 / 下一次 timeupdate 重试
            const tok = this.token;
            w.setTimeout(function () {
                if (Player.token !== tok || Player.userSeeked) return;
                const vv = Player.video;
                if (!vv || !vv.isConnected || vv.seeking) return;
                if (vv.currentTime < intro - SKIP_TOL &&
                    Player.skipTries < SKIP_MAX_TRIES && Date.now() < Player.skipDeadline) {
                    Player.introDone = false;
                    Player.skipApplied = false;
                    Player.pendingSeekTo = -1;
                    Player.startPatrol();
                    log('片头跳转未生效，准备重试');
                }
            }, 1200);
        },

        // HLS 的时长常常晚于 loadedmetadata 才确定
        onDurationChange: function () {
            const v = this.video;
            if (!v) return;
            const nd = (isFinite(v.duration) && v.duration > 0) ? v.duration : 0;
            const prev = this.duration;
            if (nd && nd !== prev) {
                this.duration = nd;
                this.reportDuration();
                log('时长更新为 ' + fmtDuration(nd));
            }
            const intro = playerCfg.intro;

            // 换集：hls.loadSource 方式切下一集时**不会**派发 emptied / loadedmetadata，
            // 只有 durationchange。判据 = 上一集刚 ended（或时长明显变化）+ 进度回到开头。
            // 这种情况必须完整重开一轮，否则 skipApplied 一直为真 → 之后每集片头都不跳。
            const justEnded = this.endedAt && (Date.now() - this.endedAt < 8000);
            const looksNewSource = !this.userSeeked && v.currentTime < 5 &&
                (justEnded || !prev || !nd || Math.abs(nd - prev) > 1);
            if (looksNewSource && (this.skipApplied || this.introDone)) {
                log('检测到新片源（换集），重新开一轮');
                this.armSkip('durationchange', true);
                return;
            }

            // 片头还没真正跳过去，而当前位置仍在片头区间内 → 重新开一轮
            // （rearmSkip 内部有 2s 防抖，可能直接返回，所以后面必须再无条件试一次）
            if (intro > 0 && !this.userSeeked && !this.skipApplied &&
                v.currentTime < intro - SKIP_TOL && (this.introDone || !this.skipArmed)) {
                this.rearmSkip('durationchange');
            }
            this.trySkip('durationchange');
        },

        onSeeking: function () {
            const v = this.video;
            if (!v) return;
            if (Date.now() < this.internalSeekUntil) {          // 脚本自身发起的定位
                this.pendingSeekTo = -1;
                return;
            }
            // HLS 的 seeking 可能延迟派发，落在 250ms 窗口之外：用落点认领回来
            if (this.pendingSeekTo >= 0 && Date.now() - this.pendingSeekAt < 3000) {
                const mine = Math.abs(v.currentTime - this.pendingSeekTo) < 2;
                this.pendingSeekTo = -1;
                if (mine) return;
            } else if (this.pendingSeekTo >= 0) {
                this.pendingSeekTo = -1;
            }
            const dur = this.currentDuration();
            const intro = playerCfg.intro;
            const t = v.currentTime;
            if (Date.now() - lastSeekGestureAt < USER_SEEK_MS) {
                lastSeekGestureAt = 0;                          // 一次手势只认领一次，别误伤后续自动定位
                // 用户在进度条上拖动：尊重用户选择，本轮不再自动跳片头
                this.userSeeked = true;
                this.introDone = true;
                if (playerCfg.outro > 0 && dur > 0 && (dur - t) <= playerCfg.outro + SKIP_TOL) {
                    this.outroDone = true;
                }
                if (this.shouldPatrol()) this.startPatrol(); else this.stopPatrol();
                log('用户拖动至 ' + Math.round(t) + 's，跳过逻辑不再介入');
                return;
            }
            // 播放器自身定位（HLS 首帧对齐 / 自动续播 / 换清晰度）：不禁用片头跳过，
            // 只按落点刷新状态，是否要跳仍由 trySkip 正常判定
            if (intro > 0 && t >= intro - SKIP_TOL) this.introDone = true;
            log('播放器内部定位至 ' + Math.round(t) + 's（不影响片头跳过）');
        },

        onTimeUpdate: function () {
            this.trySkip('timeupdate');
        },

        onEnded: function () {
            this.stopBoost();
            this.introDone = true;
            this.outroDone = true;
            this.endedAt = Date.now();          // 供「站点自动切下一集」识别用
            this.internalSeekUntil = 0;         // 片尾定位的残留不要带进下一集
            this.pendingSeekTo = -1;
            this.stopPatrol();
        },

        // 配置热更新：保存后立即对当前播放生效（不等下一次 timeupdate）
        onCfgChange: function () {
            const v = this.video;
            if (!v) return;
            const dur = this.currentDuration();
            const intro = playerCfg.intro;
            const outro = playerCfg.outro;
            this.warnedShort = false;

            if (intro <= 0) {
                this.introDone = true;
            } else if (this.userSeeked || v.currentTime >= intro - SKIP_TOL) {
                this.introDone = true;
            } else {
                // 新的片头还没过 → 立即允许跳过，不等静置期
                this.introDone = false;
                this.skipTries = 0;
                this.skipApplied = false;
                if (!this.armedAt) this.armedAt = Date.now();
                this.skipArmed = true;
                this.skipDeadline = Math.max(this.skipDeadline, Date.now() + SKIP_WINDOW_MS);
            }

            if (outro <= 0) this.outroDone = true;
            else this.outroDone = !(dur > 0 && (dur - v.currentTime) > outro);
            // 若当前已处于片尾区间内，不强制跳出，避免误切下一集

            this.startPatrol();
            this.trySkip('cfg');
            log('配置已热更新：片头 ' + fmtDuration(intro) + '，片尾 ' + fmtDuration(outro));
        },

        // 每次播放给一次「长按可加速」提示（热区没有图标，靠提示告知位置）
        showBoostHint: function () {
            if (!TOUCH_OK) return;
            const host = (this.art && this.art.template && this.art.template.$player) ||
                (this.video && this.video.parentElement) || d.body;
            if (!host) return;
            let el = this.hintEl;
            if (!el || !el.isConnected) {
                el = d.createElement('div');
                el.className = 'mtyy-boost-hint';
                el.textContent = '长按画面左右两侧 · 临时 2 倍速';
                host.appendChild(el);
                this.hintEl = el;
            }
            el.classList.remove('mtyy-boost-hint-hide');
            if (this._hintT) w.clearTimeout(this._hintT);
            this._hintT = w.setTimeout(function () { Player.hideBoostHint(); }, 4500);
        },

        hideBoostHint: function () {
            if (!this.hintEl || !this.hintEl.isConnected) return;
            this.hintEl.classList.add('mtyy-boost-hint-hide');
        },

        // -------- 临时加速 --------
        startBoost: function () {
            const v = this.video;
            if (!v || !v.duration || isNaN(v.duration)) return;
            if (this.boostOn) return;
            const target = clampRate(this.baseRate * HOLD_MULT);
            if (target <= this.baseRate) {
                this.toast('当前 ' + rateText(this.baseRate) + 'x 已达上限 ' + rateText(RATE_MAX) + 'x');
                return;
            }
            this.boostOn = true;
            this.hideBoostHint();            // 已经会用了就不用再提示
            this.writeRate(target);
            this.showBadge(rateText(target) + 'x');
            this.toast('临时加速 ' + rateText(this.baseRate) + 'x → ' + rateText(target) + 'x');
        },

        stopBoost: function () {
            if (!this.boostOn) return;
            this.boostOn = false;
            this.writeRate(this.baseRate);
            this.hideBadge();
        },

        showBadge: function (text) {
            const el = this.ensureBadge();
            if (!el) return;
            el.textContent = '▶▶ ' + text;
            el.style.display = 'block';
        },

        hideBadge: function () {
            if (this.badge && this.badge.isConnected) this.badge.style.display = 'none';
        },

        ensureBadge: function () {
            if (this.badge && this.badge.isConnected) return this.badge;
            const host = (this.art && this.art.template && this.art.template.$player) || d.body;
            if (!host) return null;
            const el = d.createElement('div');
            el.className = 'mtyy-rate-badge';
            el.style.cssText = 'position:absolute;left:50%;top:14%;transform:translateX(-50%);z-index:9999;' +
                'display:none;padding:6px 14px;border-radius:999px;background:rgba(0,0,0,.66);color:#fff;' +
                'font:600 14px/1.4 system-ui,-apple-system,"PingFang SC","Microsoft YaHei",sans-serif;' +
                'letter-spacing:.5px;pointer-events:none;';
            try { host.appendChild(el); } catch (e) { return null; }
            this.badge = el;
            return el;
        },

        toast: function (msg) {
            log('[提示]', msg);
            if (this.art && this.art.notice) {
                try { this.art.notice.show = msg; return; } catch (e) {}
            }
            showFallbackToast(msg);
        },

        // ============================================================
        // 把播放增强的设置项注入播放器自带的「设置」面板（⚙）
        // 与「画面比例 / 画面翻转」等原生项同排、同样的交互
        // ============================================================
        addSettingsPanel: function (art) {
            if (!art || !art.setting || !art.setting.add || this.settingsAdded) return;
            if (!art.option || art.option.setting !== true) {
                log('播放器未启用内置设置面板，跳过设置项注入');
                return;
            }
            this.settingsAdded = true;
            const self = this;

            // 片头跳过 / 片尾跳过：行内输入框（原生行结构，自建内容）
            art.setting.add({
                name: 'mtyy-intro',
                html: '片头跳过',
                icon: ICON_CLOCK,
                mounted: function ($item) { self.mountDurationRow($item, 'intro'); }
            });
            art.setting.add({
                name: 'mtyy-outro',
                html: '片尾跳过',
                icon: ICON_CLOCK,
                mounted: function ($item) { self.mountDurationRow($item, 'outro'); }
            });

            // 记忆倍速：原生 selector 交互（点开子列表选倍速，与站内「倍速」控件选项一致）
            art.setting.add({
                name: 'mtyy-rate',
                html: '记忆倍速',
                icon: ICON_SPEED,
                tooltip: '当前 ' + rateText(playerCfg.rate) + 'x',
                selector: RATE_OPTIONS.map(function (r) {
                    return { name: 'mtyy-rate-' + rateKey(r), html: rateText(r) + 'x', value: r };
                }),
                onSelect: function (item) {
                    const r = clampRate(item.value);
                    applyUserRate(r);
                    self.refreshSettingRows();
                    return '当前 ' + rateText(r) + 'x';
                }
            });
            this.rateRow = art.setting.find('mtyy-rate');

            // 面板每次打开时同步一次显示值
            art.on('setting', function (state) { if (state) self.refreshSettingRows(); });
            art.on('video:ratechange', function () { self.refreshRateRow(); });
            this.refreshSettingRows();
            log('已在播放器「设置」面板内注入播放增强设置项');
        },

        // 片头/片尾行：整行自建，保证点击不会落到 ArtPlayer 的整行选中逻辑上
        mountDurationRow: function ($item, key) {
            if (!$item || this.settingInputs[key]) return;
            const self = this;
            const label = (key === 'intro') ? '片头跳过' : '片尾跳过';

            $item.style.padding = '0';
            $item.innerHTML = '';

            const row = d.createElement('div');
            row.className = 'mtyy-set-row';

            const left = d.createElement('div');
            left.className = 'mtyy-set-left';
            left.innerHTML = ICON_CLOCK + '<span>' + label + '</span>';

            const input = d.createElement('input');
            input.type = 'text';
            input.className = 'mtyy-set-input';
            input.autocomplete = 'off';
            input.spellcheck = false;
            input.title = '支持「1分30秒」「90」「1:30」；留空或 0 表示关闭';

            row.appendChild(left);
            row.appendChild(input);
            $item.appendChild(row);

            // 冒泡阶段拦截，阻止触发 ArtPlayer 的整行点击（否则会报 $parent 未定义）
            row.addEventListener('click', function (e) { e.stopPropagation(); });
            ['mousedown', 'pointerdown', 'touchstart'].forEach(function (t) {
                row.addEventListener(t, function (e) { e.stopPropagation(); });
            });

            input.addEventListener('keydown', function (e) {
                if (e.key === 'Enter') {
                    e.preventDefault();
                    self.commitDuration(key, input, row);
                } else if (e.key === 'Escape') {
                    e.preventDefault();
                    self.fillDurationInput(input, key);
                    input.blur();
                }
            });
            input.addEventListener('blur', function () { self.commitDuration(key, input, row); });
            input.addEventListener('input', function () {
                input.classList.remove('mtyy-set-input-bad');
                row.classList.remove('mtyy-set-row-bad');
            });

            this.settingInputs[key] = input;
            this.fillDurationInput(input, key);
        },

        fillDurationInput: function (input, key) {
            if (!input) return;
            input.classList.remove('mtyy-set-input-bad');
            input.value = playerCfg[key] > 0 ? fmtDuration(playerCfg[key]) : '';
            input.placeholder = '未开启';
        },

        // 校验通过才落盘（非法字符 / 负值 / 超过总时长 一律拒绝并给出明确提示）
        commitDuration: function (key, input, row) {
            const label = (key === 'intro') ? '片头时长' : '片尾时长';
            const parsed = parseDurationInput(input.value);
            if (!parsed.ok) {
                this.settingsError('「' + label + '」' + parsed.error, input, row);
                return false;
            }

            const dur = this.currentDuration();
            if (!parsed.empty && dur > 0 && parsed.seconds > dur) {
                this.settingsError('「' + label + '」' + fmtDuration(parsed.seconds) +
                    ' 超过视频总时长 ' + fmtDuration(dur) + '，已拒绝保存', input, row);
                return false;
            }

            const other = (key === 'intro') ? playerCfg.outro : playerCfg.intro;
            if (dur > 0 && parsed.seconds > 0 && other > 0 && (parsed.seconds + other) >= dur) {
                this.settingsError('片头 + 片尾（' + fmtDuration(parsed.seconds + other) +
                    '）不小于视频总时长 ' + fmtDuration(dur) + '，已拒绝保存', input, row);
                return false;
            }

            if (parsed.seconds === playerCfg[key]) {
                this.fillDurationInput(input, key);
                return true;
            }

            playerCfg[key] = parsed.seconds;
            savePlayerCfg();
            this.fillDurationInput(input, key);
            this.onCfgChange();                       // 对当前播放立即生效
            this.toast(label + '已' + (parsed.seconds > 0 ? '设为 ' + fmtDuration(parsed.seconds) : '关闭'));
            log('设置已保存：' + key + ' = ' + parsed.seconds + 's');
            return true;
        },

        settingsError: function (msg, input, row) {
            if (input) {
                input.classList.add('mtyy-set-input-bad');
                input.title = msg;
            }
            if (row) row.classList.add('mtyy-set-row-bad');
            this.toast(msg);                          // 播放器原生提示，位于播放器内部
            log('[设置校验]', msg);
        },

        // 同步面板显示：两个输入框 + 记忆倍速行
        refreshSettingRows: function () {
            const self = this;
            ['intro', 'outro'].forEach(function (k) {
                if (self.settingInputs[k]) self.fillDurationInput(self.settingInputs[k], k);
            });
            this.refreshRateRow();
            this.syncSiteRateControl();
        },

        refreshRateRow: function () {
            if (!this.rateRow || !this.art || !this.art.setting) return;
            try { this.rateRow.tooltip = '当前 ' + rateText(playerCfg.rate) + 'x'; } catch (e) {}
            const setting = this.art.setting;
            // 面板正停在子列表时不打断用户（避免被强制弹回根列表）
            if (setting.active && setting.option && setting.active !== setting.option) return;
            RATE_OPTIONS.forEach(function (r) {
                const leaf = setting.find('mtyy-rate-' + rateKey(r));
                if (leaf && leaf.$item) {
                    leaf.$item.classList.toggle('art-current', Math.abs(playerCfg.rate - r) < 0.001);
                }
            });
        },

        // ============================================================
        // 站内自带「倍速」控件的文案同步
        // 记忆倍速生效后必须回写到控制栏，否则控制栏一直显示「倍速」而看不出真实倍速
        // 显示规则与站内控件自身保持一致：1.0x 显示「倍速」，其余显示「1.5x」这类文案
        // ============================================================
        rateLabel: function (r) {
            return Math.abs(clampRate(r) - 1) < 0.001 ? '倍速' : (rateText(r) + 'x');
        },

        findRateControlEl: function () {
            const art = this.art;
            if (!art || !art.controls) return null;
            const pick = function (ref) {
                return (ref && ref.querySelector) ? ref.querySelector('.art-selector-value') : null;
            };
            // 1) 精确匹配：选项里带 rate 字段的 selector 控件，即站内自带的倍速控件
            const cache = art.controls.cache;
            if (cache && typeof cache.forEach === 'function') {
                let found = null;
                cache.forEach(function (item) {
                    if (found || !item || !item.option) return;
                    const sel = item.option.selector;
                    if (!sel || !sel.length) return;
                    const isRate = sel.some(function (s) { return s && typeof s.rate === 'number'; });
                    if (isRate) found = pick(item.$ref);
                });
                if (found) return found;
            }
            // 2) 兜底：按文案找（初始为「倍速」或已是 x.x 形式）
            const player = art.template && art.template.$player;
            if (!player) return null;
            const nodes = player.querySelectorAll('.art-control-selector .art-selector-value');
            for (let i = 0; i < nodes.length; i++) {
                const txt = (nodes[i].textContent || '').trim();
                if (txt === '倍速' || /^[0-9.]+x$/i.test(txt)) return nodes[i];
            }
            return null;
        },

        syncSiteRateControl: function () {
            if (!this.art) return;
            let el = this.rateControlEl;
            if (!el || !el.isConnected) {
                this.rateControlEl = el = this.findRateControlEl();
            }
            if (!el) return;
            const want = this.rateLabel(playerCfg.rate);
            if ((el.textContent || '').trim() !== want) {
                el.textContent = want;                 // 真正需要改显示的倍速值
                log('控制栏倍速显示 → ' + want);
            }
        },

        // -------- 触屏：播放区两侧的透明长按热区（不在进度条下方，完全不遮挡画面） --------
        addSideZones: function (hostEl) {
            if (!TOUCH_OK || !hostEl) return;
            if (this.sideZones && this.zoneWrap && this.zoneWrap.isConnected) return;
            this.sideZones = true;
            const self = this;

            const wrap = d.createElement('div');
            wrap.className = 'mtyy-zones';
            ['left', 'right'].forEach(function (side) {
                const zone = d.createElement('div');
                zone.className = 'mtyy-zone mtyy-zone-' + side;
                wrap.appendChild(zone);      // 完全透明，不放任何图标
            });
            try { hostEl.appendChild(wrap); } catch (e) { return; }
            this.zoneWrap = wrap;

            let timer = null;
            let zoneEl = null;
            let startX = 0;
            let startY = 0;
            let boosted = false;
            let tracking = false;

            const reset = function (suppress) {
                if (timer) { w.clearTimeout(timer); timer = null; }
                if (zoneEl) zoneEl.classList.remove('mtyy-zone-active');
                if (boosted) {
                    if (suppress) suppressNextClick();   // 吞掉长按松开后的 click，避免误触发播放/暂停
                    self.stopBoost();
                }
                boosted = false;
                zoneEl = null;
                tracking = false;
            };

            // 全部用「捕获阶段 + passive」监听，只做判定、不拦截事件，
            // 播放器原有的单击暂停 / 双击 / 滑动调进度与音量等手势完全不受影响
            hostEl.addEventListener('touchstart', function (e) {
                suppressNextClick.cancel();               // 新的触摸开始 → 上一次待吞的 click 作废
                if (tracking) reset(true);
                if (!e.touches || e.touches.length !== 1) return;
                if (self.art && self.art.isLock) return;              // 锁屏时不干预
                if (e.target && e.target.closest && e.target.closest(
                    '.art-bottom,.art-controls,.art-progress,.art-settings,.art-contextmenus,.art-layer,.art-mask')) {
                    return;                                           // 落在控制栏/面板上的触摸不接管
                }
                const box = (self.art && self.art.template && self.art.template.$player) || hostEl;
                const rect = box.getBoundingClientRect();
                if (!rect.width) return;
                const ratio = (e.touches[0].clientX - rect.left) / rect.width;
                let side = null;
                if (ratio <= 0.22) side = 'left';
                else if (ratio >= 0.78) side = 'right';
                if (!side) return;                                    // 中间区域保持播放器原样

                zoneEl = wrap.querySelector('.mtyy-zone-' + side);
                startX = e.touches[0].clientX;
                startY = e.touches[0].clientY;
                tracking = true;
                boosted = false;
                timer = w.setTimeout(function () {
                    timer = null;
                    if (self.art && self.art.isLock) return;
                    self.startBoost();
                    boosted = true;
                    if (zoneEl) zoneEl.classList.add('mtyy-zone-active');
                }, HOLD_MS_TOUCH);
            }, { capture: true, passive: true });

            hostEl.addEventListener('touchmove', function (e) {
                if (!tracking || !e.touches || e.touches.length !== 1) return;
                const dx = Math.abs(e.touches[0].clientX - startX);
                const dy = Math.abs(e.touches[0].clientY - startY);
                const limit = boosted ? 40 : 14;                       // 判定前更容易取消，加速中留点余量
                if (dx > limit || dy > limit) reset(false);            // 用户在滑动调进度/音量，退出
            }, { capture: true, passive: true });

            const finish = function () { if (tracking) reset(true); };
            hostEl.addEventListener('touchend', finish, { capture: true, passive: true });
            hostEl.addEventListener('touchcancel', finish, { capture: true, passive: true });

            // 长按加速时抑制系统/浏览器的长按菜单
            //（部分国产浏览器长按 <video> 会弹「视频信息 / 保存视频」等，由 contextmenu 触发）
            const inZone = function (clientX) {
                const box = (self.art && self.art.template && self.art.template.$player) || hostEl;
                const rect = box.getBoundingClientRect();
                if (!rect.width) return false;
                const ratio = (clientX - rect.left) / rect.width;
                return ratio <= 0.22 || ratio >= 0.78;
            };
            hostEl.addEventListener('contextmenu', function (e) {
                if (!(tracking || boosted || (typeof e.clientX === 'number' && inZone(e.clientX)))) return;
                if (e.preventDefault) e.preventDefault();
                if (e.stopImmediatePropagation) e.stopImmediatePropagation();
                e.stopPropagation();
            }, { capture: true });

            log('已添加移动端播放区两侧的透明长按加速热区');
        },

        // 按设备形态选择加速交互：触屏 → 播放区两侧热区；鼠标 → 只用键盘（不再放按钮）
        setupBoostUI: function (art) {
            if (!TOUCH_OK) return;
            const host = (art && art.template && art.template.$player) ||
                (this.video && (this.video.parentElement || d.body));
            this.addSideZones(host);
        },

    };

    // ---------- 桌面端：长按 → 方向键（临时 ×2），短按 → 快进 5 秒 ----------
    let holdKeyTimer = null;

    function isArrowRight(e) {
        return e.code === 'ArrowRight' || e.key === 'ArrowRight' || e.keyCode === 39;
    }

    function hotkeyDown() {
        if (!Player.video) return false;
        if (!holdKeyTimer && !Player.boostOn) {
            holdKeyTimer = w.setTimeout(function () {
                holdKeyTimer = null;
                Player.startBoost();
            }, HOLD_MS_KEY);
        }
        return true;
    }

    function hotkeyUp() {
        if (!Player.video) return false;
        const wasBoost = Player.boostOn;
        if (holdKeyTimer) { w.clearTimeout(holdKeyTimer); holdKeyTimer = null; }
        if (wasBoost) Player.stopBoost();
        else Player.seekBy(SEEK_STEP);
        return true;
    }

    function onPlayerKeyDown(e) {
        if (!isArrowRight(e) || isTyping(e.target)) return;
        if (!Player.video) return;
        e.preventDefault();
        e.stopImmediatePropagation();          // 阻止播放器自身的方向键快进，由我们统一处理
        hotkeyDown();
    }

    function onPlayerKeyUp(e) {
        if (!isArrowRight(e) || isTyping(e.target)) return;
        if (!Player.video) return;
        e.preventDefault();
        e.stopImmediatePropagation();
        hotkeyUp();
    }

    // ---------- 顶层页面：焦点不在 iframe 里时把长按转发给播放器 ----------
    function onTopKeyDown(e) {
        if (!isArrowRight(e) || isTyping(e.target)) return;
        if (!getPlayerFrames().length) return;
        broadcastAll({ __mtyy: 'key', phase: 'down' });
    }

    function onTopKeyUp(e) {
        if (!isArrowRight(e) || isTyping(e.target)) return;
        if (!getPlayerFrames().length) return;
        broadcastAll({ __mtyy: 'key', phase: 'up' });
    }

    // ---------- 跨帧通信 ----------
    function broadcastAll(msg) {
        let list;
        try { list = d.querySelectorAll('iframe'); } catch (e) { return; }
        for (let i = 0; i < list.length; i++) {
            try { list[i].contentWindow.postMessage(msg, w.location.origin); } catch (e) {}
        }
    }

    function pushCfgToFrames() {
        broadcastAll({
            __mtyy: 'cfg',
            intro: playerCfg.intro,
            outro: playerCfg.outro,
            rate: playerCfg.rate
        });
    }

    function getPlayerFrames() {
        const out = [];
        let list;
        try { list = d.querySelectorAll('iframe'); } catch (e) { return out; }
        for (let i = 0; i < list.length; i++) {
            try {
                const cw = list[i].contentWindow;
                if (cw && cw.document && cw.document.querySelector('video')) out.push(list[i]);
            } catch (e) {}
        }
        return out;
    }

    function onFrameMessage(e) {
        if (e.origin !== w.location.origin) return;
        const m = e.data;
        if (!m || typeof m !== 'object' || !m.__mtyy) return;

        if (m.__mtyy === 'cfg') {
            reloadPlayerCfg();
            Player.onCfgChange();
            Player.applySavedRate();
            Player.refreshSettingRows();
        } else if (m.__mtyy === 'key') {
            if (m.phase === 'down') hotkeyDown();
            else hotkeyUp();
        } else if (m.__mtyy === 'open-panel') {
            // 打开播放器自带的「设置」面板（设置项就在里面）
            if (Player.art && Player.art.setting) {
                Player.refreshSettingRows();
                Player.art.setting.show = true;
            }
        }
    }

    // ---------- 播放器探测（不依赖具体播放器实现） ----------
    function watchPlayer() {
        let scanning = false;
        const scan = function () {
            scanning = false;
            try {
                // 优先用 ArtPlayer 自己的 video，避免误绑到页面里其它 <video>（如广告预览）
                const v = (w.art && w.art.video) ||
                    d.querySelector('.art-video-player video') ||
                    d.querySelector('video');
                if (v) Player.bindVideo(v);
                if (w.art && w.art !== Player.art) Player.bindArt(w.art);
            } catch (e) {}
        };
        const scheduleScan = function () {
            if (scanning) return;
            scanning = true;
            if (w.requestAnimationFrame) w.requestAnimationFrame(scan);
            else w.setTimeout(scan, 16);
        };

        try {
            new w.MutationObserver(scheduleScan)
                .observe(d.documentElement || d, { childList: true, subtree: true });
        } catch (e) {}

        [0, 300, 800, 1500, 3000, 6000].forEach(function (ms) { w.setTimeout(scan, ms); });

        // ArtPlayer 实例出现后会挂在 window.art 上，用它补上自定义控件与提示能力
        // 找到之后立刻降级为 1s 的「守护轮询」：换集 / 重建播放器 / video 元素被替换时
        // 能重新绑定，避免事件监听跟着旧元素一起失效（这是旧版丢失监听的主因之一）
        const startGuard = function () {
            if (watchPlayer._guard) return;
            watchPlayer._guard = w.setInterval(function () {
                try {
                    const art = w.art;
                    if (art && art !== Player.art && art.video) {
                        log('检测到新的播放器实例，重新接入');
                        Player.bindVideo(art.video);
                        Player.bindArt(art);
                        Player.applySavedRate();
                        return;
                    }
                    if (Player.video && Player.video.isConnected === false) {
                        log('原视频元素已离开 DOM，重新探测');
                        Player.stopPatrol();
                        Player.bound = null;
                        scan();
                    }
                } catch (e) {}
            }, 1000);
        };

        let tries = 0;
        const timer = w.setInterval(function () {
            tries++;
            const art = w.art;
            if (art && art.video) {
                Player.bindVideo(art.video);
                Player.bindArt(art);
                Player.applySavedRate();
                w.clearInterval(timer);
                startGuard();
                return;
            }
            if (tries > 600) {                  // 60s 都没见到 ArtPlayer（非 ArtPlayer 播放器）
                w.clearInterval(timer);
                startGuard();
            }
        }, 100);

        d.addEventListener('keydown', onPlayerKeyDown, true);
        d.addEventListener('keyup', onPlayerKeyUp, true);
        w.addEventListener('blur', function () { Player.stopBoost(); });
        d.addEventListener('visibilitychange', function () { if (d.hidden) Player.stopBoost(); });
    }

    // ================================================================
    // ============================ 菜单 ==============================
    // ================================================================
    function registerPlayerMenu() {
        if (typeof GM_registerMenuCommand !== 'function') return;

        GM_registerMenuCommand('打开播放器设置面板（片头 / 片尾 / 倍速）', function () {
            if (Player.art && Player.art.setting) {
                Player.refreshSettingRows();
                Player.art.setting.show = true;
                return;
            }
            broadcastAll({ __mtyy: 'open-panel' });     // 让播放器帧打开自带的设置面板
        });

        GM_registerMenuCommand('清除记忆倍速（恢复 1.0x）', function () {
            reloadPlayerCfg();
            playerCfg.rate = 1;
            savePlayerCfg();
            pushCfgToFrames();
            Player.baseRate = 1;
            Player.writeRate(1);
            Player.refreshSettingRows();
        });
    }

    // ================================================================
    // ============================ 启动 ==============================
    // ================================================================
    function bootstrap() {
        log('启动 v3.0.0', w.location.href, IS_TOP ? '(顶层页面)' : '(子帧/播放器)');

        // —— 模块 A：广告净化 ——
        hookScriptSrc();     // document-start：抢在站内脚本注入之前
        hookSetAttribute();
        hookNetwork();
        hookNavigation();
        installEventListenerGuard();   // 必须早于站内内联脚本
        injectCSS();
        startObserver();

        // —— 模块 C：播放增强（每个帧都可能承载播放器） ——
        addStyle(PLAYER_CSS, 'player');
        watchPlayer();
        w.addEventListener('message', onFrameMessage);

        if (IS_TOP) {
            d.addEventListener('keydown', onTopKeyDown, true);
            d.addEventListener('keyup', onTopKeyUp, true);
        }

        if (d.readyState === 'loading') {
            d.addEventListener('DOMContentLoaded', onDomReady, { once: true });
        } else {
            onDomReady();
        }
        w.addEventListener('load', cleanAll, { once: true });
    }

    function onDomReady() {
        log('DOM 就绪，执行首轮清理');
        cleanAll();
        registerMenu();          // 广告模块菜单
        registerPlayerMenu();    // 播放增强菜单

        // 广告脚本在 1s / 2.5s 后二次注入，这里做几次延迟补刀
        [500, 1200, 2500, 4000, 6000].forEach(function (ms) {
            w.setTimeout(cleanAll, ms);
        });
    }

    bootstrap();

})();