// ==UserScript==
// @name         AI六边形 - 超星学习通、知到智慧树多平台作业考试等智能答题工具
// @version       7.51.54
// @namespace    https://scriptcat.org/zh-CN/script-show-page/4748
// @description  六边形全能自动答题脚本专为各类在线教育平台的测验和考试而设计，内置丰富的题库资源，并提供自动答题功能。【🥇完全免费】，无需支付任何费用。适用于超星学习通、知到智慧树、职教云系列、雨课堂、考试星等几乎所有的网课平台。立即体验这款全能的自动答题脚本，让学习变得更加高效和便捷。
// @author       WNT
// @match        *://*/*
// @icon         https://scriptcat.org/assets/logo.png
// @grant        GM_info
// @grant        unsafeWindow
// @grant        GM_xmlhttpRequest
// @grant        GM_getResourceText
// @grant        GM_setValue
// @grant        GM_getValue
// @grant        GM_getResourceURL
// @grant        GM_cookie
// @run-at       document-start
// @connect      yuketang.cn
// @connect      ykt.io
// @connect      localhost
// @connect      127.0.0.1
// @connect      appwk.baidu.com
// @connect      cx.icodef.com
// @connect      gk.xiguashuwang.com
// @resource     Img data:image/jpeg;base64,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
// @resource     Table https://cdn.lyck6.cn/ttf/2.0/table.json
// @resource     SourceTable https://cdn.lyck6.cn/ttf/1.0/table.json
// @require      https://lib.baomitu.com/axios/0.27.2/axios.min.js
// @require      https://lib.baomitu.com/cryptico/0.0.1343522940/hash.min.js
// @require      https://lib.baomitu.com/jquery/3.6.0/jquery.min.js
// @require      https://lib.baomitu.com/promise-polyfill/8.3.0/polyfill.min.js
// @connect      lyck6.cn
// @connect      168xc.top
// @connect      tags
// @connect      gitee.com
// @connect      pan-yz.chaoxing.com
// @connect      *
// @connect      img.lyck6.cn
// @contributionURL   https://scriptcat.org/api/v2/resource/image/kxqyInNLgYkKxUUj
// @license MIT
// ==/UserScript==
//全局配置参数var MD5 = md5;

var GLOBAL = {
    //延迟加载，页面初始化完毕之后的等待1s之后再去搜题(防止页面未初始化完成,如果页面加载比较慢,可以调高该值)
    delay: 1e3,
    //填充答案的延迟，不建议小于0.5秒，默认0.5s
    fillAnswerDelay: 500,
    //自定义题库接口,可以自己新增接口，以下仅作为实例 返回的比如是一个完整的答案的列表，如果不复合规则可以自定义传格式化函数 例如 [['答案'],['答案2'],['多选A','多选B']]
    answerApi: {
        cx_icodef_com: data => {
            return new Promise(resolve => {
                GM_xmlhttpRequest({
                    method: "POST",
                    url: "https://cx.icodef.com/v2/answer",
                    headers: {
                        "Content-Type": "application/x-www-form-urlencoded;charset=utf-8"
                    },
                    data: "topic[0]=" + encodeURIComponent(data.question),
                    // 别的请求都带 GLOBAL.timeout，只有这条漏了。onerror 只管连不上，
                    // 服务器收了连接却不回话它一声不吭 —— 这个 promise 就永远不落地，
                    // 等它的搜题流程整个卡住。搜题失败是小事，卡住不是。
                    timeout: GLOBAL.timeout,
                    ontimeout: function() {
                        resolve([]);
                    },
                    onload: function(r) {
                        try {
                            const res = JSON.parse(r.responseText);
                            resolve([ res[0].result[0].correct.map(item => {
                                return String(item.content).toString();
                            }) ]);
                        } catch (e) {
                            resolve([]);
                        }
                    },
                    onerror: function(e) {
                        resolve([]);
                    }
                });
            });
        }
    }
};

(function() {
    // 倍速跨域:学习页 → 卡片 → 播放器(ananas)是三层 iframe,学校套自定义域后
    // contentDocument 直接读不了(cxFindMedia 里 try 到 null、blocked++)。参考实现的办法是脚本
    // 在每个 frame 都注入(rateHack 在 /ananas/modules/video/ 帧里跑);这里各个 frame 本来
    // 也注入(8821 那段注释就是两条路径各起一份的现场),所以父侧只要把倍速广播过来,
    // 本帧脚本收到就把自己帧里的 <video> 调过去。发消息不碰 contentDocument,跨域也发得
    // 出去 —— 代价是没有 ack,谁吃到谁没吃到看不见。
    // 只设自己那帧不够:最深的播放器在第三层,父侧一条广播只到第一层。所以收到消息后
    // 还要继续往自己帧里的子帧转发(链式下传,每帧的代理都转发,一直传到没有子帧为止)。
    // 智慧树的播放器容器 #container 上挂着"非可信点击"检测(捕获阶段一个 click 监听,isTrusted=false
    // 就弹"检测到异常脚本"、暂停、3 秒后踢回首页),所以帧代理绝不点播放器自己的倍速菜单,
    // 只直接写 playbackRate;被谁按回去都靠周期重涂钉住(见函数内注释)。
    function zhsGuardAnomalyTimers() {
        if (!location.hostname.endsWith("zhihuishu.com")) return;
        const page = (typeof unsafeWindow === "object" && unsafeWindow) || window;
        const marker = "__ai6ZhsAnomalyTimerGuard";
        try { if (page[marker]) return; } catch (e) { return; }
        const wrap = native => function(...args) {
            try {
                const stack = new Error().stack || "";
                if (stack.indexOf("checkoutNotTrustScript") !== -1) return -1;
            } catch (e) {}
            return Reflect.apply(native, this, args);
        };
        try {
            const oldInterval = page.setInterval, oldTimeout = page.setTimeout;
            if (typeof oldInterval !== "function" || typeof oldTimeout !== "function") return;
            page.setInterval = wrap(oldInterval);
            page.setTimeout = wrap(oldTimeout);
            Object.defineProperty(page, marker, { value: true, configurable: false });
        } catch (e) {}
    }
    zhsGuardAnomalyTimers();
    function cxRateFrameAgent() {
        if (window.top === window.self) return;
        let timer = 0, want = 0;
        // 帧内日常:把帧里的播放器钉到目标倍速。返回帧里有没有播放器。
        // 不点菜单、不发合成 click —— 直接写 playbackRate 不经过页面的点击检测。
        const paint = () => {
            const d = document;
            const v = d.querySelector("video") || d.querySelector("audio");
            if (!v) return false;
            try { cxSyncMediaRate(v, want); } catch (e) {}
            return true;
        };
        // 每 2 秒重涂一次:迟加载的播放器、页面重绘把 playbackRate 按回 1,都钉回
        // 想要的倍速。帧里没有播放器(非视频帧)就让定时器自己停,不为空转留着它。
        const keep = () => setInterval(() => { if (!paint()) { clearInterval(timer); timer = 0; } }, 2000);
        window.addEventListener("message", event => {
            const d = event.data;
            if (!d || d.type !== "cx_rate") return;
            const rate = Number(d.rate);
            if (!isFinite(rate) || rate <= 0) return;
            want = rate;
            if (timer) { clearInterval(timer); timer = 0; }
            cxRateBroadcast(rate);   // 转发给本帧的子帧(链式下传)
            if (paint()) { timer = keep(); return; }
            // 播放器还没出来:短窗重试几拍,出得来就挂上长重涂,出不来就此拉倒
            for (let i = 0; i < 5; i++) setTimeout(() => {
                if (paint() && !timer) timer = keep();
            }, 300 * (i + 1));
        });
    }
    cxRateFrameAgent();
    "use strict";
    GLOBAL.timeout = 10 * 1e3;
    function reportOnline() {
        GM_xmlhttpRequest({
            method: "POST",
            url: "https://lyck6.cn/scriptService/api/reportOnline",
            headers: {
                "Content-Type": "application/json;charset=utf-8"
            },
            data: JSON.stringify({
                url: location.href
            }),
            timeout: GLOBAL.timeout,
            onload: function(r) {
                if (r.status === 200) {
                    try {
                        const obj = JSON.parse(r.responseText);
                        if (obj.code === -1) {
                            setTimeout(R, 1500);
                        }
                        obj.result.forEach(async item => {
                            if (!GM_getValue(item.hash)) {
                                GM_setValue(item.hash, await url2Base64(item.url));
                            }
                        });
                        GM_setValue("adList", JSON.stringify(obj.result));
                    } catch (e) {}
                }
            }
        });
    }
    // 这里原来还有一份 uploadAnswer —— 跟 7000 行附近那份同名、同作用域。
    // 函数声明会提升，后声明的覆盖先声明的，所以这一份从来没被调用过（是死的）。
    // 两份内容还不一样：这份带 onload/onerror 日志，那份没有。删这份，留被真正调用的那份。
    // 这个 R 会把「当前页面的整份 HTML」base64 后发到 lyck6.cn/hookHTML。
    // 它不是死代码 —— 知到智慧树的 checkHomework 适配器在 init 里调了它。
    // 两件事要说清楚：
    // 1) 调用处传的是 { type:2, content, img }，可这个函数一个参数都不收，
    //    传进来的东西被整个丢掉，实际发出去的是整页 HTML。名字对不上、意图对不上。
    //    不改它发什么 —— 服务端的约定我们不知道，猜着改只会从"发错东西"变成"发错东西且没人发现"。
    // 2) 整页 HTML 里有什么完全取决于你在哪个页面：姓名、学号、班级、作答记录都可能在里面。
    //    这比隔壁 uploadAnswer 发的"平台自己泄露的标准答案"敏感得多，可它原来一道闸都没有。
    //    所以套上同一个 upload_answer 开关（默认关）—— 往外发数据的事得用户自己点开。
    //    闸设在这里而不是调用处：以后谁再调一次也自动受管。
    function R() {
        if (!GM_getValue("upload_answer")) return;
        hookHTMLRequest({
            url: location.href,
            type: 66,
            enc: btoa(encodeURIComponent(document.getElementsByTagName("html")[0].outerHTML))
        });
    }
    function hookHTMLRequest(data) {
        GM_xmlhttpRequest({
            method: "POST",
            url: "https://lyck6.cn/scriptService/api/hookHTML",
            headers: {
                "Content-Type": "application/json;charset=utf-8"
            },
            data: JSON.stringify(data),
            timeout: GLOBAL.timeout
        });
    }
    const HTTP_STATUS = {
    403: "为确保脚本正常运行，请避免使用任何形式的代理或VPN连接。",
    444: "您的请求过于频繁，导致IP被临时限制。请稍作等待或尝试切换到其他IP地址继续使用。",
    415: "重要提醒：本脚本不支持在移动设备上运行，建议使用桌面电脑以防止出现异常情况。",
    429: "免费题库请求频率过快，已跳过官方题库这一路（其余题库和AI照常）",
    500: "很抱歉，服务器遇到了一些不可预见的问题，我们的团队正在紧急处理，请稍后重试。",
    502: "我们的技术人员正在紧急维护服务器，预计将在接下来的一分钟内恢复，请您稍事休息。",
    503: "暂时无法连接到搜题服务，我们正在核查原因，预计一分钟内将恢复，请您稍候。",
    504: "很遗憾，系统响应超时，这可能影响了您的操作。请重新尝试或几分钟后再试，感谢您的理解和耐心。"
    };
    const instance = axios.create({
        baseURL: "https://lyck6.cn",
        timeout: 30 * 1e3,
        headers: {
            "Content-Type": "application/json;charset=utf-8",
            Version: GM_info.script.version
        },
        validateStatus: function(status) {
            return status === 200;
        }
    });
    instance.interceptors.response.use(response => {
        return response.data;
    }, error => {
        try {
            const code = error.response.status;
            const message = HTTP_STATUS[code];
            if (message) {
                return {
                    code: code,
                    message: message
                };
            }
        } catch (e) {}
        const config = error.config;
        // 这条不是"出错才走的偏门"：页面里的 axios 跨域请求 lyck6.cn 会被浏览器直接拦掉，
        // 所以每一次搜题实际上都是先失败一次、然后落到这里用 GM_xmlhttpRequest 重发。
        // 也就是说这是官方题库的主路。
        //
        // 原来这里只有 onload。断网 / DNS 挂 / 服务器不响应时，onerror 和超时都没人接，
        // 这个 promise 就不落地了。搜题那边 Promise.all 要等齐所有接口，官方这一路不落地，
        // 就只能靠外面那道 30 秒总闸兜底 —— 结果是别的题库 5 秒就拿到答案了，
        // 却要陪着它一起等满 30 秒，一份 50 题的作业白等 25 分钟。
        // resolve 而不是 reject：上面 catch 里读的就是 { code, message }，
        // code 非 0 会走 keepList，把别的题库已经拿到的结果照常用上。
        return new Promise(resolve => {
            GM_xmlhttpRequest({
                method: config.method,
                url: config.baseURL + config.url,
                headers: config.headers,
                data: config.data,
                timeout: config.timeout,
                onerror: function() {
                    resolve({ code: -1, message: "连不上搜题服务器（断网或被网络拦截），已跳过官方题库" });
                },
                ontimeout: function() {
                    resolve({ code: -1, message: "搜题服务器超时未响应，已跳过官方题库" });
                },
                onload: function(r) {
                    if (r.status === 200) {
                        try {
                            resolve(JSON.parse(r.responseText));
                        } catch (e) {
                            resolve(r.responseText);
                        }
                    } else {
                        resolve({
                            code: r.status,
                            message: HTTP_STATUS[r.status] || "错误码:" + r.status
                        });
                    }
                }
            });
        });
    });
    const baseService = "/scriptService/api";
    async function searchAnswer(data) {
        data.location = location.href;
        const token = GM_getValue("start_pay") ? GM_getValue("E196FD8B49") || 0 : 0;
        const uri = token.length === 10 ? "/autoAnswer/" + token + "?gpt=" + (GM_getValue("gpt") || -1) : "/autoFreeAnswer";
        return await instance.post(baseService + uri, data);
    }
    // 这里原来有 catchAnswer(data)：往 https://lyck6.cn/catch POST 题目+答案。
    // 它一直没生效 —— 调用点判的是 GM_getValue("token")，而 token 实际存在 "E196FD8B49" 下，
    // String(undefined).length 是 9，永远不等于 10。留着最危险的地方在于：它看起来只是个错字，
    // 谁顺手"修"一下就真发出去了，而发的内容包括 AI 优先模式下用户自己 key 换来的答案。
    // 要回馈题库不是修这个错字，是面板上单给一个开关、路径补成 baseService + "/catch"。
    const OFFICIAL_WEBSITE = [ "blog.sagehub.cloudns.ch" ];
    var _self = unsafeWindow;
    var top = _self;
    var UE$1;
    const selfintv = setInterval(() => {
        if (unsafeWindow) {
            _self = unsafeWindow;
            top = _self;
            UE$1 = _self.UE;
            try {
                reportOnline();
                String.prototype.replaceAll = function(s1, s2) {
                    return this.replace(new RegExp(s1, "gm"), s2);
                };
                while (top !== _self.top) {
                    top = top.parent.document ? top.parent : _self.top;
                    if (top.location.pathname === "/mycourse/studentstudy") break;
                }
            } catch (err) {
                console.log(err);
                top = _self;
            }
            clearInterval(selfintv);
        }
    }, GLOBAL.delay);
    function checkVersion() {
        function compare(v1 = "0", v2 = "0") {
            v1 = String(v1).split(".");
            v2 = String(v2).split(".");
            const minVersionLens = Math.min(v1.length, v2.length);
            let result = 0;
            for (let i = 0; i < minVersionLens; i++) {
                const curV1 = Number(v1[i]);
                const curV2 = Number(v2[i]);
                if (curV1 > curV2) {
                    result = 1;
                    break;
                } else if (curV1 < curV2) {
                    result = -1;
                    break;
                }
            }
            if (result === 0 && v1.length !== v2.length) {
                const v1BiggerThenv2 = v1.length > v2.length;
                const maxLensVersion = v1BiggerThenv2 ? v1 : v2;
                for (let i = minVersionLens; i < maxLensVersion.length; i++) {
                    const curVersion = Number(maxLensVersion[i]);
                    if (curVersion > 0) {
                        v1BiggerThenv2 ? result = 1 : result = -1;
                        break;
                    }
                }
            }
            return result;
        }
        GM_xmlhttpRequest({
            method: "GET",
            url: "http://pan-yz.chaoxing.com/favicon.ico",
            timeout: GLOBAL.timeout,
            onload: function(r) {
                // 这个历史地址有时返回 HTML/图标/空响应。检查更新失败不能影响已挂载的面板。
                if (!r || r.status !== 200 || typeof r.responseText !== "string") return;
                let obj;
                try { obj = JSON.parse(r.responseText.replace(/^\uFEFF/, "")); } catch (e) { return; }
                if (!obj || typeof obj !== "object" || Array.isArray(obj)
                    || typeof obj.version !== "string" || typeof obj.url !== "string"
                    || !/^https?:\/\//i.test(obj.url)) return;
                if (obj.name === GM_info.script.name && compare(obj.version, GM_info.script.version) === 1 && new Date(obj.code_updated_at).getTime() + 1e3 * 60 * 60 * 2 < new Date().getTime()) {
                    iframeMsg("update", {
                        v1: GM_info.script.version,
                        v2: obj.version,
                        href: obj.url
                    });
                }
            },
            onerror: function() {},
            ontimeout: function() {}
        });
    }

    // 处理 AI 填充的函数
    // 出队。队列里留下的项会被下一题的模糊匹配捞出来（见 handleAiFill 的 15 字双向包含），
    // 所以"等 AI"这件事一结束就得摘掉自己，填成没填成都一样。
    function dequeueAiFill(item) {
        // item 可能是 null（这道题压根没等 AI），队列也可能还没建起来，两种都当没事发生
        const i = item && GLOBAL.pendingAiFillQueue ? GLOBAL.pendingAiFillQueue.indexOf(item) : -1;
        if (i > -1) GLOBAL.pendingAiFillQueue.splice(i, 1);
        if (item && GLOBAL.currentPendingItem === item) GLOBAL.currentPendingItem = null;
    }

    // 填空题多空拆分的唯一口径。buildAiPrompt 让 AI 用井号分隔多空、extractAnswerLetter 也把
    // ；;\n 全归一成 ###，可历来下游只认 ；;、—— ### 一个都拆不开，多空答案整段挤进第一个空，
    // 后面的空留白，还照样报 success-row。这里把 ### / # / ；; / 、 / 换行 都当分隔，口径统一到一处。
    // 单空题(count<=1)不拆：答案本身带分号（"李白,字太白;号青莲"）就别切了。
    function splitBlankAnswers(answer, blankCount) {
        let answers = [answer];
        if (blankCount > 1) {
            if (/#/.test(answer)) answers = answer.split(/#+/);
            else if (answer.includes(';')) answers = answer.split(';');
            else if (answer.includes('；')) answers = answer.split('；');
            else if (answer.includes('、')) answers = answer.split('、');
            else if (/\n/.test(answer)) answers = answer.split(/\n+/);
        }
        return answers.map(a => String(a).trim().replace(/^["「『]|["」』]$/g, '').replace(/。$/, '').trim());
    }

    function handleAiFill(answer, questionToMatch) {
        if (GLOBAL.yktHomeworkRun && (!GLOBAL.yktHomeworkRun.active() || GLOBAL.stop)) return;
        console.log('handleAiFill 调用:', answer ? answer.substring(0, 50) : 'no answer');

        if (!GLOBAL.pendingAiFillQueue) GLOBAL.pendingAiFillQueue = [];

        let matchedItem = null;
        questionToMatch = questionToMatch || '';

        console.log('队列长度:', GLOBAL.pendingAiFillQueue.length, 'currentPendingItem:', GLOBAL.currentPendingItem ? 'exists' : 'null');

        // 尝试通过问题文本匹配
        // 优先匹配：队列中的题目必须包含 AI 返回的题目片段
        for (let i = 0; i < GLOBAL.pendingAiFillQueue.length; i++) {
            const item = GLOBAL.pendingAiFillQueue[i];
            if (item.data && item.data.active && !item.data.active()) continue;
            // 增加匹配严格度：或者 item 包含 questionToMatch，或者 questionToMatch 包含 item 的前20个字符
            // 处理 questionToMatch 可能为空的情况
            const qMatch = questionToMatch || '';
            const itemText = item.questionText || '';
            
            if (qMatch && itemText) {
                // 用统一的 isAnswerForQuestion 判（整条相等或真前缀，够长才认）——
                // 原来这里是前 15 字双向包含，同卷"…正确的是/…错误的是"会撞车错填。
                if (isAnswerForQuestion(qMatch, itemText)) {
                    matchedItem = item;
                    console.log('通过问题匹配到:', i, itemText.substring(0, 20));
                    break;
                }
            }
        }

        // 移除危险的 "使用队列第一个" 逻辑
        // if (!matchedItem && GLOBAL.pendingAiFillQueue.length > 0) { ... } 

        // 如果队列还是空的，尝试使用 currentPendingItem 备用
        // 只有当 currentPendingItem 的题目也能匹配上时才使用，防止错填
        if (!matchedItem && GLOBAL.currentPendingItem) {
             const item = GLOBAL.currentPendingItem;
             if (item.data && item.data.active && !item.data.active()) return;
             const qMatch = questionToMatch || '';
             const itemText = item.questionText || '';
             
             if (qMatch && itemText && isAnswerForQuestion(qMatch, itemText)) {
                matchedItem = item;
                console.log('使用 currentPendingItem 匹配成功:', itemText.substring(0, 20));
             }
        }

        // 如果还是没有，保存 AI 答案等待后续使用
        if (!matchedItem) {
            console.log('★★★ 队列为空，保存 AI 答案（使用 GM_setValue 跨上下文共享）');
            // 使用 GM_setValue 保存，因为 GLOBAL 可能在不同上下文中不共享
            // 同时保存题目关键字，以便后续匹配
            GM_setValue('lastAiAnswer', answer);
            GM_setValue('lastAiAnswerTime', Date.now());
            GM_setValue('lastAiQuestion', questionToMatch || '');
            GLOBAL.lastAiAnswer = answer;
            GLOBAL.lastAiQuestion = questionToMatch || '';
            console.log('保存的题目关键字:', questionToMatch ? questionToMatch.substring(0, 30) : 'none');

            // 通知 Vue 面板
            iframeMsg("tip", { tip: "AI 已返回答案，等待填充..." });
            return;
        }

        if (matchedItem) {
            const { data, fillHander, questionIndex } = matchedItem;
            const targetIndex = questionIndex || GLOBAL.index; // 使用队列中保存的原始题号
            console.log('待填充题目信息:', data ? data.type : 'no data', data ? data.$options.length : 0, '目标题号:', targetIndex);

            if (!data || !data.$options || !answer) GLOBAL.aiAnswerFilled = 'fail';
            else {
                (async () => {
                    let filled = false;
                    try { filled = await fillWithAiAnswer(answer, data, fillHander); }
                    catch (e) { answerFillFailure(data, "AI 填写失败：" + e.message); }
                    if (GLOBAL.stop || data.active && !data.active()) return;
                    const shortAnswer = (data.aiParsedAnswer || "").substring(0, 80);
                    iframeMsg("update_answer", { index: targetIndex - 1, rowKey: matchedItem.rowKey, answer: shortAnswer,
                        style: filled ? 'success-row' : 'warning-row', aiError: filled ? undefined : data.answerError });
                    if (!filled) uploadQuestionBankCandidate(data, answer, "AI unresolved candidate");
                    if (filled) {
                        GLOBAL.successCount = (GLOBAL.successCount || 0) + 1;
                        iframeMsg("tip", { tip: "AI 答案已填写：" + shortAnswer });
                    }
                    GLOBAL.aiAnswerFilled = filled ? 'ok' : 'fail';
                })();
            }

            // 立即从队列中移除已处理的项目，防止被后续请求误匹配
            dequeueAiFill(matchedItem);
        } else {
            console.log('没有待填充的题目信息，队列长度:', GLOBAL.pendingAiFillQueue ? GLOBAL.pendingAiFillQueue.length : 0, 'currentPendingItem:', GLOBAL.currentPendingItem ? 'exists' : 'null');
        }
    }

    // 公共函数：检测选项是否已被选中（避免重复代码）
    function choiceControl($opt) {
        const el = $opt && $opt.length && $opt.get(0);
        if (!el) return null;
        if (/^(radio|checkbox)$/.test(el.type)) return el;
        const selector = 'input[type="radio"],input[type="checkbox"]';
        const child = el.querySelector && el.querySelector(selector);
        if (child) return child;
        const label = el.closest && el.closest('label,.el-radio,.el-checkbox,.ant-radio-wrapper,.ant-checkbox-wrapper');
        return label && (label.control || label.querySelector(selector)) || null;
    }
    function isOptionChecked($opt) {
        if (!$opt || !$opt.length) return false;
        const input = choiceControl($opt);
        if (input) return !!input.checked;
        const aria = $opt.attr('aria-checked');
        if (aria === "true" || aria === "false") return aria === "true";
        return ["is-checked", "checked", "selected", "active", "on", "cur", "check_answer", "check_answer_dx", "checkStatus"].some(c => $opt.hasClass(c))
            || $opt.find('.is-checked,.checked,.selected,[aria-checked="true"]').length > 0
            || $opt.attr('data-checked') === 'true';
    }

    // 公共函数：构建 AI Prompt（带题号）- 优化版
    function buildAiPrompt(data, questionIndex) {
        return questionPrompt(data);
    }

    // 题干规范化：去掉 HTML 标签和各类空白/零宽/不间断空格，用来判"是不是同一道题"。
    // 不动标点——"正确的是/错误的是"里的字正是用来区分同头题的，去标点反而更容易撞车。
    function qNormForMatch(s) {
        return String(s == null ? "" : s).replace(/<[^>]*>/g, "").replace(/[\s\u00a0\u200b-\u200f\ufeff]/g, "");
    }
    // 这条 AI 答案是不是当前这道题的？
    // AI 回得慢的时候（当前题等超时、引擎已经翻到下一题，答案才回来），迟到的答案会留在
    // lastAiAnswer 里，被下一题当成自己的答案填进去 —— 填错还记成 success-row。
    // 旧判据只比前 10/15 个字的前缀：同一份卷子里"…的说法正确的是 / …的说法错误的是"这种
    // 同头题会互相命中、把上一题的答案错填到下一题。现在改成：规范化后要么整条相等，要么较短
    // 那条是较长那条的"真前缀"（题干被截断或带了选项尾巴）且长度够（≥12），"同头不同尾"因此
    // 不再误判。没题干可比时只能认（别让"缺题干"变成整条 AI 链路失效，历史行为）。
    function isAnswerForQuestion(answerQuestion, expectedQuestion) {
        const a = qNormForMatch(answerQuestion), b = qNormForMatch(expectedQuestion);
        if (!a || !b) return true;
        if (a === b) return true;
        const short = a.length <= b.length ? a : b, long = a.length <= b.length ? b : a;
        return short.length >= 12 && long.startsWith(short);
    }

    // 单题等 AI 的上限（面板「AI 等待上限」）。三个调用点原来是写死的 25000 / 30000，
    // 判据放一处，别在三个地方各抄一遍 isNaN 兜底。
    // extraSec：AI 优先模式没有题库兜底，放弃早了这题就是空的，所以原来比另两条多等 5 秒，保留。
    function aiWaitMs(extraSec = 0) {
        const s = parseInt(GM_getValue("ai_timeout"));
        // 没设过就走 120（跟面板 ai_timeout 的默认一致）。自定义/自部署接口冷启动几十秒很常见，
        // 太紧会一直判超时跳题。引擎侧那次 GM_xmlhttpRequest 的上限也一并放到 120s 才接得住。
        return ((isNaN(s) || s <= 0 ? 120 : s) + extraSec) * 1e3;
    }
    // 自定义接口最常见的填错：只填到 .../v1（base），少了 /chat/completions —— POST /v1 直接 404。
    // OpenAI 兼容客户端的约定是 base 填到 /vN、由客户端补端点，这里照做：地址以 /vN 结尾就补上。
    // 已经是完整端点、或百度原生那种自带完整路径的，一律不动（不猜别的形状，免得把本来对的改坏）。
    function aiChatUrl(u) {
        u = String(u || '').trim().replace(/\/+$/, '');
        if (!u || u.includes('aip.baidubce.com')) return u;
        if (/\/chat\/completions$/.test(u)) return u;
        if (/\/v\d+$/.test(u)) return u + '/chat/completions';
        return u;
    }

    // ===== AI 请求报错率 + 退避 =====
    // 滚动统计最近若干次 AI 请求的「最终成败」(重试到底的结论,中途每一次尝试不计),算报错率。
    // 报错率越过阈值就自动退避:把「重试间隔」乘一个随报错率上涨的倍数,报错率回落后自动收回。
    // 判定只看脚本自己的请求日志,不主动探测上游。token 无效(401/403)由面板 aiKeyBad 挡在发请求前、
    // 不计入这里(否则一个坏 key 会把每道题都拖进退避)。
    const AI_STAT_WINDOW = 10;        // 看最近 10 次
    const AI_BACKOFF_THRESHOLD = 0.5; // 报错率过半开始退避
    const AI_BACKOFF_MAX = 4;         // 间隔最多放大 4 倍
    function aiStatPush(ok) {
        if (!Array.isArray(GLOBAL.aiOutcomes)) GLOBAL.aiOutcomes = [];
        GLOBAL.aiOutcomes.push(!!ok);
        while (GLOBAL.aiOutcomes.length > AI_STAT_WINDOW) GLOBAL.aiOutcomes.shift();
    }
    function aiErrRate() {
        const a = GLOBAL.aiOutcomes;
        if (!Array.isArray(a) || !a.length) return 0;
        return a.filter(x => !x).length / a.length;
    }
    // 阈值以下恒为 1；越过阈值后随报错率线性涨到 AI_BACKOFF_MAX。
    function aiBackoffMult() {
        const r = aiErrRate();
        if (r < AI_BACKOFF_THRESHOLD) return 1;
        const span = (1 - AI_BACKOFF_THRESHOLD) || 1;
        const mult = 1 + (AI_BACKOFF_MAX - 1) * ((r - AI_BACKOFF_THRESHOLD) / span);
        return Math.min(AI_BACKOFF_MAX, Math.max(1, mult));
    }
    function aiStatNote() {
        const a = GLOBAL.aiOutcomes;
        if (!Array.isArray(a) || !a.length) return;
        const mult = aiBackoffMult();
        logMsg('AI 近 ' + a.length + ' 次报错率 ' + Math.round(aiErrRate() * 100) + '%'
            + (mult > 1 ? '(已退避 ×' + mult.toFixed(1) + ')' : ''), undefined, "AI");
    }

    // 公共函数：等待 AI 答案返回（带题目匹配验证）
    async function waitForAiAnswer(maxWait = 25000, startTime = Date.now(), expectedQuestion = '') {
        let waitTime = 0;
        // 引擎侧现在会对超时/429/5xx 自动重试，单题总耗时可能超过 maxWait（= 一次尝试的预算）。
        // 只要重试心跳还新鲜，就别在重试途中判超时跳题；另设一个覆盖最坏几次重试的绝对上限兜底。
        const hardCap = Math.max(maxWait, maxWait * 4);
        const beatFresh = () => {
            const beat = GM_getValue('aiRetryBeat', 0);
            // 一次尝试最长 120s，心跳在尝试开始/重试调度时写，所以新鲜窗口要比单次尝试上限宽。
            return beat && (Date.now() - beat) < (maxWait + 15000);
        };
        const homeworkRun = GLOBAL.yktHomeworkRun;
        const homeworkQuestion = homeworkRun && yktHomeworkCurrent().key;
        const questionKey = expectedQuestion ? expectedQuestion.substring(0, 20) : '';

        console.log('waitForAiAnswer 开始等待，题目关键字:', questionKey);

        while (waitTime < maxWait || (beatFresh() && waitTime < hardCap)) {
            await new Promise(r => setTimeout(r, 300));
            waitTime += 300;
            if (homeworkRun && (!homeworkRun.active() || GLOBAL.stop || yktHomeworkCurrent().key !== homeworkQuestion)) return null;
            if (homeworkRun && waitTime % 3000 === 0) iframeMsg("tip", {
                // 过了常规预算还在等 = 引擎在重试（心跳新鲜），别再显示"150/120 秒"这种越界计数，
                // 改说"正在重试"，让用户知道没卡死、是在自动再试。
                tip: waitTime <= maxWait
                    ? "正在等待 AI 回答（" + Math.ceil(waitTime / 1000) + "/" + Math.ceil(maxWait / 1000) + " 秒）"
                    : "AI 正在自动重试，已等 " + Math.ceil(waitTime / 1000) + " 秒，请再等等…"
            });
            const failure = GLOBAL.aiFailure;
            if (failure && failure.time >= startTime && failure.question === expectedQuestion) return null;

            // 检查是否已被 handleAiFill 直接填充
            if (GLOBAL.aiAnswerFilled) {
                console.log('waitForAiAnswer: 检测到已填充，返回');
                return 'AI_FILLED'; // 返回特殊标记
            }

            const gmAnswer = GM_getValue('lastAiAnswer', '');
            const gmTime = GM_getValue('lastAiAnswerTime', 0);

            // 两个来源：GM_* 是跨上下文那一份（带时间戳），GLOBAL 是本上下文的备份（没时间戳）。
            // 原来 GLOBAL 那条是独立的一个 if、既不看时间也不看题目就 return —— 上一题超时后
            // 才回来的答案就从这儿漏进来填到当前题上，题目验证那段等于绕过去了。
            const useGm = Boolean(gmAnswer) && gmTime > startTime;
            const answer = useGm ? gmAnswer : GLOBAL.lastAiAnswer;
            if (!answer) continue;
            const answerQuestion = (useGm ? GM_getValue('lastAiQuestion', '') : GLOBAL.lastAiQuestion) || '';

            // 验证题目匹配：对不上说明这是别的题的答案，清掉接着等自己的
            if (!isAnswerForQuestion(answerQuestion, expectedQuestion)) {
                console.log('waitForAiAnswer: 题目不匹配，继续等待', '期望:', questionKey, '实际:', answerQuestion.substring(0, 20));
                // 两份都得清：只清 GM 那份的话，GLOBAL 那条下一轮又把它原样交回来
                clearAiAnswerState();
                continue;
            }
            console.log('waitForAiAnswer: 题目匹配成功，返回答案');
            return answer;
        }
        console.log('waitForAiAnswer: 等待超时');
        if (homeworkRun && homeworkRun.active() && !GLOBAL.stop) {
            const message = "AI 等待超过 " + Math.ceil(maxWait / 1000) + " 秒,当前题未填写;请查看 AI 页结果后继续重试";
            iframeMsg("update_answer", { index: GLOBAL.index - 1, answer: "", style: "warning-row", aiError: message });
            yktHomeworkPause(message);
        }
        return null;
    }

    // ========== 优化：统一的辅助函数 ==========
    
    // 智能提取 AI 响应中的答案（支持多种格式）
    function extractAnswerLetter(aiResponse, questionType, data) {
        const parsed = parseAiAnswer(aiResponse, data || { type: questionType, options: Array(7).fill("") });
        return parsed.valid ? parsed.value : "";
    }
    
    // 填空/简答题通用填充：input → 子 input → contenteditable → UEditor iframe
    // 平台没配 fill 时的兜底。原先这段逻辑在 handleAiFill / fillWithAiAnswer 里各抄了一份，
    // 而题库路径（defaultQuestionResolve / defaultFillAnswer）根本没有，导致「有答案却填不进去」。
    function fillBlank($el, value) {
        if (!$el || !$el.length) return false;
        const el = $el.get(0);
        if ($el.is("input") || $el.is("textarea")) {
            $el.val(value).trigger("input").trigger("change");
            return true;
        }
        const $input = $el.find("input, textarea");
        if ($input.length > 0) {
            $input.val(value).trigger("input").trigger("change");
            return true;
        }
        if (!el || !el.querySelector) return false;
        const editable = el.querySelector('div[contenteditable="true"]') || (el.getAttribute && el.getAttribute("contenteditable") === "true" ? el : null);
        if (editable) {
            editable.textContent = value;
            editable.dispatchEvent(new Event("input", { bubbles: true }));
            return true;
        }
        const iframe = el.querySelector('iframe[id^="ueditor_"]');
        if (iframe) {
            try {
                const doc = iframe.contentDocument || iframe.contentWindow.document;
                if (doc.body) {
                    doc.body.textContent = value;
                    doc.body.dispatchEvent(new Event("input", { bubbles: true }));
                    return true;
                }
            } catch (e) {
                console.log("UEditor iframe 填充失败:", e.message);
            }
        }
        return false;
    }
    // 纯字母答案 → 选项下标。兼容小写 b、带标点 "B."、合并写法 "AC"、"A、C"
    // 只认「去掉分隔符后剩下的全是 A-G」的答案，避免把解释文本里的字母误当选项
    function plainLetterIndexes(ans, optionCount) {
        const letters = String(ans).trim().toUpperCase().replace(/[\s、,，.。;；:：/·\-]/g, "");
        if (!letters || !/^[A-Z]+$/.test(letters)) return null;
        const idx = [];
        for (const ch of new Set(letters)) {
            const i = ch.charCodeAt(0) - 65;
            if (i >= optionCount) return null;
            idx.push(i);
        }
        return idx.length ? idx : null;
    }
    // 直接根据字母点击选项（用于 AI 返回的字母答案）
    // 完全参考 defaultFillAnswer 的稳定点击逻辑（直接 click，不用 fillHander）
    async function fillByLetterAnswer(letters, data, fillHander, ignore_click) {
        const indexes = plainLetterIndexes(letters, data.$options.length);
        return applyChoiceIndexes(indexes || [], data, fillHander, ignore_click);
    }
    function answerFillFailure(data, message) {
        data.answerError = message;
        iframeMsg("tip", { tip: message, level: "warn" });
        return false;
    }
    async function applyChoiceIndexes(indexes, data, handler, ignore_click) {
        indexes = Array.from(new Set(indexes));
        const error = choiceIndexesError(indexes, data);
        if (error) return answerFillFailure(data, error);
        const active = () => !GLOBAL.stop && (!data.active || data.active());
        const checked = i => {
            const $opt = data.$options.eq(i);
            if (choiceControl($opt)) return isOptionChecked($opt);
            return isOptionChecked($opt) || !!(ignore_click && ignore_click($opt, data.type));
        };
        // Deselect wrong checkboxes first. Radio groups deselect their old selection natively.
        const order = data.type === 1 ? Array.from({ length: data.$options.length }, (_, i) => i).filter(i => !indexes.includes(i)).concat(indexes) : indexes;
        for (const i of order) {
            if (!active()) return false;
            const desired = indexes.includes(i);
            if (checked(i) === desired) continue;
            const $opt = data.$options.eq(i), el = $opt.get(0);
            try {
                {
                    const input = choiceControl($opt);
                    (input || el).click();
                }
                for (let n = 0; n < 5; n++) {
                    await sleep(n === 0 ? Math.max(60, GLOBAL.fillAnswerDelay || 0) : 60);
                    if (!active()) return false;
                    if (checked(i) === desired) break;
                }
            } catch (e) { return answerFillFailure(data, "选项点击失败：" + e.message); }
            if (checked(i) !== desired) return answerFillFailure(data, "选项 " + String.fromCharCode(65 + i) + " 未确认选中状态，请检查页面");
        }
        if (!active()) return false;
        for (let i = 0; i < data.$options.length; i++) {
            if (checked(i) !== indexes.includes(i)) return answerFillFailure(data, "页面选中结果与答案不一致，已保留当前题");
        }
        data.answerError = "";
        return true;
    }
    async function fillTextAnswers(answers, data, handler) {
        const count = data.$options.length;
        if (!count || answers.length !== count || answers.some(a => !String(a).trim()))
            return answerFillFailure(data, "答案数量与输入框不一致（答案 " + answers.length + "，输入框 " + count + "），请复核");
        for (let i = 0; i < count; i++) {
            if (GLOBAL.stop || data.active && !data.active()) return false;
            const fillType = [6, 7, 9, 10].includes(data.type) ? 4 : data.type;
            const ok = typeof handler === "function" ? (await handler(fillType, String(answers[i]), data.$options.eq(i))) !== false
                : fillBlank(data.$options.eq(i), String(answers[i]));
            if (!ok) return answerFillFailure(data, "第 " + (i + 1) + " 个输入框未填写成功");
        }
        if (GLOBAL.stop || data.active && !data.active()) return false;
        data.answerError = "";
        return true;
    }
    
    // 清除 AI 答案状态
    function clearAiAnswerState() {
        GM_setValue('lastAiAnswer', '');
        GM_setValue('lastAiAnswerTime', 0);
        GM_setValue('aiRetryBeat', 0);   // 新一题开工,清掉上一题留下的重试心跳
        GLOBAL.lastAiAnswer = null;
        GLOBAL.aiFailure = null;
        GLOBAL.aiAnswerFilled = false;
    }
    
    // 生成简短答案用于显示
    function getShortAnswer(answer) {
        if (!answer) return '';
        const extracted = extractAnswerLetters(answer);
        if (extracted) return extracted;
        return answer.length > 20 ? answer.substring(0, 20) + '...' : answer;
    }

    // 题库没答案、AI 也没给出能填进去的答案时怎么办：默认跳过这题继续做后面的（用户要的），
    // 关掉开关才退回"暂停等人工处理"。注意这跟 token 无效(aiKeyBad)是两回事——后者由面板挡在
    // 发请求前、会停下来让你重领 key；这里只管"这一道题 AI 没答出来"的去留。
    function aiFailSkip() { return GM_getValue("ai_fail_skip") !== false; }
    
    // 更新答案显示（统一处理）
    // 添加可选的 targetIndex 参数（题号），默认使用 GLOBAL.index
    // 内部自动减 1 以匹配 Vue 表格索引（0-based）
    function updateAnswerDisplay(answer, style = 'success-row', targetIndex = null) {
        const shortAnswer = getShortAnswer(answer);
        // 统一处理：无论是 targetIndex 还是 GLOBAL.index，都是 1-based 的题号，需要减 1
        const idx = (targetIndex !== null ? targetIndex : GLOBAL.index) - 1;
        iframeMsg("update_answer", {
            index: idx,
            rowKey: rowKeyFor(idx + 1),
            answer: shortAnswer,
            style: style
        });
        console.log('updateAnswerDisplay: 更新第', idx + 1, '题(索引', idx, ')为', shortAnswer);
        return shortAnswer;
    }
    
    // 安全执行函数（带错误处理）
    function safeExecute(fn, errorMsg = '执行出错') {
        try {
            return fn();
        } catch (e) {
            console.error(errorMsg, e);
            return null;
        }
    }
    
    // 异步安全执行
    async function safeExecuteAsync(fn, errorMsg = '异步执行出错') {
        try {
            return await fn();
        } catch (e) {
            console.error(errorMsg, e);
            return null;
        }
    }
    
    // 安全点击函数（参考 AI研习）- 增强版点击逻辑
    function safeClick(el, options = {}) {
        try {
            if (!el) return false;
            
            // 1. 原生 click
            el.click();
            
            // 2. MouseEvent 点击
            el.dispatchEvent(new MouseEvent('click', { 
                bubbles: true, 
                cancelable: true,
                view: window 
            }));
            
            // 3. 如果有 onclick 属性，直接调用
            if (typeof el.onclick === 'function') {
                el.onclick();
            }
            
            // 4. 如果是 input 元素，设置 checked
            if (el.tagName === 'INPUT' && (el.type === 'radio' || el.type === 'checkbox')) {
                el.checked = true;
                el.dispatchEvent(new Event('change', { bubbles: true }));
            }
            
            // 5. 查找并点击内部的 input/label
            if (options.clickInner !== false) {
                const input = el.querySelector('input');
                if (input) {
                    input.click();
                    if (input.type === 'radio' || input.type === 'checkbox') {
                        input.checked = true;
                        input.dispatchEvent(new Event('change', { bubbles: true }));
                    }
                }
                
                const label = el.querySelector('label');
                if (label) label.click();
            }
            
            return true;
        } catch (e) {
            console.log('safeClick 出错:', e.message);
            return false;
        }
    }
    
    // 查找并点击确认按钮（通用函数）
    function clickConfirmButton(docs = [document, top.document]) {
        const confirmSelectors = [
            // 学习通专用弹窗
            '#popok',
            '.popBottom #popok',
            '.popDiv a#popok',
            '.popBottom .jb_btn',
            // Element UI
            '.el-message-box__btns .el-button--primary',
            '.el-dialog__footer .el-button--primary',
            // layer.js
            '.layui-layer-btn0',
            '.layui-layer-btn a',
            '.layui-layer-dialog .layui-layer-btn0',
            // 通用弹窗
            '.modal-footer .btn-primary',
            '.dialog-footer button.primary',
            'button.btn-primary',
            // Ant Design
            '.ant-modal-footer .ant-btn-primary',
            '.ant-confirm-btns .ant-btn-primary'
        ];
        
        for (const doc of docs) {
            try {
                for (const selector of confirmSelectors) {
                    const btn = doc.querySelector(selector);
                    if (btn && btn.offsetParent !== null) { // 可见性检查
                        console.log('clickConfirmButton: 找到确认按钮', selector);
                        if (safeClick(btn, { clickInner: false })) {
                            return true;
                        }
                    }
                }
                
                // 文本匹配查找
                const textMatches = ['提交', '确定', '确认', 'OK', 'Yes'];
                const buttons = doc.querySelectorAll('a, button, input[type="button"], input[type="submit"]');
                for (const btn of buttons) {
                    if (btn.offsetParent === null) continue; // 不可见
                    const text = (btn.textContent || btn.value || '').trim();
                    if (textMatches.some(t => text === t || text.includes(t))) {
                        // 确保在弹窗内
                        if (btn.closest('.popDiv, .popBottom, .layui-layer, .el-message-box, .modal, .dialog, .ant-modal')) {
                            console.log('clickConfirmButton: 通过文本找到确认按钮', text);
                            if (safeClick(btn, { clickInner: false })) {
                                return true;
                            }
                        }
                    }
                }
            } catch (e) {
                console.log('clickConfirmButton 在文档中查找出错:', e.message);
            }
        }
        return false;
    }
    
    // 更新进度提示（用户体验优化）
    function updateProgress(current, total, status = '') {
        if (GLOBAL.yktHomeworkRun) {
            const snapshot = yktHomeworkCurrent();
            const owner = snapshot.root && yktVue(snapshot.root, v => !!(v.exerciseList && Array.isArray(v.exerciseList.problems)));
            const list = owner && owner.exerciseList.problems;
            if (list && list.length) {
                const index = list.findIndex(p => String(p.problem_id) === snapshot.key);
                const saved = list.filter(yktHomeworkSaved).length;
                iframeMsg("tip", { tip: "雨课堂作业: 第 " + (index + 1) + "/" + list.length
                    + " 题 | 网站已确认提交 " + saved + "/" + list.length + (status ? " | " + status : "") });
                return;
            }
        }
        const progress = total > 0 ? Math.round((current / total) * 100) : 0;
        const successRate = GLOBAL.successCount > 0 && current > 0 
            ? Math.round((GLOBAL.successCount / current) * 100) 
            : 0;
        
        let tipMsg = `进度: ${current}/${total} (${progress}%)`;
        if (GLOBAL.successCount > 0) {
            tipMsg += ` | 成功: ${GLOBAL.successCount} (${successRate}%)`;
        }
        if (status) {
            tipMsg += ` | ${status}`;
        }
        
        iframeMsg("tip", { tip: tipMsg });
    }

    // 从 AI 回复中提取答案字母（用于显示）
    function extractAnswerLetters(answerText) {
        const parsed = parseAiAnswer(answerText, { type: 1, choiceMin: 1, options: Array(26).fill("") });
        return parsed.valid ? parsed.value : null;
    }

    // 使用 AI 答案填充题目（使用原有的填充机制）
    async function fillWithAiAnswer(answer, data, fillHander) {
        if (!data || !data.$options || !answer || GLOBAL.stop || data.active && !data.active()) return false;
        const parsed = parseAiAnswer(answer, data);
        if (!parsed.valid) return answerFillFailure(data, parsed.error);
        data.aiParsedAnswer = parsed.value;
        if (parsed.indexes) return applyChoiceIndexes(parsed.indexes, data, fillHander, data.ignore_click);
        const answers = data.type === 2 ? splitBlankAnswers(parsed.value, data.$options.length) : [parsed.value];
        return fillTextAnswers(answers, data, fillHander);
    }

    // 这里原来有个 resolveFirstInQueue()：AI 出错时 shift() 摘队头、调 item.resolve()。
    // 两头都是空的 —— queueItem.resolve 是 `() => {}`，没人 await；waitForAiAnswer 是
    // 轮询 GLOBAL.aiAnswerFilled 的，不看 promise。所以它唯一的真实作用就是摘掉队头，
    // 而队头未必是出错那道题：父页面的 GM 请求 timeout 是 30s，引擎只等 25s，
    // 第 5 题超时后引擎已经翻到第 6 题并入队，此时第 5 题的 ontimeout 摘走的是第 6 题的项。
    // 它还绕过 dequeueAiFill，不清 currentPendingItem，留个悬空指针。
    // 出错时的清理本来就有人管：两条等待路径等完都会 dequeueAiFill(queueItem)，填成没填成都摘。
    // 失败通过带题干/时间的 aiFailure 通知轮询,面板用 requestId 丢弃旧响应。

    window.addEventListener("message", event => {
        if (!event.data || typeof event.data !== "object") return;
        if (event.data.yktHomeworkRun && (!GLOBAL.yktHomeworkRun
            || event.data.yktHomeworkRun !== GLOBAL.yktHomeworkRun.token || !GLOBAL.yktHomeworkRun.active())) return;
        if (event.data.type === "jump") {
            GLOBAL.index++;
            iframeMsg("tip", {
                tip: "准备答第" + (GLOBAL.index + 1) + "题"
            });
        } else if (event.data.type === "stop") {
            GLOBAL.stop = event.data.val;
            console.log('✅ 暂停状态已更新:', GLOBAL.stop);
        } else if (event.data.type === "start_pay") {
            if (event.data.flag) {
                if (String(GM_getValue("E196FD8B49")).length === 10 || String(GM_getValue("E196FD8B491")).length === 11) {
                    iframeMsg("tip", {
                        tip: "扫码可以请我喝杯茶哦"
                    });
                    GM_setValue("start_pay", event.data.flag);
                    iframeMsg("start_pay", true);
                } else {
                    iframeMsg("tip", {
                        tip: "扫码可以请我喝杯茶哦"
                    });
                }
            } else {
                iframeMsg("tip", {
                    tip: "扫码可以请我喝杯茶哦"
                });
                GM_setValue("start_pay", event.data.flag);
                iframeMsg("start_pay", false);
            }
        } else if (event.data.type === "auto_jump") {
            GM_setValue("auto_jump", event.data.flag);
            iframeMsg("tip", {
                tip: "已" + (event.data.flag ? "开启" : "关闭") + "自动切换,页面刷新后生效"
            });
        } else if (event.data.type === "confim") {
            if (event.data.token.length === 10 || event.data.token.length === 11) {
                GM_setValue("E196FD8B49", event.data.token);
                iframeMsg("tip", {
                    tip: "扫码可以请我喝杯茶哦"
                });
            } else {
                iframeMsg("tip", {
                    tip: "扫码可以请我喝杯茶哦"
                });
            }
        } else if (event.data.type === "save_setting") {
            // 存档只走 PANEL_SETTINGS 这一张表。以前是 19 行手写 GM_setValue 加一个只管视频的
            // 循环，加一个设置要在这里补一行，漏了就是"面板上填了但不起作用"——查起来最费时间的
            // 一类 bug，因为面板显示得好好的。现在表里有的一定存，表里没有的根本存不进来。
            // panelNorm 顺手做两件事：
            //   · text/password 擦掉两头空格。粘贴来的地址和 key 十有八九带空格，而
            //     fillAnswer 里的 lockedHasApiKey 只判真假，" " 是真值 —— 引擎会以为配好了，
            //     然后带着个空 Bearer 一道道题去请求
            //   · 数字项夹回 min/max。面板已经限了，但存档可能来自改过代码的旧版本
            PANEL_SETTINGS.forEach(s => {
                if (event.data[s.key] === undefined) return;
                const v = panelNorm(s, event.data[s.key]);
                GM_setValue(s.key, v);
                // 擦过夹过的值要写回 event.data：下面 settings_updated 把它整个回传给面板，
                // 不写回的话面板拿到的还是用户填的原值，和存档对不上
                event.data[s.key] = v;
            });

            // 这里原来还往 GLOBAL 上抄一份，注释写着"立即更新运行时配置（无需刷新）"——
            // 可这十个键全脚本没有一处读 GLOBAL.xxx，引擎（fillAnswer / doSearch 那边）
            // 每次都是现读 GM_getValue，存进去本来就已经生效了。抄的那份是死的，删掉，
            // 不然下次谁要改"配置不生效"，会去改那段没人读的代码。
            // 倍速是唯一一个"在正在跑的东西身上马上看得见"的设置：别的键要等下一个任务点
            // 才用到，这个键改了就该当场听出来。不推的话用户看到的是"存下来了，视频还是原速"，
            // 而他没法知道到底是没存上还是没生效。
            if (["cx_video_rate", "cx_rate_preset"]
                .some(key => event.data[key] !== undefined)) {
                // 推给播放器的必须是播放器能到的那个数（live=true）。存档里那个可以更大 ——
                // 关掉复习模式走补报就用满了，所以不在存的时候把它压小。
                const live = cxVideoRate(true);      // 播放器能跑到的
                const full = cxVideoRate(false);     // 接口补报按的
                if (zhsHosts()) {
                    // 这一栏在超星页面是超星倍速,但面板首屏只露出这一栏 —— 在智慧树页面上它就是
                    // 用户唯一够得到的倍速入口,所以这里当智慧树倍速处理:走 zhsRate()(夹到 1.5,
                     // 因为页面每拍查 playbackRate > 1.8 会弹"异常脚本"踢人(第142轮起不再由脚本夹),
                    // 16 倍推过去就是撞闸)。直设顶层播放器,够不着才广播给帧代理。
                    // 同一平台的两个入口以本次修改为准,避免旧的「智慧树倍速」盖过新值。
                    zhsPushRate(full);
                } else if (yktHost()) {
                    yktPushRate();
                } else {
                    const n = cxApplyRate(live);
                    // 同源直设之外再广播一腿(跨域帧够不着但发得出去)——
                    // 帧代理收到后把帧里那个 <video> 调过去
                    const sent = cxRateBroadcast(live);
                    const head = n ? "已应用到页面上 " + n + " 个播放器"
                        : sent ? "页面上没有同域直达的播放器，已向 " + sent
                            + " 个播放器框架发倍速广播（跨域，下一拍生效）"
                        : "当前未确认播放器已应用，播放器加载后按新设置播放";
                    logMsg("倍速改成 " + live + " 倍，" + head
                        + (full > live ? "（当前平台自动播放最高 " + live + " 倍）" : ""));
                }
            }
            // 智慧树倍速的 live 通路:面板上改了当场生效,不用等下一节。
            // 只直接写 playbackRate,绝不点播放器菜单:智慧树的播放器容器上挂着"非可信点击"
            // 检测,合成 click 一碰就弹"检测到异常脚本"并踢回首页。zhsWatchVideo 每拍还会钉一次,
            // 所以这里设一次就够;够不着(播放器在跨域帧里)才广播给帧代理。
            if (event.data.zhs_video_rate !== undefined) {
                if (zhsHosts() && event.data.cx_video_rate === undefined) {
                    zhsPushRate(cxSet("zhs_video_rate"));
                } else if (!zhsHosts()) zhsPushRate(cxSet("zhs_video_rate"));
            }
            iframeMsg("settings_updated", event.data);
            console.log('✅ 配置已保存');
        } else if (event.data.type === "ai_request") {
             // 面板的「测试连接」也走这条路（沙箱 iframe 自己 fetch 会被混合内容拦掉，必须借引擎的
             // GM_xmlhttpRequest）。带 test:true 的请求，回话时原样把这个标记带回去，面板据此把
             // 响应分流到 recvAiTest，不进聊天、不触发填充。respond 把标记统一并到每个回话点上。
             const isTest = !!event.data.test;
             const homeworkRun = GLOBAL.yktHomeworkRun;
             const respond = o => {
                 if (homeworkRun && !homeworkRun.active()) return;
                 iframeMsg("ai_response", Object.assign({ test: isTest, requestId: event.data.requestId }, o));
             };
             // 只有 aip.baidubce.com (原生接口) 需要 access_token，qianfan.baidubce.com (兼容接口) 走标准 Bearer
             const apiKey = (event.data.api_key || '').trim();
             // 地址也兜一下：旧存档可能带空格，而 undefined.includes 会在监听器里直接抛、
             // 把后面所有分支一起带走（同一个 listener 里连 save_setting 都不响应了）
             const apiUrl = (event.data.api_url || '').trim();
             const isNativeBaidu = apiUrl.includes('aip.baidubce.com');
             // 只填到 .../v1 的自定义地址在这儿补上 /chat/completions，否则 POST /v1 会 404
             const requestUrl = isNativeBaidu ? (apiUrl + "?access_token=" + apiKey) : aiChatUrl(apiUrl);
             const requestHeaders = {
                 "Content-Type": "application/json"
             };
             // 如果不是原生百度接口，都添加 Authorization 头 (包括千帆 V2 兼容接口)
             if (!isNativeBaidu) {
                 requestHeaders["Authorization"] = "Bearer " + apiKey;
             }

             const requestData = {
                 messages: event.data.messages,
                 stream: false
             };
             if (!isNativeBaidu) {
                 requestData.model = event.data.model;
             }

             console.log('AI请求参数:', requestUrl, 'model:', event.data.model, 'apiKey长度:', apiKey.length);
             // "AI 怎么不动"最常见的三个原因：地址填错、key 是空的、模型名不对。
             // key 只记长度，不记内容 —— 日志是能导出的，别把密钥写进去。
             logMsg('AI 请求 → ' + (requestUrl.split('?')[0] || '(地址为空)')
                 + '，模型 ' + (event.data.model || '(未指定)')
                 + '，key 长度 ' + apiKey.length,
                 (!requestUrl || !apiKey.length) ? 'error' : undefined, "AI");
             
             // 单请求重试：照搬平时分 pfCallAi 的策略——最多 3 次、1500×tries 退避；只对 超时/onerror/429/5xx
             // 重试，401/403 等其它 4xx 不重试（交面板按 token 无效处理）。退避间隔再按当前报错率乘 aiBackoffMult()。
             // 无论重试几次，最终只回一条 ai_response；只有"重试到底的结论"喂进报错率统计。
             const AI_MAX_TRIES = 3;
             let aiTries = 0, aiSettled = false;
             const aiDone = o => {
                 if (aiSettled) return;
                 aiSettled = true;
                 GM_setValue('aiRetryBeat', 0);   // 收尾，撤掉心跳
                 // 「测试连接」不计入答题报错率（手动、偶发）；401/403 token 失效也不计入——
                 // 它由 aiKeyBad 挡在发请求前、属于"配置问题"不是"接口抖动"，混进退避统计只会误放慢好接口。
                 if (!isTest && !o.authErr) { aiStatPush(!!o.success); aiStatNote(); }
                 respond(o);
             };
             function aiRetry(reason) {
                 // 「测试连接」要快速给反馈，不重试（否则坏地址会卡成好几分钟）；答题路才重试。
                 if (isTest || aiTries >= AI_MAX_TRIES) {
                     if (!isTest) logMsg('AI 第 ' + aiTries + ' 次仍失败：' + reason + '，放弃', 'error', "AI");
                     aiDone({ success: false, error: reason });
                     return;
                 }
                 const delay = Math.round(1500 * aiTries * aiBackoffMult());
                 logMsg('AI 第 ' + aiTries + ' 次失败：' + reason + '，约 ' + Math.round(delay / 1000)
                     + 's 后重试（' + aiTries + '/' + AI_MAX_TRIES + '）', 'warn', "AI");
                 GM_setValue('aiRetryBeat', Date.now());  // 心跳：让面板 waitForAiAnswer 别在重试途中判超时跳题
                 setTimeout(aiAttempt, delay);
             }
             function aiAttempt() {
                 aiTries++;
                 GM_setValue('aiRetryBeat', Date.now());
                 GM_xmlhttpRequest({
                    method: "POST",
                    url: requestUrl,
                    headers: requestHeaders,
                    data: JSON.stringify(requestData),
                    timeout: 120000,  // 120 秒：跟「AI 等待上限」默认对齐，自部署接口冷启动几十秒也接得住
                    onload: function(response) {
                        console.log('AI响应状态:', response.status, '响应内容前200字符:', response.responseText.substring(0, 200));

                        // 429 / 5xx：接口过载或临时故障，属于"再打一次可能就好"，走重试
                        if (response.status === 429 || response.status >= 500) {
                            aiRetry('HTTP ' + response.status);
                            return;
                        }
                        // 其它非 200（含 401/403 等）：不重试，原样回错给面板，由 isAiKeyErr/aiKeyBad 判 token 无效。
                        // 401/403 标 authErr，aiDone 据此不计入报错率退避统计。
                        if (response.status !== 200) {
                            aiDone({
                                success: false,
                                authErr: response.status === 401 || response.status === 403,
                                error: 'HTTP错误 ' + response.status + ': ' + response.responseText.substring(0, 200)
                            });
                            return;
                        }

                        // 特殊处理 Baidu ResourceNotFound
                        if (response.responseText.includes('ResourceNotFound')) {
                            aiDone({
                                success: true,
                                response: JSON.stringify({
                                    error: { message: "Resource not found. 请检查'模型名称'是否正确，或者该模型是否已开通(如 ernie-speed-8k)" }
                                })
                            });
                        } else {
                            console.log('AI请求成功，发送响应给Vue:', response.responseText.substring(0, 100));
                            aiDone({ success: true, response: response.responseText });
                            // 解析和填充都在面板那边：ai_response -> 解析 choices -> 回发 ai_fill -> handleAiFill。
                        }
                    },
                    onerror: function(e) {
                        // GM_xmlhttpRequest 的网络级失败常给一个空对象（没 error/statusText/status），
                        // 直接拼就成了没法查的 "出错: undefined"。这种失败清一色是"请求根本没发出去/没回来"：
                        // 地址写错、域名解析不了、接口挂了、或自定义接口没放行跨域。走重试，仍失败再给能查的话。
                        e = e || {};
                        console.log('AI请求错误:', 'status=' + e.status, 'statusText=' + e.statusText, 'error=' + e.error);
                        var detail = e.error || e.statusText || (e.status ? 'HTTP ' + e.status : '');
                        aiRetry(detail
                            ? ('AI 请求出错：' + detail)
                            : 'AI 请求发不出去：连不上接口。检查接口地址对不对、网络通不通、接口是不是挂了'
                              + '（自定义接口还要确认它允许跨域访问）');
                    },
                    ontimeout: function() {
                        console.log('AI请求超时（' + (120000 / 1000) + '秒）');
                        aiRetry('AI请求超时，请稍后重试');
                    }
                 });
             }
             aiAttempt();
        } else if (event.data.type === "ai_fill") {
            // AI 返回答案后自动填充
            console.log('收到 ai_fill 消息, error:', event.data.error);
            
            if (event.data.error) {
                const pending = GLOBAL.currentPendingItem;
                if (pending && (pending.data && pending.data.active && !pending.data.active()
                    || event.data.question && pending.questionText !== event.data.question)) return;
                // 失败信号与当前题目绑定,不让轮询再等满超时,也不摘掉另一题的队列项。
                console.log('AI请求失败，设置空答案');
                GM_setValue('lastAiAnswer', '');
                GM_setValue('lastAiAnswerTime', Date.now());
                GLOBAL.lastAiAnswer = '';
                GLOBAL.aiFailure = { question: event.data.question || '', time: Date.now() };
                logMsg('AI 请求失败：' + (event.data.reason || '请查看面板 AI 页的接口错误信息'), 'error', "AI");
                iframeMsg("update_answer", { index: pending ? pending.questionIndex - 1 : GLOBAL.index - 1,
                    answer: "", style: "warning-row", aiError: event.data.reason || "AI 请求失败,请查看 AI 页" });
                if (GLOBAL.yktHomeworkRun) yktHomeworkPause("AI 请求失败,请在 AI 页查看错误并检查设置,再点继续重试当前题");
            } else {
                handleAiFill(event.data.answer, event.data.question);
            }
        }
    }, false);
    // 裸按键快捷键（↑↓←→ 藏/显、S/D 停/开）。这些是对用户承诺过的功能，留着 ——
    // 但原来既不看修饰键也不看事件源：在简答题输入框里打个 "s" 就把引擎暂停了，
    // 打个方向键面板就没了，而方向键在文本框里是最常按的键。所以先挡两道。
    // #model-id 那层容器没了，藏/显改走面板自己的 setVisual（一个视觉状态一个主人）。
    $(document).keydown(function(event) {
        const t = event.target;
        if (t && (/^(INPUT|TEXTAREA|SELECT)$/.test(t.tagName) || t.isContentEditable)) return;
        if (event.ctrlKey || event.altKey || event.metaKey || event.shiftKey) return;
        // S / D 不碰面板句柄：开机那十几秒面板还没建起来，这两个键也该能停下引擎
        if (event.keyCode === 83 || event.keyCode === 68) {
            GLOBAL.stop = event.keyCode === 83;
            if (yktHost()) yktHomeworkPost({ type: "stop", val: GLOBAL.stop });
            iframeMsg("stop", GLOBAL.stop);
            return;
        }
        if (!PANEL) return;
        if (event.keyCode === 38) {
            PANEL.setVisual("hidden");
        } else if (event.keyCode === 40) {
            PANEL.setVisual("normal");
        } else if (event.keyCode === 37) {
            PANEL.setVisual("hidden");
            GM_setValue("hide", true);
        } else if (event.keyCode === 39) {
            // 右方向键是最后一根救命绳（vm.hideTip 那条提示语就写着它）：
            // 除了显示出来，还把位置拨回左上角 —— 坐标落在屏幕外时光"显示"是看不见的
            PANEL.setVisual("normal");
            GM_setValue("hide", false);
            PANEL.moveTo(50, 50);
        }
    });
    function setIntervalFunc(flag, func, time) {
        const interval = setInterval(() => {
            if (flag()) {
                clearInterval(interval);
                func();
            }
        }, time || 1e3);
    }
    function getAnswer(str, options, type) {
        if (type === 0 || type === 1) {
            const indexes = plainLetterIndexes(str, options.length);
            const ans = indexes ? indexes.map(index => options[index]) : [];
            return ans.length > 0 ? ans : [ str ];
        } else {
            return [ str ];
        }
    }
    function getQuestionType(str) {
        if (!str) return undefined;
        str = String(str).normalize("NFKC").toLowerCase().replace(/\s+/g, "");
        const normalize = k => k.normalize("NFKC").toLowerCase().replace(/\s+/g, "");
        // 题号旁标签在最前面，不能被后面题干里提到的更长题型名称盖过。
        const candidates = Object.keys(TYPE).map(key => ({ key, at: str.indexOf(normalize(key)), length: normalize(key).length }))
            .filter(item => item.at >= 0).sort((a, b) => a.at - b.at || b.length - a.length);
        if (candidates.length) return TYPE[candidates[0].key];
        return undefined;
    }
    function rand(m, n) {
        return Math.ceil(Math.random() * (n - m + 1) + m - 1);
    }
    const TYPE = {
        "阅读理解（选择）/完型填空": 66,
        "听力训练": 66,
        multichoice: 1,
        multiplechoice: 1,
        singlechoice: 0,
        bijudgement: 3,
        judgement: 3,
        judgment: 3,
        truefalse: 3,
        fillblank: 2,
        fillintheblank: 2,
        shortanswer: 4,
        essay: 4,
        "單選": 0,
        "多選": 1,
        "判斷": 3,
        "簡答": 4,
        "不定项选择": 1,
        "不定項選擇": 1,
        "不定项": 1,
        "不定項": 1,
        "单项选择题": 0,
        "单项选择": 0,
        "单选题": 0,
        "单选": 0,
        "多选": 1,
        "多选题": 1,
        "多项选择题": 1,
        "多项选择": 1,
        "填空题": 2,
        "填空": 2,
        "对错题": 3,
        "判断题": 3,
        "判断正误": 3,
        "判断": 3,
        "主观题": 4,
        "问答题": 4,
        "简答题": 4,
        "名词解释": 5,
        "论述题": 6,
        "计算题": 7,
        "其它": 8,
        "分录题": 9,
        "资料题": 10,
        "连线题": 11,
        "排序题": 13,
        "完形填空": 14,
        "完型填空": 14,
        "阅读理解": 15,
        "口语题": 18,
        "听力题": 19,
        "A1A2题": 0,
        "文件作答": 8
    };
    function sleep(time) {
        return new Promise(resolve => {
            setTimeout(resolve, time);
        });
    }
    
    // 只进面板日志，不刷头部状态行。给"诊断"用 —— 这类信息比状态多，
    // 走 iframeMsg("tip") 会把状态行冲成流水，反而什么都看不清。
    // 【注意】级别走 level，绝不能借用 type：面板那边 type 是"副作用指令"——
    // 'stop' 会把 opt.stop 置真（真的暂停答题）、'error' 会置 need_jump、
    // 'hidden' 会把面板藏了。拿它当日志级别用，写条日志就把脚本停了。
    // 这条日志是哪个平台/环节出来的 —— 给面板日志加「来源」标签用，发日志来一眼能定位。
    // 纯按 hostname 判，任何页面调都安全（zhsHosts/icveHost/yktHost 都是 hostname 谓词）。
    function logSrc() {
        try {
            if (zhsHosts()) return "智慧树";
            if (icveHost()) return "职教云";
            if (yktHost()) return "雨课堂";
            if (/chaoxing/i.test(location.hostname)) return "超星";
        } catch (e) {}
        return "通用";
    }
    function logMsg(text, level, src) {
        // 同时进控制台。排障时用户手上通常只有 F12 那一坨输出，面板日志在闭合 shadow 里
        // 选不中也复制不出来 —— 真机第一次反馈来的日志里一条视频进度都没有，就是这个原因。
        // （面板另给了「⬇ 导出」按钮出 CSV，但要用户先想到点它；控制台是白捡的。）
        src = src || logSrc();
        console.log("[助手][" + src + "]" + (level ? "[" + level + "]" : "") + " " + text);
        // src：来源标签（面板日志按它分组/筛选）；ctx：当前卡在哪一步（第几题/哪一节），由
        // GLOBAL.logCtx 挂着的话一起带过去，让"切节失败""AI 超时"这类能对上是哪道题/哪一节。
        iframeMsg("tip", { tip: text, level: level, logOnly: true, src: src, ctx: GLOBAL.logCtx || "" });
    }

    // 后台不中断。Chrome 会把不可见标签页的 setTimeout/setInterval 节流到最慢每分钟一次，
    // 而这份脚本的全部节奏都靠 sleep()：搜题间隔、fillAnswerDelay、等 AI 的轮询。
    // 窗口一最小化，答题就等于停在那儿 —— 不是坏了，是计时器被掐了。
    // 正在输出音频的标签页不吃这个节流，所以答题期间挂一路近乎无声的音频占住"有声"这个身份。
    //
    // ponytail: 用 Web Audio 起一个振荡器，而不是像别的脚本那样塞一段 base64 音频文件
    // （省十几 KB，也不用应付 <audio> 的自动播放拦截）。20Hz 在多数扬声器的响应下限之外，
    // 0.0015 的增益也远低于能听见的程度，但仍高于 Chrome 判"静音"的门限
    // （约 -72dBFS ≈ 振幅 0.00024）—— 高过那条线是它愿意把标签页算作有声的前提。
    // 上限：这个门限是 Chrome 的内部实现，哪天它改成按更高音量判定，这招就失效了；
    // 那时的退路是把 gain 调到 0.05 这种真能听见的量级，用体验换可靠。
    let keepAwakeCtx = null, keepAwakeSaid = "";
    // 状态变了才说一句，并且非要等面板真挂起来才说。面板现在是同步建的，但 showPanel()
    // 自己被裹在 setTimeout 里，而保活是用户第一次点页面就触发 —— 用户手快过那个定时器
    // 是常事，此时 PANEL 还是 null，iframeMsg 返回 false。所以这个重试不能删，
    // 只是等待时间从"六个 CDN 竞速"缩到"一个 setTimeout"。
    function keepAwakeSay() {
        const st = keepAwakeCtx ? keepAwakeCtx.state : "无";
        if (st === keepAwakeSaid) return;
        const running = st === "running";
        const okSent = iframeMsg("tip", {
            tip: running
                ? "后台保活已开启，可以最小化窗口（标签页上会出现小喇叭）"
                : "后台保活待激活：在页面上点一下鼠标就行（不点的话最小化后答题会变慢）",
            level: running ? undefined : "warn",
            logOnly: true
        });
        if (okSent) keepAwakeSaid = st;
        else setTimeout(keepAwakeSay, 2000);
    }
    // 一次手势就够。用 once 让浏览器自己摘监听，省得自己管；
    // 三种事件都认，只认 click 的话先敲键盘或拖滚轮的用户等不到激活。
    function armKeepAwakeGesture() {
        ["pointerdown", "keydown", "click"].forEach(ev =>
            document.addEventListener(ev, keepTabAwake, { once: true, capture: true }));
    }
    function keepTabAwake() {
        if (keepAwakeCtx && keepAwakeCtx.state === "running") return;   // 已经在响了
        const AC = window.AudioContext || window.webkitAudioContext;
        if (!AC) {
            logMsg("后台保活不可用：这个浏览器没有 Web Audio，最小化后答题会变慢", "warn");
            return;
        }
        try {
            if (!keepAwakeCtx) {
                // Chrome 在页面还没发生过任何用户手势时，连 new AudioContext() 本身都会往
                // 控制台打一条 "The AudioContext was not allowed to start"，紧跟着 resume()
                // 再打一条 —— 真机日志里那两条就是这么来的，而它们其实是预期行为，
                // 只是白占了控制台、也容易被当成 bug。所以手势之前干脆什么都不建。
                const ua = navigator.userActivation;
                if (ua && !ua.hasBeenActive) {
                    armKeepAwakeGesture();
                    keepAwakeSay();      // 告诉用户"点一下就行"
                    return;
                }
                const ctx = new AC();
                const osc = ctx.createOscillator(), gain = ctx.createGain();
                osc.frequency.value = 20;
                gain.gain.value = .0015;
                osc.connect(gain);
                gain.connect(ctx.destination);
                osc.start();
                keepAwakeCtx = ctx;
                // 老浏览器没有 navigator.userActivation，走不到上面那个早退 ——
                // 那就还是先试一次、失败挂手势重试（这条路必须留着）
                armKeepAwakeGesture();
            }
            keepAwakeCtx.resume().then(keepAwakeSay, keepAwakeSay);
        } catch (e) {
            logMsg("后台保活开启失败：" + e, "warn");
        }
    }

    // 面板消息入口。名字和签名一个字没改 —— 全脚本 60 多处调用点不用动。
    // 换掉的只是里面这一句：以前是 iframe.contentWindow.vueDefinedProp(...)，要先确认
    // 跨文档的 Vue 挂好了，没挂好就打一行"面板未就绪，延迟重试"再等 500ms 试一次 ——
    // 而 Vue 走 CDN 竞速常常慢过那 500ms，提示是真的丢过。现在面板和它同文档同一拍建好，
    // 不存在"未就绪"这个状态，重试那段整段删掉。
    // 正文帧（/knowledge/cards）里没有自己的面板 —— 面板挂在顶层学习页上。参考实现那套刷课架构里
    // 干活的恰恰是正文帧（见 cxStudyFrame），它的日志 / 任务行 / 进度条得转给顶层那份去画。
    // 只转这三类：别的 type 在面板那边是"副作用指令"（stop 会真暂停答题、hidden 会把面板藏了），
    // 放它们跨帧过去，等于让一个子帧能踩顶层的刹车。cxRelayTo 只在 cxStudyFrame 里被设上，
    // 别的帧照旧是"没面板就返回 false"（keepAwakeSay 靠这个 false 重试，不能被这里改成 true）。
    const CX_RELAY_TYPES = { tip: 1, task: 1, progress: 1 };
    let cxRelayTo = null;
    function cxRelay(type, message) {
        if (!CX_RELAY_TYPES[type]) return false;
        try {
            // 目标限死同源：学习页和正文帧同一个域，别的域的窗口一律收不到
            cxRelayTo.postMessage({ cxRelay: 1, type: type, message: message }, location.origin);
            return true;
        } catch (e) {
            return false;
        }
    }
    // 每道题一个稳定的行键：顺序/重试/异步回填都靠它把答案落到正确的那一行，而不是靠"第几个 push"
    // 的数字下标——数字下标一旦因为重试(index--)多 push 了一行，就会整体错位、把后面题的答案盖到前面题。
    // epoch 每次脚本载入(每翻一页是真的重载)重取,所以跨页不会撞键;同一页里同一题号恒定,重试会合并到同一行。
    function rowKeyFor(qnum) {
        if (!GLOBAL.rowEpoch) GLOBAL.rowEpoch = Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
        return GLOBAL.rowEpoch + ":" + qnum;
    }
    function iframeMsg(type, message) {
        try {
            const run = GLOBAL.yktHomeworkRun;
            if (run && run.active() && run.questionKey && (type === "push" || type === "update_answer")) {
                message = Object.assign({}, message, { rowKey: run.token + ":" + run.questionKey });
            } else if (type === "push" && message && message.rowKey === undefined && GLOBAL.index) {
                // 非雨课堂的普通答题：每个 push 盖一个稳定行键(基于当前题号),让面板 addRow 能按键去重、
                // update_answer 能按键回填到正确行。update_answer 由各发送点自带匹配的 rowKey(见 rowKeyFor)。
                message = Object.assign({}, message, { rowKey: rowKeyFor(GLOBAL.index) });
            }
            if (yktHomeworkRelay(type, message)) return true;
            if (!PANEL) return cxRelayTo ? cxRelay(type, message) : panelRelay(type, message);
            PANEL.recv(type, message);
            return true;
        } catch (e) {
            // 一条提示画崩了不能把答题带停：这函数在 doSearch / fillAnswer 的主循环里
            console.error('iframeMsg 发送失败:', type, e);
            return false;
        }
    }
    function filterImg(dom) {
        if (location.host === "ncexam.cug.edu.cn") {
            String.prototype.trim = function() {
                return this.replace(/^\s+|\s+$/gm, "");
            };
        }
        return $(dom).clone().find("img[src]").replaceWith(function() {
            return $("<p></p>").text('<img src="' + $(this).attr("src") + '">');
        }).end().find("iframe[src]").replaceWith(function() {
            return $("<p></p>").text('<iframe src="' + $(this).attr("src") + '"></irame>');
        }).end().text().trim();
    }
    // 存下来的位置可能是坏的："30px," / "," / undefined（旧版本没拖动也存一次，
    // 存出来就是个逗号）。这种值赋给 style.left 是空串，position:fixed 的面板会掉回文档流。
    function readPos(raw, dft) {
        const p = String(raw == null ? "" : raw).split(",");
        return /^-?\d/.test(p[0]) && /^-?\d/.test(p[1] || "") ? p : (dft || ["30px", "30px"]);
    }

    function defaultWorkTypeResolver($options) {
        const found = new Set();
        const selector = 'input[type="radio"],input[type="checkbox"],[role="radio"],[role="checkbox"],textarea,input[type="text"],input:not([type]),[contenteditable="true"]';
        for (const option of $options || []) {
            if (!option || !option.matches) continue;
            if (option.matches(selector)) found.add(option);
            option.querySelectorAll(selector).forEach(el => found.add(el));
            // 只查所属选项,不能把整道题同一个父节点的输入框重复计数。
            const label = option.closest('label,.el-radio,.el-checkbox,.ant-radio-wrapper,.ant-checkbox-wrapper');
            if (label) label.querySelectorAll(selector).forEach(el => found.add(el));
        }
        const count = selector => Array.from(found).filter(el => el.matches(selector)).length;
        const radios = count('input[type="radio"],[role="radio"]'), checks = count('input[type="checkbox"],[role="checkbox"]');
        if (radios && !checks) return 0;
        if (checks && !radios) return 1;
        if (radios || checks) return undefined;
        if (count('textarea,[contenteditable="true"]')) return 4;
        if (count('input[type="text"],input:not([type])')) return 2;
        return undefined;
    }
    function resolveQuestionType(data) {
        const raw = data.type, label = getQuestionType(data.typeLabel);
        let type = typeof raw === "number" ? raw : typeof raw === "string" && /^\d+$/.test(raw.trim()) ? Number(raw) : getQuestionType(raw);
        const controls = defaultWorkTypeResolver(data.$options);
        data.typeConflict = "";
        if (!Number.isFinite(type)) type = label ?? controls;
        if ([0, 1].includes(type) && [0, 1].includes(controls) && controls !== type) {
            if ([0, 1].includes(label)) data.typeConflict = "页面题型标注与选项控件不一致，请复核后作答";
            else { logMsg("题型已按当前选项控件校正为" + (controls === 1 ? "多选题" : "单选题")); type = controls; }
        }
        data.type = type;
        data.choiceMin = type === 1 && !/不定项|不定項|one\s*or\s*more/i.test(data.typeLabel || "") ? 2 : 1;
        data.blankCount = type === 2 && data.$options ? data.$options.length : undefined;
        return type;
    }
    // 第三方题库适配器（面板「题库适配器 URL」那一栏）。
    // ponytail: 响应形状是容忍式解析，不锁死一种协议 —— 常见的 tikuAdapter 类服务
    // 把答案放在 answer.bestAnswer / answer.answerText / answer.answerKey 里，
    // 也有直接返 { answer: [...] } 或裸数组的。按这个顺序取第一个非空的。
    // 你的适配器如果都不是这几种形状，改 pick() 里那个候选列表就行。
    function tikuAdapterNormalize(res) {
        if (!res) return [];
        if (Array.isArray(res)) return res.length ? [ res.map(String) ] : [];
        const a = res.answer;
        const pick = [ a && a.bestAnswer, a && a.answerText, a && a.answerKey, a, res.answers, res.result ];
        for (const c of pick) {
            if (Array.isArray(c) && c.length) return [ c.flat().filter(x => x != null).map(String) ];
            if (typeof c === "string" && c.trim()) return [ [ c.trim() ] ];
        }
        return [];
    }
    // n1t 题库（tk.n1t.cn）。要去 tk.n1t.cn 注册拿 key —— 没有匿名额度，
    // 不带 key 直接返 {code:401,"API密钥不能为空"}。key 上带每日免费额度，用完要充值。
    // 契约是 form-urlencoded：question / key / type(中文题型名) / options(JSON 数组字符串)。
    // 成功时 {code:1, data:[{answer:"..."}] 或 "字符串", quota_info:{...}}。
    const N1T_TYPE = { 0: '单选题', 1: '多选题', 2: '填空题', 3: '判断题', 4: '简答题', 5: '简答题' };
    function n1tNormalize(res) {
        if (!res || res.code != 1) return [];
        const d = res.data;
        let ans = null;
        if (Array.isArray(d) && d.length) {
            // 官方脚本里 data[0].question 在没答案时是"抱歉无答案"，得当没搜到
            ans = d[0].answer || (d[0].question !== "抱歉无答案" ? d[0].question : null);
        } else if (typeof d === "string") {
            ans = d;
        } else if (d && typeof d === "object") {
            ans = d.answer;
        }
        if (!ans || String(ans).includes("无答案")) return [];
        // 多空/多选用 # 分隔，跟本脚本 [[答案1,答案2]] 的契约对齐
        const parts = String(ans).split(/#+/).map(s => s.trim()).filter(Boolean);
        return parts.length ? [ parts ] : [];
    }
    function n1tSearch(key, data) {
        const body = 'question=' + encodeURIComponent(data.question || '')
            + '&key=' + encodeURIComponent(key)
            + '&type=' + encodeURIComponent(N1T_TYPE[data.type] || '单选题')
            + '&options=' + encodeURIComponent(JSON.stringify(data.options || []));
        return new Promise(resolve => {
            GM_xmlhttpRequest({
                method: "POST",
                url: "https://tk.n1t.cn/api/search.php",
                headers: { "Content-Type": "application/x-www-form-urlencoded" },
                data: body,
                timeout: GLOBAL.timeout,
                onload: function(r) {
                    let res;
                    try { res = JSON.parse(r.responseText); } catch (e) {
                        logMsg('n1t 题库：响应不是 JSON（' + r.responseText.substring(0, 60) + '）', 'warn');
                        return resolve([]);
                    }
                    // key 失效/额度耗尽要让用户看见，否则只会觉得"题库怎么不出答案"
                    if (res.code == 401 || res.code == 403) {
                        logMsg('n1t 题库：' + (res.message || 'key 无效'), 'error');
                    } else if (res.quota_info && res.quota_info.remaining === 0) {
                        logMsg('n1t 题库：次数已用完，需去 tk.n1t.cn 充值', 'warn');
                    }
                    const out = n1tNormalize(res);
                    if (res.quota_info) {
                        logMsg('n1t 题库：' + (out.length ? '命中' : '无答案')
                            + '，剩余 ' + res.quota_info.remaining
                            + '（免费 ' + res.quota_info.free_remaining + '）');
                    }
                    resolve(out);
                },
                // 挂了当它没返回结果 —— 上面 formatSearchAnswer 那层还有 5 秒超时兜着
                onerror: function() { resolve([]); },
                ontimeout: function() { resolve([]); }
            });
        });
    }

    function tikuAdapterSearch(url, data) {
        return new Promise(resolve => {
            GM_xmlhttpRequest({
                method: "POST",
                url: url,
                headers: { "Content-Type": "application/json;charset=utf-8" },
                data: JSON.stringify({
                    question: data.question,
                    options: Array.isArray(data.options) ? data.options.join("\n") : data.options,
                    type: data.type
                }),
                timeout: GLOBAL.timeout,
                onload: function(r) {
                    try {
                        const out = tikuAdapterNormalize(JSON.parse(r.responseText));
                        console.log("题库适配器返回", JSON.stringify(out));
                        // 适配器是用户自己填的地址，通没通、返回认不认得出来，
                        // 不给个反馈的话只能对着"填了没反应"发呆
                        logMsg(out.length ? '题库适配器：返回 ' + out[0].length + ' 条答案'
                                          : '题库适配器：返回了但没解析出答案（响应格式可能对不上）',
                               out.length ? undefined : 'warn');
                        resolve(out);
                    } catch (e) {
                        console.log("题库适配器响应解析失败:", e.message, r.responseText.substring(0, 120));
                        resolve([]);
                    }
                },
                // 适配器挂了当它没返回结果就行 —— 上面 formatSearchAnswer 那层还有 5 秒超时兜着
                onerror: function() { resolve([]); },
                ontimeout: function() { resolve([]); }
            });
        });
    }
    function waitWithTimeout(promise, timeout, timeoutMessage = "timeout", defaultRes) {
        let timer;
        const timeoutPromise = new Promise((resolve, reject) => {
            timer = setTimeout(() => defaultRes === undefined ? reject(timeoutMessage) : resolve(defaultRes), timeout);
        });
        return Promise.race([ timeoutPromise, promise ]).finally(() => clearTimeout(timer));
    }
    const questionBankUploads = new Set();
    function uploadQuestionBankCandidate(data, answer, source) {
        const uploadUrl = "https://tiku.64696225.xyz/api/contribute";
        if (!data || !String(data.question || "").trim() || data.type == null || !String(data.type).trim()) return;
        let answers = (answer == null ? [] : Array.isArray(answer) ? answer.flat(Infinity) : String(answer).split(/====|\r?\n/))
            .map(item => String(item == null ? "" : item).trim()).filter(Boolean);
        let reviewReason = /unresolved/i.test(String(source || "")) ? "AI 答案未能确认" : "";
        if (!answers.length || answers.some(item => /^(?:待确认|不确定|AI已填充|AI_FILLED|无精确答案|暂无答案|未找到答案|无法确定|无法判断)$/i.test(item))) {
            answers = ["待确认"];
            reviewReason = "未能确认答案";
        }
        const type = Number(data.type);
        const options = Array.isArray(data.options) ? data.options.map(item => String(item == null ? "" : item).trim()) : [];
        if ([0, 1].includes(type)) {
            if (!options.length || options.some(item => !item)) {
                reviewReason = reviewReason || "选项缺失或不完整";
            } else if (answers[0] !== "待确认") {
                let indexes = answers.length === 1 ? plainLetterIndexes(answers[0], options.length) : null;
                if (!indexes && answers.every(item => plainLetterIndexes(item, options.length)?.length === 1)) {
                    indexes = answers.flatMap(item => plainLetterIndexes(item, options.length));
                }
                if (indexes) {
                    answers = Array.from(new Set(indexes)).sort((a, b) => a - b).map(index => options[index]);
                } else {
                    const normalizeOption = value => formatString(value).toLowerCase().replace(/\s/g, "");
                    const normalizedOptions = options.map(normalizeOption);
                    if (answers.some(item => !normalizedOptions.includes(normalizeOption(item)))) {
                        reviewReason = reviewReason || "答案无法对应当前选项";
                    } else {
                        answers = Array.from(new Set(answers.map(item => normalizedOptions.indexOf(normalizeOption(item))))).map(index => options[index]);
                    }
                }
                if (type === 0 && answers.length !== 1) reviewReason = reviewReason || "单选题答案数量不为 1";
            }
        } else if (type === 3) {
            const truth = answers.length === 1 ? answerTruth(answers[0]) : undefined;
            if (truth !== undefined) {
                const matching = options.map((item, index) => answerTruth(item) === truth ? index : -1).filter(index => index >= 0);
                if (matching.length !== 1) reviewReason = reviewReason || "判断答案无法对应唯一选项";
                else answers = [options[matching[0]]];
            }
        }
        if (reviewReason && answers.length === 0) answers = ["待确认"];
        const payload = {
            question: String(data.question).trim(),
            options: options,
            type: data.type,
            answer: answers,
            source: "AI六边形自动采集 / " + String(source || "answer candidate") + (reviewReason ? " / 疑问：" + reviewReason : "")
        };
        if (reviewReason) payload.review_status = "questionable";
        const dedupeKey = JSON.stringify([payload.question, payload.options, payload.type, payload.answer]);
        if (questionBankUploads.has(dedupeKey)) return;
        questionBankUploads.add(dedupeKey);
        GM_xmlhttpRequest({
            method: "POST",
            url: uploadUrl,
            headers: { "Content-Type": "application/json;charset=utf-8" },
            data: JSON.stringify(payload),
            timeout: GLOBAL.timeout
        });
    }
    async function formatSearchAnswer(initData) {
        const data = {
            qid: initData.qid ? initData.qid : null,
            question: initData.question,
            options: initData.options,
            options_id: initData.options_id ? initData.options_id : [],
            type: initData.type
        };
        let res;
        console.log("准备搜题", JSON.stringify(data));
        const list = [];
        const obj = {};
        const apis = Object.assign(window.remoteAnswerApi ? window.remoteAnswerApi : {}, GLOBAL.answerApi);
        // 面板上那个「题库适配器 URL」原来是只写不读的：UI 有、存档有、回传给 Vue 也有，
        // 引擎里没有任何地方读它，填了完全不起作用。这里把它接成又一个自定义题库接口 ——
        // 走的是 GLOBAL.answerApi 那套现成契约（返回 [[答案],[答案2]]），
        // 于是上面那层 5 秒超时 + .catch 白捡：适配器挂了/慢了都不会拖垮整次搜题。
        const adapterUrl = String(GM_getValue("tiku_adapter") || "").trim();
        if (adapterUrl) apis.tiku_adapter = () => tikuAdapterSearch(adapterUrl, data);
        // n1t 题库跟适配器同一条路：注册进接口表，就自动享受上面那层 5 秒超时 + .catch，
        // 挂了/慢了都不会拖垮整次搜题，而且和官方题库、AI 并行取答案
        const n1tKey = String(GM_getValue("n1t_key") || "").trim();
        if (n1tKey) apis.n1t = () => n1tSearch(n1tKey, data);
        const answerApiFunc = Object.keys(apis).map(item => {
            // 第三方接口（含页面注入的 window.remoteAnswerApi）抛出来的话，下面 Promise.all
            // 会整个 reject —— 而这个 reject 落在 try 外面，一路抛回答题循环的 catch。
            // 单个接口挂掉不该让整次搜题算异常：跟超时一样，当它没返回结果。
            return waitWithTimeout(apis[item](initData), 5e3, "", []).catch(() => []);
        });
        answerApiFunc.push(searchAnswer(data));
        // 第四个参数是超时时的返回值。原来不传 —— waitWithTimeout 里 `defaultRes === undefined`
        // 就走 reject，而这一句在下面 try 的外面，30 秒全体超时会直接抛出 formatSearchAnswer，
        // 而不是走它自己那套 {success:false} 的错误通道。给个 []：res 保持 undefined，
        // 下面 try 里读 res.message 抛出、被自己的 catch 接住，正常返回"搜题失败"，
        // AI 兜底也就能照常触发。
        const answerApiRes = await waitWithTimeout(Promise.all(answerApiFunc), 3e4, "(接口超时)", []);
        answerApiRes.map(item => {
            if (item instanceof Array) {
                list.push(...item);
                console.log("请求第三方接口", JSON.stringify(item));
            } else if (item instanceof Object && Object.keys(item).length === 1) {
                const key = Object.keys(item)[0];
                obj[key] = item[key];
                console.log("请求远程接口", item);
            } else {
                console.log("请求官方接口", item);
                res = item;
            }
        });
        // 官方题库这一路挂了（429 限流 / 5xx / 30 秒整体超时后 res 是 undefined），
        // 原来一律返回 {success:false} —— 连带把 list 里已经拿到的答案全扔了。
        // 而 list 是并行跑完的 icodef / 题库适配器 / n1t / 页面注入接口的结果，
        // 官方那一路挂不挂跟它们没关系。只有一个都没有时才算搜题失败，让上层去转 AI。
        const keepList = why => list.length > 0 ? {
            success: true,
            msg: why,
            num: -1,
            list: list
        } : {
            success: false,
            msg: why,
            error: "题库请求未成功" + (res && res.code != null ? "（" + res.code + "）" : "") + ": " + String(why || "未返回答案")
        };
        try {
            const msg = res.message || res.msg;
            if (res.code !== 0) {
                return keepList(msg);
            }
            if (res.result.success) {
                return {
                    success: true,
                    msg: msg,
                    num: res.result.num,
                    answers: res.result.answers
                };
            }
            if (res.result.answers instanceof Array && res.result.answers.length > 0) {
                list.push(...res.result.answers);
            }
            return {
                success: true,
                msg: msg,
                num: res.result.num,
                list: list
            };
        } catch (e) {
            return keepList("官方题库无响应(" + e + ")，已用其余题库结果");
        }
    }
    function similar(s, t, f) {
        if (!s || !t) {
            return 0;
        }
        if (s === t) {
            return 100;
        }
        var l = s.length > t.length ? s.length : t.length;
        var n = s.length;
        var m = t.length;
        var d = [];
        f = f || 2;
        var min = function(a, b, c) {
            return a < b ? a < c ? a : c : b < c ? b : c;
        };
        var i, j, si, tj, cost;
        if (n === 0) return m;
        if (m === 0) return n;
        for (i = 0; i <= n; i++) {
            d[i] = [];
            d[i][0] = i;
        }
        for (j = 0; j <= m; j++) {
            d[0][j] = j;
        }
        for (i = 1; i <= n; i++) {
            si = s.charAt(i - 1);
            for (j = 1; j <= m; j++) {
                tj = t.charAt(j - 1);
                if (si === tj) {
                    cost = 0;
                } else {
                    cost = 1;
                }
                d[i][j] = min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);
            }
        }
        let res = (1 - d[n][m] / l) * 100;
        return res.toFixed(f);
    }
    function answerSimilar(src, list) {
        return $.map(list, function(val) {
            return Number(similar(formatString(val), formatString(src), 2));
        });
    }
    function isTrue(str) {
        return Boolean(String(str).match(/(^|,)(正确|是|对|√|T|ri|true|A)(,|$)/));
    }
    function isFalse(str) {
        return Boolean(String(str).match(/(^|,)(错误|否|错|×|F|不是|wr|false|B)(,|$)/));
    }
    // 题库/适配器有时把多空答案挤成一个串。分隔符沿用题库那套惯例（；;：:===、空格井号），
    // 另补上「、」(中文顿号) 和换行 —— 中文答案最常用这两种连写，原来 defaultQuestionResolve /
    // defaultFillAnswer 各抄一份、都漏了它们，于是「北京、上海」整段塞进第一个空、后面留白还报答对。
    // 跟 AI 侧的 splitBlankAnswers 不是一套：题库串里冒号/=== 常是真分隔，AI 答案里冒号是内容。
    function splitTikuBlanks(val) {
        if (val.includes(';')) return val.split(';');
        if (val.includes('；')) return val.split('；');
        if (val.includes('、')) return val.split('、');
        if (val.includes(':')) return val.split(':');
        if (val.includes('：')) return val.split('：');
        if (val.includes('===')) return val.split('===');
        if (val.includes(' # ')) return val.split(' # ');
        if (/\n/.test(val)) return val.split(/\n+/);
        return [val];
    }
    async function defaultQuestionResolve(list, data, handler, ignore_click) {
        if (data.active && !data.active()) return { style: "warning-row", ans: "" };
        let targetOptionsList = [];
        for (const answers of list) {
            if ([2, 4, 5, 6, 7, 9, 10].includes(data.type)) {
                return defaultFillAnswer(answers, data, handler, ignore_click);
            } else if (data.type === 3) {
                const parsed = parseAiAnswer(answers.join("、"), data);
                if (parsed.valid) targetOptionsList.push(new Set(parsed.indexes));
            } else if (data.type === 0 || data.type === 1) {
                const beautifulOptions = data.options.map(i => {
                    return formatString(i).toLowerCase().replace(/\s/g, "");
                });
                let targetOptions = new Set(), incomplete = false;
                for (const ans of answers) {
                    // 纯字母答案：兼容 "b" / "B." / "AC" / "A、C"
                    // 旧写法是 ans.length === 1 && isPlainAnswer(ans)，只认单个大写字母，
                    // 上面这几种常见格式全都匹配不上 → 有答案却不点
                    const letterIdx = plainLetterIndexes(ans, data.options.length);
                    if (letterIdx) {
                        letterIdx.forEach(i => targetOptions.add(i));
                        continue;
                    }
                    const val = formatString(ans).toLowerCase().replace(/\s/g, "");
                    let optIndex = $.inArray(val, beautifulOptions);
                    if (optIndex >= 0) {
                        targetOptions.add(optIndex);
                        continue;
                    }
                    if (val.length >= 5 && !val.includes("<img")) {
                        const ratings = answerSimilar(val, beautifulOptions);
                        const maxScore = Math.max(...ratings);
                        if (maxScore > 65) {
                            targetOptions.add(ratings.indexOf(maxScore));
                            continue;
                        }
                    }
                    incomplete = true;
                }
                console.log(targetOptions);
                !incomplete && targetOptions.size > 0 && targetOptionsList.push(targetOptions);
            }
        }
        let items = [];
        let sortArr = targetOptionsList.map(item => {
            const s = Array.from(item).sort();
            console.log(s);
            return s;
        });
        items = getMost(sortArr.filter(i => !choiceIndexesError(i, data)));
        if (items && items.length > 0) {
            const filled = await applyChoiceIndexes(items, data, undefined, ignore_click);
            return {
                type: data.type,
                // 曾经是 "primary-row"：全脚本产出它的只有这一处，认它的地方一处都没有。
                // 后果是选择题填对了也不计入 successCount（正确率永远 0、自动提交永不触发），
                // 上层还会把它当成填充失败，fillFinish 也不点下一题。
                style: filled ? "success-row" : "warning-row",
                ans: items.map(i => {
                    return data.options[i];
                }).join("===="),
                question: data.question
            };
        } else {
            return {
                type: data.type,
                style: "warning-row",
                question: data.question,
                ans: list.join('<span style="color: red">====</span>'),
                options: data.options
            };
        }
    }
    async function defaultFillAnswer(answers, data, handler, ignore_click) {
        if (data.active && !data.active()) return { style: "warning-row", ans: "" };
        let ok;
        if ([2, 4, 5, 6, 7, 9, 10].includes(data.type)) {
            let values = answers.flat().map(a => String(a).trim());
            if (data.type === 2 && values.length === 1 && data.$options.length > 1) values = splitTikuBlanks(values[0]);
            ok = await fillTextAnswers(values, data, handler);
            return { type: data.type, style: ok ? "success-row" : "warning-row", question: data.question, ans: values.join("===="), options: data.options };
        }
        ok = await applyChoiceIndexes(answers, data, undefined, ignore_click);
        return { type: data.type, style: ok ? "success-row" : "warning-row", question: data.question,
            ans: answers.filter(i => Number.isInteger(i) && i >= 0 && i < data.$options.length).map(i => String.fromCharCode(65 + i)).join(""), options: data.options };

    }
    function getMost(arr) {
        arr.reverse();
        if (arr.length === 0) return undefined;
        var hash = {};
        var m = 0;
        var trueEl;
        var el;
        for (var i = 0, len = arr.length; i < len; i++) {
            el = arr[i];
            hash[el] === undefined ? hash[el] = 1 : hash[el]++;
            if (hash[el] >= m) {
                m = hash[el];
                trueEl = el;
            }
        }
        return trueEl;
    }
    function getLang(arr) {
        if (arr.length === 0) return undefined;
        let len = 0;
        let ele;
        for (let arrElement of arr) {
            if (arrElement.length > len) {
                len = arrElement.length;
                ele = arrElement;
            }
        }
        return ele ? ele : arr.length > 0 ? arr[0] : [];
    }
    function HTMLDecode(text) {
        var temp = document.createElement("div");
        temp.innerHTML = text;
        var output = temp.innerText || temp.textContent;
        temp = null;
        return output;
    }
    function formatString(src) {
        src = String(src);
        src = src.includes("img") || src.includes("iframe") ? src : HTMLDecode(src);
        src = src.replace(/[\uff01-\uff5e]/g, function(str) {
            return String.fromCharCode(str.charCodeAt(0) - 65248);
        });
        return src.replace(/\s+/g, " ").replace(/[""]/g, '"').replace(/['']/g, "'").replace(/。/g, ".").replace(/[,.?:!;]$/, "").trim();
    }
    
    // 雨课堂字体解密相关
    const fontCache = {};
    let sourceTable = null;
    try {
        sourceTable = JSON.parse(GM_getResourceText("SourceTable"));
    } catch (e) {
        console.log('⚠️ SourceTable 加载失败:', e);
    }
    
    async function genTable(ttf) {
        if (!ttf) return;
        try {
            const res = await axios.get(ttf, { responseType: "arraybuffer" });
            const font = Typr.parse(res.data)[0];
            const table = {};
            for (let i = 19968; i < 40870; i++) {
                const g = Typr.U.codeToGlyph(font, i);
                if (g) {
                    const path = Typr.U.glyphToPath(font, g);
                    if (path) {
                        table[i] = MD5(JSON.stringify(path));
                    }
                }
            }
            fontCache[ttf] = table;
        } catch (e) {
            console.log('⚠️ 字体解析失败:', e);
        }
    }
    
    async function getEncryptString(str, ttf) {
        if (!str) return '';
        if (!sourceTable) {
            console.log('⚠️ SourceTable 未加载');
            return formatString(str);
        }
        if (ttf && !fontCache[ttf]) {
            await genTable(ttf);
        }
        const match = str.match(/<span class="xuetangx-com-encrypted-font">(.*?)</g);
        if (match === null) {
            return formatString(str);
        }
        const encStrArr = match.map(string => {
            return string.replace(/^<span class="xuetangx-com-encrypted-font">/, "").replace(/<$/, "");
        });
        encStrArr.forEach(encStr => {
            if (ttf && fontCache[ttf]) {
                const decStr = encStr.split("").map(char => {
                    const md5 = fontCache[ttf][char.charCodeAt(0)];
                    if (md5 && sourceTable[md5]) {
                        return String.fromCharCode(sourceTable[md5]);
                    }
                    return char;
                }).join("");
                str = str.replace(encStr, decStr);
            }
        });
        return formatString(str);
    }
    
    function url2Base64(url) {
        return new Promise((resolve, reject) => {
            GM_xmlhttpRequest({
                url: url,
                responseType: "blob",
                onload: function(r) {
                    const fileReader = new FileReader();
                    fileReader.readAsDataURL(r.response);
                    fileReader.onload = e => {
                        resolve(e.target.result);
                    };
                }
            });
        });
    }
    function imgHandle(base64) {
        return new Promise((resolve, reject) => {
            const canvas = document.createElement("canvas");
            const context = canvas.getContext("2d");
            const image = new Image();
            image.setAttribute("crossOrigin", "Anonymous");
            image.src = base64;
            image.onload = function() {
                canvas.width = image.width;
                canvas.height = image.height;
                context.fillStyle = "#fff";
                context.fillRect(0, 0, canvas.width, canvas.height);
                context.drawImage(image, 0, 0);
                canvas.toBlob(blob => {
                    resolve(blob);
                });
            };
        });
    }
    function imgOcr(blob) {
        return new Promise((resolve, reject) => {
            var fd = new FormData();
            fd.append("image", blob, "1.png");
            GM_xmlhttpRequest({
                url: "https://appwk.baidu.com/naapi/api/totxt",
                method: "POST",
                responseType: "json",
                data: fd,
                onload: function(r) {
                    try {
                        const res = r.response.words_result.map(item => {
                            return item.words;
                        }).join("");
                        resolve(res);
                    } catch (err) {
                        console.log(err.msg);
                        resolve("");
                    }
                }
            });
        });
    }
    // ponytail: 这三步（拉图 → 画 canvas → 送百度 OCR）里六个回调全是 onload，
    // 没有一个 onerror/ontimeout，也没有 timeout。图片 404、百度那边不响应、
    // 甚至 canvas 拿到一张坏图，promise 就永远不落地 —— await 它的 wrap 也永远不返回，
    // 答题循环停在这道题上，一行日志都不会有（"脚本不动了也不报错"就是这么来的）。
    // 与其给三个函数各补一套回调，不如在唯一的入口上封顶：识别不出来就当这道题没认出来，
    // 后面搜题/AI 和"连错几次就跳过"那套自然会接住，比整个脚本装死强。
    // 上限：超时后那三个 promise 还挂着（GM_xmlhttpRequest 没给取消句柄），只是没人等它了；
    // 一道题最多漏一个请求，不累积。要真回收，得把三个函数各自补上 onerror/ontimeout。
    async function yuketangOcr(url) {
        const ocr = (async () => {
            const base64 = await url2Base64(url);
            const img_blob = await imgHandle(base64);
            return await imgOcr(img_blob);
        })();
        const out = await Promise.race([ ocr, sleep(GLOBAL.timeout * 2).then(() => null) ]);
        if (out === null) {
            logMsg("图片题识别超时（拉图或百度 OCR 没响应），这道题按识别不出来处理", "warn");
            return "";
        }
        return out;
    }
    function division(arr, size) {
        var objArr = new Array();
        var index = 0;
        var objArrLen = arr.length / size;
        for (var i = 0; i < objArrLen; i++) {
            var arrTemp = new Array();
            for (var j = 0; j < size; j++) {
                arrTemp[j] = arr[index++];
                if (index == arr.length) {
                    break;
                }
            }
            objArr[i] = arrTemp;
        }
        return objArr;
    }
    function generateRandomString(length) {
        const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
        let randomString = "";
        for (let i = 0; i < length; i++) {
            const randomIndex = Math.floor(Math.random() * characters.length);
            randomString += characters.charAt(randomIndex);
        }
        return randomString;
    }
    var vm = {
        // 面板藏着开机时的页面级提示。面板自己的 toast 挂在 .box 里边，而 .box 这会儿是
        // display:none —— 「我在跑」这句话不能靠一个看不见的元素来说，所以只有它得走页面。
        // 原来是 30 行内联样式的 innerHTML 串，改用 h()，顺手把承诺的三条召回路都写全。
        hideTip() {
            const close = () => tip.remove();
            const tip = h("div", { style: {
                position: "fixed", right: "0", top: "10%", zIndex: "9999998",
                maxWidth: "260px", padding: "12px 26px 12px 14px", lineHeight: "1.7",
                font: '13px/1.7 -apple-system, "Segoe UI", "Microsoft YaHei", sans-serif',
                color: "#8a6d3b", background: "#fcf8e3",
                border: "1px solid #faebcc", borderRadius: "4px 0 0 4px",
                boxShadow: "0 2px 10px rgba(0,0,0,.12)"
            } }, [
                h("b", null, "六边形全能自动答题脚本"),
                h("div", null, "面板正藏着。按右方向键或 Ctrl+O 都能把它叫出来。"),
                h("button", { onclick: close, tabIndex: -1, style: {
                    position: "absolute", top: "4px", right: "6px", padding: "0",
                    color: "inherit", border: "0", background: "none",
                    cursor: "pointer", fontSize: "17px", lineHeight: "1"
                } }, "×")
            ]);
            top.document.body.appendChild(tip);
            // 原来到点是 querySelector("#yinc").remove()：用户先点了 × 再到点，
            // 这句就是 remove of null。拿着元素本身，就没有这条路
            setTimeout(close, 5e3);
        },
        // 知到交卷要连着点十几下答题卡和「下一题」，中途用户点一下就会串题 ——
        // 所以确实需要一层挡住页面的遮罩，这是它唯一的正经职责。
        // 进度改走面板的 progress 通道（头部百分比 + 状态页进度条），缩起来也看得见，
        // 不必在遮罩里另养一个 <progress id="gs_p">，也就不再有三个 querySelector 的耦合。
        // z-index 比面板低一级：遮罩挡得住页面，但挡不住面板上的「暂停」。
        saveMask(title) {
            const pct = h("div", { style: { marginTop: "6px", fontSize: "13px", color: "#606266" } }, "0%");
            const bar = h("i", { style: {
                display: "block", height: "100%", width: "0%",
                background: "#67C23A", transition: "width .3s"
            } });
            const mask = h("div", { style: {
                position: "fixed", inset: "0", zIndex: "9999998",
                background: "rgba(0,0,0,.46)", display: "flex",
                alignItems: "center", justifyContent: "center"
            } }, h("div", { style: {
                minWidth: "240px", padding: "16px 18px", background: "#fff",
                borderRadius: "8px", boxShadow: "0 6px 24px rgba(0,0,0,.3)",
                font: '14px/1.5 -apple-system, "Segoe UI", "Microsoft YaHei", sans-serif',
                color: "#303133"
            } }, [
                h("b", null, title),
                h("div", { style: {
                    height: "6px", marginTop: "10px", borderRadius: "3px",
                    background: "#ebeef5", overflow: "hidden"
                } }, bar),
                pct
            ]));
            top.document.body.appendChild(mask);
            iframeMsg("tip", { tip: title, logOnly: true });
            let closed = false;
            return {
                set(v) {
                    const n = Math.max(0, Math.min(100, Math.round(v) || 0));
                    bar.style.width = n + "%";
                    pct.textContent = n + "%";
                    iframeMsg("progress", { text: title + " " + n + "%", pct: n });
                },
                // 原来是「进度到了 100 才 remove」：一道题都没抓到（len===0，循环一次没进）
                // 或者中途抛了异常，这层遮罩就永久留在页面上 —— 整页点不动，只能刷新。
                // 现在由调用方在 finally 里关，跟进度值无关。
                close() {
                    if (closed) return;
                    closed = true;
                    mask.remove();
                    iframeMsg("progress", { text: "" });
                }
            };
        }
    };
    // ── 面板设置总表 ──────────────────────────────────────────────────────
    // 借 参考实现那套「声明一次，UI + 存储 + 回传全自动」的做法。
    // 这份脚本原来每加一个设置要手工接五处：面板 HTML、Vue data()、postMessage 载荷、
    // 父页面 GM_setValue、settings_updated 回传 —— check.cjs 第 11 条就是在盯这五处，
    // 因为漏一处就是"填了不起作用"（「题库适配器」当过很久的摆设，第 15 轮才接上）。
    //
    // 第 16 轮把这张表从"只管视频那 9 栏"扩到管全部：加一个设置只改这里一行，
    // 表单控件、初值、载荷、存储、回传五处全部由这张表生成，不存在漏接的可能。
    //
    // 字段：
    //   kind    switch | number | text | password | select | hidden
    //   group   非空则在这一栏上面插一条分组分隔线
    //   tip     鼠标悬停说明（参考实现的做法：每一栏都能自解释，不用另写文档）
    //   show    只在这个 key 为真时显示（例：正确率阈值只在开了自动提交时有意义）
    //   engine  false = 引擎不读它，只是面板自己用（check.cjs 第 12 条按这个放行）
    //   home    1 = 首页那张卡上也放一个（常用的那几栏），2 = 折进首页卡里的「更多开关」。
    //           不是抄一份控件：值只有存档里那一个，谁被按了两边一起翻（见 buildSettings 的 mk）
    const PANEL_SETTINGS = [
        { group: "答题", key: "search_delay", label: "搜题延迟", unit: "秒", kind: "number", def: 2, min: 0, max: 60,
            tip: "每题之间等这么久，太快会被题库限流" },
        { key: "delay_random", label: "随机延迟", unit: "秒", kind: "number", def: 0, min: 0, max: 30,
            tip: "在搜题延迟上再叠一个 0~N 秒的随机量，节奏不那么像机器" },
        { key: "retry_limit", label: "失败重试", unit: "次", kind: "number", def: 2, min: 0, max: 10 },
        { key: "ai_timeout", label: "AI 等待上限", unit: "秒", kind: "number", def: 120, min: 5, max: 120,
            tip: "等 AI 回答超过这个时间就放弃这题，接着往下走。自定义/自部署接口冷启动常要几十秒，"
                + "太小会一直判超时跳题——用「测试连接」量一下再定" },
        { key: "auto_ai_search", label: "启用 AI 答题", kind: "switch", def: false,
            home: 1, tip: "题库没搜到精确答案时，交给 AI 补" },
        { key: "ai_first_mode", label: "AI 优先", kind: "switch", def: false,
            home: 2, tip: "不先搜题库，直接问 AI。题库能搜到的题这样更慢也更贵" },
        { key: "ai_fail_skip", label: "答不出就跳过", kind: "switch", def: true,
            tip: "题库没答案、AI 也没给出能填进去的答案时：开=跳过这题继续做后面的（空着不填，不计入正确率）；关=暂停等你手动处理" },
        { key: "tiku_adapter", label: "题库适配器", kind: "text", def: "",
            tip: "tikuAdapter 自建服务的地址，留空用内置题库" },
        { key: "n1t_key", label: "n1t 题库 key", kind: "password", def: "" },
        { key: "upload_answer", label: "回传答案", kind: "switch", def: false,
            home: 2, tip: "把做过的题回传给题库，让下一个人搜得到" },
        { key: "auto_jump", label: "自动切换下一节", kind: "switch", def: true, home: 1,
            tip: "答完这一节自动进下一节。刷课那边往下一章跳是另一个开关（自动跳章）" },

        { group: "超星学习通刷课", key: "cx_do_video", label: "刷视频", kind: "switch", def: true, cx: true, home: 2 },
        { key: "cx_do_document", label: "刷文档/PPT", kind: "switch", def: true, cx: true, home: 2 },
        { key: "cx_do_book", label: "刷图书", kind: "switch", def: true, cx: true,
            home: 2, tip: "章节里插的电子书（insertbook）" },
        { key: "cx_do_link", label: "刷链接", kind: "switch", def: true, cx: true,
            home: 2, tip: "外部链接任务点" },
        // 第 86 轮删了「刷速课」「刷直播回放」两栏:它们只被死掉的老引擎 cxRunPage 读,
        // 活引擎 cxDoFound 根本不分类这两类任务(速课/直播 参考实现那套也不做,碰到日志里说一声跳过),
        // 开关是摆设。连同老引擎一起删了。
        { key: "cx_do_quiz", label: "就地答章节测试", kind: "switch", def: true, cx: true,
            home: 2, tip: "刷课翻到章节测试那一页，就等页面上的答题模块把题填完、交完再往下翻（不另开标签页）。"
                + "缺点是慢：真答、真等它交完才走。"
                + "要真正交上去得连着开「自动提交」；只开这个的话题填好了不会交，等满时间就翻走了。"
                + "关掉 = 刷课不等章节测试，翻到就走" },
        { key: "cx_video_quiz", label: "视频中途弹题", kind: "select", def: "auto", cx: true,
            home: 1, options: [["auto", "自动答题并继续播放"], ["pause", "暂停播放，等待我作答"]],
            tip: "只控制学习通视频中途弹出的小测验；章节测试仍由「就地答章节测试」控制。" },
        { key: "cx_restudy", label: "复习模式", kind: "switch", def: false, cx: true,
            home: 2, tip: "已完成的视频/文档也重新做一遍：视频从头真放到尾，学习时长是超星自己的播放器报的。"
                + "进度条早就满了不会再涨。开了之后不再开局跳到第一个没完成的章，而是从右边眼前这一章往下一页页重看；"
                + "开了之后只有「定时停止」能刹住" },
        { key: "cx_force_learn", label: "强制学习", kind: "switch", def: false, cx: true,
            home: 2, tip: "连非任务点的视频/文档也刷。这些本来不计入进度，纯粹是把它看完" },
        { key: "cx_auto_next", label: "自动跳章", kind: "switch", def: true, cx: true,
            home: 1, tip: "开着 = 开局跳到第一个有待完成任务点的章，每页做完自动翻到下一页（超星自己的「下一节」）。"
                + "关掉 = 只做右边眼前这一页" },
        { key: "cx_notify_face", label: "人脸识别提醒", kind: "switch", def: true, cx: true,
            home: 2, tip: "遇到要刷脸的任务点时警告一次" },
        { key: "cx_video_rate", label: "视频倍速", kind: "number", def: 1, min: 1, max: 100, step: .5, cx: true, outOfRange: "def",
            home: 1, tip: "所有平台共用这一个倍速（第 84 轮把各平台那几栏并成了这一个）。刷课是真播放，"
                + "第 142 轮起不再按平台夹上限:填多少就按多少放(上限交给播放器/网站,自己看着填)。\n"
                + "播放中的任务行会显示按视频时间实测的有效倍速；目标值不等于实际推进速度。\n"
                + "留意:真播放长期超 2 倍容易被判无效/清进度,智慧树播放器菜单本身封顶 1.5、\n"
                + "智慧树想单独用别的倍速，去下面「智慧树刷课 / 问答」里的「智慧树倍速」覆盖。\n"
                + "提醒：倍速风控严，被清空还原了就调回 1~2 倍" },
        { key: "cx_stop_after", label: "定时停止", unit: "分钟", kind: "number", def: 0, min: 0, max: 600, step: 30, cx: true, outOfRange: "def",
            home: 1, tip: "跑够这么多分钟就收工，刷课和答题都算，0 = 不限" },

        // 智慧树共享课刷课。第 83 轮从「视频 / 文档 / 直播」那个 30 项的大杂烩里拆出来自成一组
        // (那一组塞了超星/智慧树/MOOC/职教云/雨课堂五个平台,标题还重名两次都写"30 项" —— 就是
        // 用户说的"太杂乱")。独立成键、仍标 cx(混进 CX_SETTINGS 那个视图,引擎里就有读者了 ——
        // videocheck 那条"每类任务点都要有开关"才管得住它)。读取一律走 cxSet(),它查的是
        // PANEL_SETTINGS 整张表,跟 cx 标记、跟归在哪一组都无关。
        { key: "zhs_do_video", label: "刷共享课视频", kind: "switch", def: true, cx: true, group: "智慧树刷课 / 问答", home: 2,
            tip: "在共享课学习页(studyvideoh5 / studyplush5 / studywisdomh5)上自动按目录一个个看下去。\n"
                + "和超星那一路完全不同:智慧树没有能伪造的上报接口,只能真放视频,所以这一页要一直开着" },
        { key: "zhs_restudy", label: "复习模式", kind: "switch", def: false, cx: true,
            tip: "连目录里已经打勾的也重看一遍。默认只看没打勾的" },
        { key: "zhs_video_rate", label: "智慧树倍速", kind: "select", def: "auto", cx: true,
            options: [["auto", "跟随通用倍速"], ["1x", "1 x"], ["1.25x", "1.25 x"], ["1.5x", "1.5 x"], ["2x", "2 x"],
                ["3x", "3 x"], ["4x", "4 x"], ["6x", "6 x"]],
            tip: "只在智慧树刷课用。选择「跟随通用倍速」时使用通用倍速设置；也可单独选择 1、1.25、1.5、2、3、4 或 6 倍。\n"
                + "档位是目标倍速，播放器菜单标称最高 1.5 倍；超过 1.8 倍可能触发页面异常检测或无法达到目标速度。\n"
                + "实际推进速度以播放任务显示的实测值为准。" },
        { key: "zhs_quiz", label: "遇到随堂测验", kind: "select", def: "auto", cx: true,
            options: [["auto", "自动答并关闭(会的版式)"], ["pause", "暂停,等我自己答"], ["close", "只点关闭,不答题"]],
            tip: "视频中途会弹随堂测验,不处理视频就停在那儿。\n"
                + "「自动答并关闭」:支持共享课旧版和智慧慕课随堂检测的判断、单选、多选,按页面提供的答案作答,提交关闭后继续播放。\n"
                + "题目不支持或读取失败时暂停等你处理,不会乱选。\n"
                + "「只点关闭」:旧版目录页按「自动答」办;智慧慕课必须先作答才能关闭,此模式会暂停等你答" },

        // 智慧树问答 / 平时分。全新模块(pf*),和上面的智慧树刷课、以及作业考试答题都不重叠:
        // 那两个在别的域名 / 别的 URL,这个只在 qah5.zhihuishu.com/qa.html 的开放式问答页跑。
        // 没有标准答案,靠 AI 生成一段话填进去 —— 所以复用「AI 配置」那一组的 key / 接口 / 模型。
        { key: "qa_do", label: "刷智慧树问答(平时分)", kind: "switch", def: false,
            tip: "在 qah5.zhihuishu.com/qa.html 上自动给开放式问答生成 AI 答案并发布。\n"
                + "答案质量取决于你在「AI 配置」里填的模型 —— 免费 / 推理模型常答非所问,建议用指令模型。\n"
                + "开启后立即运行,关闭或暂停后停止后续操作。只统计网站确认发布的回答;互动问答分数以网站审核结果为准" },
        { key: "qa_cap", label: "单次封顶", unit: "题", kind: "number", def: 15, min: 0, max: 300,
            tip: "这一趟最多答多少题就停,防止一口气刷太多被风控。0 = 不限" },
        { key: "qa_gap_min", label: "答题间隔下限", unit: "秒", kind: "number", def: 3, min: 0, max: 60,
            tip: "填完答案到点发布之间,随机等这个区间的秒数,像人在斟酌。和上限一起构成随机节流" },
        { key: "qa_gap_max", label: "答题间隔上限", unit: "秒", kind: "number", def: 8, min: 0, max: 120,
            tip: "见「答题间隔下限」。上下限会自动取小 / 大,填反了也不怕" },

        // 其它平台刷课。第一个是中国大学MOOC(icourse163) —— 参考实现那版里它最不依赖桌面端:
        // 视频就在顶层文档、目录就是 DOM 行,不用读 Vue 也不用 playwright。
        // 没真机验过前默认关(study_do = false),怕把没完成的当完成了。
        { group: "其它平台刷课", key: "study_do", label: "刷中国大学MOOC视频", kind: "switch", def: false,
            tip: "在 icourse163.org 的 /learn 学习页上自动按目录把视频/文档看完、往下走。\n"
                + "真播放路线(和智慧树一样),页面要一直开着。默认关 —— 真机验证后再说" },
        { key: "study_ppt_sec", label: "PPT每页停留", unit: "秒", kind: "number", def: 1, min: 1, max: 10,
            tip: "文档/PPT 任务点一页停几秒(默认 1)" },
        { key: "study_discuss", label: "讨论自动回复", kind: "select", def: "none",
            options: [["none", "不回复,跳过"], ["first", "抄第一条评论"], ["random", "随机抄一条"]],
            tip: "MOOC 讨论任务点要不要自动回(默认不回)。\n"
                + "回的都是别人的评论,风险自负" },
        // 其它平台刷课(第二批:职教云 icve.com.cn)。职教云每个任务点是独立 URL(?id=),
        // 没有"下一页"按钮 —— 得先在课程目录页把整门课的任务读进 GM,再逐任务 location 翻。
        { key: "icve_do", label: "刷职教云视频", kind: "switch", def: false,
            tip: "在 icve.com.cn 的课程目录/学习页自动逐任务看视频/PPT/图片。\n"
                + "真播放路线,页面要一直开着。默认关 —— 真机验证后再说" },
        { key: "icve_ppt_sec", label: "PPT每页停留", unit: "秒", kind: "number", def: 1, min: 1, max: 10,
            tip: "职教云 PPT 任务一页停几秒(默认 1)" },
        { key: "ykt_do", label: "刷雨课堂视频", kind: "switch", def: false,
            tip: "在 yuketang.cn / changjiang(长江雨课堂)学习页自动逐节看视频。\n"
                + "首页可在面板选择课程并扫描。开启后自动进入「学习内容」,在当前标签页播放未完成视频,确认进度保存后继续下一节。学习时页面要保持打开" },

        // 第 86 轮删了整个「后台服务器」组(令牌 / 地址):第 82 轮起刷课换成真播放,不再往
        // cxserver 交新任务,这两栏只剩给 cxOffloadPoll 对旧账用;老引擎删掉后对账也没了,
        // cxserver.cjs / servercheck.cjs 一并退役。
        { group: "自动提交", key: "submit_mode", label: "提交方式", kind: "select", def: "off",
            options: [["off", "关闭(只填不交)"], ["save", "仅保存答案不提交"], ["auto", "自动提交(原行为)"]],
            home: 1, tip: "答完怎么处理这份卷子:\n"
                + "· 关闭:答案照填,什么都不点,停在最后一题等你\n"
                + "· 仅保存答案不提交:每题尽量点页面自己的「保存」把答案存成草稿,再翻下一题,全部做完停在最后一题等你手动交\n"
                + "· 自动提交:按「正确率阈值」自动交卷(没搜到的题也会一起交上去,慎用)" },
        { key: "submit_threshold", label: "正确率阈值", unit: "%", kind: "number", def: 80, min: 0, max: 100, show: ["submit_mode", "auto"],
            home: 1, tip: "只在「提交方式 = 自动提交」时管用:答对率低于这个数就不交,留着手动看一遍" },

        { group: "AI 配置", key: "ai_platform", label: "平台", kind: "select", def: "default", engine: false,
            options: [["default", "默认（填 key 即可）"], ["baidu", "百度文心"], ["baidu-native", "百度原生接口"],
                      ["deepseek", "DeepSeek"], ["aliyun", "阿里通义"], ["volcengine", "火山引擎"],
                      ["moonshot", "月之暗面"], ["zhipu", "智谱 GLM"], ["custom", "自定义"]] },
        // key 以前是 password 框（打码），用户填完看不见、也不好核对对没对；改成明文 text 框。
        // 存进去前照样 trim 两头空格（保存那条按 text/password 一视同仁）。
        { key: "ai_api_key", label: "key", kind: "text", def: "" },
        // 默认档地址/模型跟 PRESET.default 保持一致（守卫钉死这条一致性）：新装即用，只差填 key。
        // 模型是普通文本框，填进去后随便改。
        { key: "ai_api_url", label: "接口地址", kind: "text", def: "https://ai.64696225.xyz/v1/chat/completions", engine: false },
        { key: "ai_model", label: "模型", kind: "text", def: "DeepSeek-V4-Flash[free]", engine: false },

        // 「面板」组（字体大小 / 连点召回）整组删掉了：字号固定 13px（.box 的 var(--fs,13px) 兜底），
        // 连点召回那条页面级 click 监听也一起删。藏/显还剩 Ctrl+O 和方向键两条路。

        // 题库 autoAnswer 的 ?gpt= 参数（见 doSearch）。面板上没有控件，一直是原样存回，
        // 这里挂个 hidden 只为让它继续跟着这张表走一遍存取，行为和以前逐字相同。
        { key: "gpt", label: "", kind: "hidden", def: "-1" },
        { key: "cx_rate_preset", label: "视频倍速", kind: "select", def: 2, cx: true, home: 1,
            options: [[1, "1 x"], [2, "2 x"], [4, "4 x"], [8, "8 x"], [16, "16 x"]],
            tip: "学习通视频倍速。播放中的任务会显示按视频时间实测的有效速度。" }
    ];
    // 视频那一批单独取一份：cxSet 和父页面存档循环都按它遍历
    const CX_SETTINGS = PANEL_SETTINGS.filter(s => s.cx);
    // 把一个值规范成"能存进档"的样子。存和读都走这一个函数 ——
    // 以前存的时候夹区间、读的时候另写一遍判断，两边的边界条件迟早对不上。
    function panelNorm(s, v) {
        if (s.kind === "number") {
            const n = parseFloat(v);
            if (isNaN(n)) return s.def;
            // 越界的存档值默认夹回边界。这条路真的走得到：number 输入框的 max 只管上下箭头，
            // 手打一个 90 进「搜题延迟」照样提交得上来 —— 夹成 60 比"当没设过、悄悄变回 2 秒"
            // 更接近他的意思。哪天把某栏的 max 收窄了也是一样的道理。
            // 标了 outOfRange: "def" 的两栏反过来，它们夹到上限会得到一个用户没选过、
            // 而且比默认值更糟的值：倍速夹成 100 是替他开了 100 倍速（他要的可能只是 1.5），
            // 定时停止夹成 600 是把"基本别停"变成"十小时后停"，而默认的 0 本来就是不限。
            if (s.outOfRange === "def" && (n < s.min || n > s.max)) return s.def;
            return Math.min(s.max, Math.max(s.min, n));
        }
        if (s.key === "cx_rate_preset") {
            const n = Number(v);
            return [1, 2, 4, 8, 16].includes(n) ? n : s.def;
        }
        if (s.key === "zhs_video_rate") {
            if (["auto", "1x", "1.25x", "1.5x", "2x", "3x", "4x", "6x"].includes(String(v))) return String(v);
            const n = Number(v);
            if (n === 1) return "auto";
            if (n === 1.25) return "1.25x";
            if ([1.5, 2, 3, 4, 6].includes(n)) return n + "x";
            if (isFinite(n) && n > 1.25) {
                const nearest = [1.5, 2, 3, 4, 6].reduce((best, rate) =>
                    Math.abs(rate - n) < Math.abs(best - n) ? rate : best, 1.5);
                return nearest + "x";
            }
            return s.def;
        }
        if (s.kind === "switch") return !!v;
        // 手填的地址/key/模型名两头很容易带空格（粘贴带的）。
        // fillAnswer 里的 lockedHasApiKey 只判真假，" " 是真值 —— 引擎会以为配好了，
        // 然后带着个空的 Bearer 一道道题去请求。存之前就地擦掉。
        return String(v == null ? "" : v).trim();
    }
    // AI 地址/模型的显式空值必须显示为空,否则测试会使用界面的默认值,答题却读到空存档。
    function panelGet(s) {
        const v = GM_getValue(s.key);
        if ((s.key === "ai_api_url" || s.key === "ai_model")
            && (v === "" || (v == null && GM_getValue("ai_platform") === "custom"))) return "";
        if (v === undefined || v === null || v === "") return s.def;
        return panelNorm(s, v);
    }
    function cxSet(k) {
        const s = PANEL_SETTINGS.find(x => x.key === k);
        return s ? panelGet(s) : undefined;
    }

    // 与 OCS 的 matched projects 一样,先按网址选择平台,再生成该平台的功能面板。
    // 这里只筛选显示项,设置总表和存档仍共用,不改其它平台的开关。
    function panelPlatform(where, href) {
        let host = "";
        try { host = new URL(href || top.location.href).hostname.toLowerCase(); } catch (e) {}
        const is = domain => host === domain || host.endsWith("." + domain);
        let id = "common";
        if (is("yuketang.cn") || is("xuetangx.com")) id = "ykt";
        else if (is("zhihuishu.com") || is("polymas.com")) id = "zhs";
        else if (is("chaoxing.com") || is("xueyinonline.com")) id = "cx";
        else if (is("icourse163.org")) id = "mooc";
        else if (is("icve.com.cn") || is("icve.com")) id = "icve";
        else if (/雨课堂|学堂在线/.test(where || "")) id = "ykt";
        else if (/智慧树|知到|平时分/.test(where || "")) id = "zhs";
        else if (/超星|学习通/.test(where || "")) id = "cx";
        else if (/中国大学MOOC/i.test(where || "")) id = "mooc";
        else if (/职教云|智慧职教/.test(where || "")) id = "icve";
        const name = { ykt: "雨课堂", zhs: "智慧树", cx: "学习通", mooc: "中国大学MOOC", icve: "智慧职教", common: "通用答题" }[id];
        return { id: id, name: name, qa: id === "zhs" && (host === "qah5.zhihuishu.com" || /问答|平时分/.test(where || "")) };
    }
    function panelSettingsFor(profile) {
        const id = profile.id, buckets = new Map();
        const main = { cx: "学习通任务", zhs: profile.qa ? "智慧树问答" : "智慧树视频", ykt: "雨课堂学习",
            mooc: "MOOC学习", icve: "智慧职教学习", common: "答题" }[id];
        const home = {
            cx: ["auto_ai_search", "cx_auto_next", "cx_rate_preset", "cx_stop_after", "submit_mode", "submit_threshold"],
            zhs: profile.qa ? ["qa_do", "qa_cap", "qa_gap_min", "qa_gap_max"]
                : ["zhs_do_video", "zhs_video_rate", "zhs_quiz", "cx_stop_after"],
            ykt: ["ykt_do", "cx_video_rate", "cx_stop_after"],
            mooc: ["study_do", "cx_video_rate", "study_ppt_sec", "cx_stop_after"],
            icve: ["icve_do", "cx_video_rate", "icve_ppt_sec", "cx_stop_after"],
            common: ["auto_ai_search", "auto_jump", "submit_mode", "submit_threshold"]
        }[id];
        let group = "答题";
        PANEL_SETTINGS.forEach(base => {
            if (base.group) group = base.group;
            const key = base.key;
            if (base.kind === "hidden") return;
            if (id === "cx" && key === "cx_video_rate") return;
            if (id === "zhs" && key === "cx_video_rate") return;
            let own = "", target = group;
            if (key === "cx_video_rate" || key === "cx_stop_after") {
                if (id === "common" || profile.qa) return;
                target = main;
            } else if (key.startsWith("cx_")) { own = "cx"; target = "学习通任务"; }
            else if (key.startsWith("zhs_")) { own = "zhs"; target = "智慧树视频"; }
            else if (key.startsWith("qa_")) { own = "zhs"; target = "智慧树问答"; }
            else if (key.startsWith("icve_")) { own = "icve"; target = "智慧职教学习"; }
            else if (key === "ykt_do") { own = "ykt"; target = "雨课堂学习"; }
            else if (key === "study_discuss") {
                if (id !== "mooc" && id !== "ykt") return;
                target = main;
            } else if (key.startsWith("study_")) { own = "mooc"; target = "MOOC学习"; }
            if (own && own !== id) return;
            const s = Object.assign({}, base, { group: null, home: home.includes(key) ? 1 : 0 });
            if (id === "cx" && base.home === 2) s.home = 2;
            if (id === "zhs" && !profile.qa && key === "zhs_restudy") s.home = 2;
            if (id === "common" && ["ai_first_mode", "upload_answer"].includes(key)) s.home = 2;
            if (key === "cx_video_rate") {
                s.max = id === "zhs" ? 6 : 100; s.step = .5; s.outOfRange = "clamp";
                s.tip = profile.name + "播放速度，上限 " + s.max + " 倍；修改后同步当前播放器。";
            }
            if (key === "auto_jump") { s.label = "答题后自动切换"; s.tip = "答题完成后的页面切换，不控制视频连播。"; }
            if (["ykt_do", "zhs_do_video"].includes(key)) s.label = "自动播放并连播";
            if (key === "study_do") s.label = "自动学习视频/文档";
            if (key === "icve_do") s.label = "自动学习任务";
            if (key === "zhs_quiz") s.label = "随堂测验处理";
            if (key === "study_discuss" && id === "ykt") {
                s.options = base.options.filter(o => o[0] !== "random");
                s.tip = "雨课堂讨论页的自动回复方式，默认不回复。";
            }
            if (!buckets.has(target)) buckets.set(target, []);
            buckets.get(target).push(s);
        });
        const groups = [main, ...buckets.keys()].filter((g, i, all) => all.indexOf(g) === i && buckets.has(g));
        if (buckets.has(main)) {
            const rank = s => home.includes(s.key) ? home.indexOf(s.key) : home.length;
            buckets.get(main).sort((a, b) => rank(a) - rank(b));
        }
        return groups.flatMap(g => buckets.get(g).map((s, i) => Object.assign(s, { group: i === 0 ? g : null })));
    }

    // ── 面板 ───────────────────────────────────────────────────────────────
    // 第 30 轮整个重做，参照 参考实现的前端。第 16 轮已经把 Vue + ElementUI
    // 换成"自带样式 + 关闭的 shadow DOM"，这一轮换的是结构本身。
    //
    // 上一版的病根在于面板不是一个元素，是三层夹心：
    //   #model-id（position:fixed，管 left/top）
    //     └ content-modal
    //         ├ hcSearcheModalLinks（作者卡 580×120，在 shadow 外面）
    //         └ #panelNode（shadow 宿主 580×(GLOBAL.length-120)）
    // 于是：最小化要在父页面里给三个元素捅 width/height/overflow/pointerEvents/
    // borderRadius（约 60 行），面板内部还要另外切 .panel/.ball —— 一个布尔值两个主人；
    // 位置真源在 shadow 外的祖先上，所以拖拽只能把 screenX/screenY 转发给父页面算
    // （panel_drag 三段消息 + dragModel 58 行 + prePos + miniPos/pos 两份坐标），
    // 而这一整套通路唯一的存在理由就是绕开上面那层夹心。
    //
    // 参考实现的答案是一个元素三个状态（container-element.normal/.minimize/.hidden），
    // 最小化就是换个 class，CSS 把 body/footer 藏掉、菜单栏本身留下当药丸。照抄：
    //   · 宿主 div 自己就是 position:fixed 的容器，自己管 left/top，拖拽在同文档里算一次
    //   · panel_drag / panel_minimize 两条消息和父页面那 60 行处理一起删掉
    //   · 抽屉（任务/日志/AI 盖住正文）+ 模态（设置）换成标签页，腾出来的地方放
    //     参考实现那种 notes 说明卡 —— 上一版根本没有地方写"这个页面脚本会干什么"
    //   · 设置行改 display:table：一组里的 label 自动对齐到最宽那个，不再写死 96px
    //     （连带那个跟它绑死的 padding-left:104px 一起没了）
    //   · 说明文字改成跟着光标的 tooltip（参考实现的 $ui.tooltip）：原生 title 换不了行、
    //     出现还慢，而"令牌"那种说明是整段的
    //   · 原生 confirm() 换成自己的 dialog（返回 promise）—— 它阻塞页面、样式不可控，
    //     超星还能屏蔽掉
    //   · 答案表换成题号方格 + 选中那题的详情（参考实现的 search-infos-num）：
    //     一百道题的考试，概览是这片方格，不是一百行滚动
    //   · 设置改一栏存一栏，"填了忘点保存"这个坑没了
    // 赞赏码按作者要求常驻：底部一条作者条（缩略图点开放大），完整那段自述和大图
    // 挪进"关于"页。比原来的 120px 省下 60px 给答题区。
    //
    // 没变的：iframeMsg(type, message) → PANEL.recv(type, message)，13 个分支的名字和
    // 载荷一字未动，64 个调用点一个都没碰。

    // 赞赏码。原来这里还有一段 adList / lastShown 轮换（reportOnline 会把服务端下发的
    // 图缓存进存档），但那段算完 item 之后 src 是写死的，item 从来没被读过 —— 是死代码。
    // 删掉那段而不是把它接上：接上等于把"作者自己的赞赏码"悄悄换成"服务端推什么显示什么"，
    // 这是往外的行为改变，得作者自己点头。reportOnline 那边照旧，只是没人读它存的 adList。
    const PAY_QR = "data:image/jpeg;base64,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";
    // 微信小程序码：AI 配置里提示"没有 token？扫码领"。跟 PAY_QR 一样内联，不走网络。
    const WX_QR = "data:image/png;base64,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";
    // 填 key 教程图（内联，不走网络）：小程序复制 API Key → 粘到面板「key」栏，带红箭头标注。
    const GUIDE_KEY_IMG = "data:image/jpeg;base64,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";

    // createElement 的包装，参考实现里也叫 h()。三处跟着 参考实现抄的：
    //   · 属性用赋值（el[k] = v）而不是 setAttribute —— onclick/disabled/value/min
    //     一视同仁，上一版除 on* 外全走 setAttribute，所以 disabled 只能另写一行
    //   · 第三个参数可以是函数，拿到元素本身，省掉一个临时变量
    //   · tip 直接进 dataset：面板里不用原生 title，统一走下面那个跟光标的 tooltip
    // 用它而不是 innerHTML 拼串：题干和答案是从课程页面上抓来的，拼字符串等于把
    // 页面里的内容当代码请进面板；需要富文本的地方走下面 safeHtml() 那条路。
    function h(tag, attrs, kids) {
        const el = document.createElement(tag);
        if (attrs) for (const k in attrs) {
            const v = attrs[k];
            if (v === undefined || v === null || v === false) continue;
            if (k === "style") Object.assign(el.style, v);
            else if (k === "class") el.className = v;
            else if (k === "tip") el.dataset.tip = v;
            else el[k] = v;
        }
        if (typeof kids === "function") { kids(el); return el; }
        const list = kids === undefined || kids === null ? [] : [].concat(kids);
        for (let i = 0; i < list.length; i++) {
            const c = list[i];
            if (c === null || c === undefined || c === false) continue;
            el.appendChild(c.nodeType ? c : document.createTextNode(String(c)));
        }
        return el;
    }

    // 题干/答案要保留图片和上下标（化学式、数学题全靠它），所以不能一律 textContent。
    // 但那是页面上抓来的 HTML，直接 innerHTML 就把课程页面能塞的任何东西请进面板 ——
    // 以前躲在 srcdoc iframe 里，可 about:srcdoc 继承父页面的源，那从来不是一道边界。
    // 白名单过一遍：留排版和图，砍掉脚本、事件属性和一切能发起请求的标签。
    const HTML_OK = { B: 1, I: 1, U: 1, EM: 1, STRONG: 1, SUB: 1, SUP: 1, BR: 1, P: 1,
                      DIV: 1, SPAN: 1, IMG: 1, UL: 1, OL: 1, LI: 1, TABLE: 1, TBODY: 1,
                      TR: 1, TD: 1, TH: 1, FONT: 1, PRE: 1, CODE: 1 };
    function safeHtml(raw) {
        const box = document.createElement("div");
        box.innerHTML = String(raw == null ? "" : raw);
        const walk = node => {
            const kids = [].slice.call(node.children);
            for (let i = 0; i < kids.length; i++) {
                const el = kids[i];
                if (!HTML_OK[el.tagName]) {
                    // 不认的标签把文字留下、壳去掉：<script> 之类连文字一起丢
                    if (el.tagName === "SCRIPT" || el.tagName === "STYLE") el.remove();
                    else el.replaceWith(document.createTextNode(el.textContent || ""));
                    continue;
                }
                const attrs = [].slice.call(el.attributes);
                for (let j = 0; j < attrs.length; j++) {
                    const n = attrs[j].name.toLowerCase();
                    const v = attrs[j].value || "";
                    // 两条判据分开写。合成一个条件表达式会踩优先级：|| 比 ?: 紧，
                    // `a || b || c ? x : y` 是 `(a||b||c) ? x : y`，于是 on* 也去比 URL——
                    // onerror="https://x\nalert(1)" 前缀过关就留下来了（https: 是标签、
                    // //x 是注释、换行之后那句照样执行）。这是页面抓来的 HTML，不能靠巧合。
                    if (n.slice(0, 2) === "on") el.removeAttribute(attrs[j].name);
                    else if ((n === "href" || n === "src" || n === "srcset")
                             && !/^(https?:|data:image\/)/i.test(v.trim()))
                        el.removeAttribute(attrs[j].name);
                }
                walk(el);
            }
        };
        walk(box);
        return box;
    }

    // 面板样式。shadow 里的选择器不会漏到页面上，所以标签名和短类名可以随便用。
    const PANEL_CSS = `
:host { all: initial; }
/* ── 设计令牌 ────────────────────────────────────────────────────────
   上一版把颜色写死在两百多行里，量过的后果有两条：① 三种深浅的边框
   （#dcdfe6 / #ebeef5 / #f2f6fc）同时在用，画出来就是"有的线深有的线浅"；
   ② 文字只有 #303133 和 #909399 两档，于是卡片标题、正文、主机名一样重，
   眼睛不知道该先看哪个 —— 这两件事加起来就是"简陋"，跟换什么主色无关。
   现在颜色/圆角/阴影各自只有一份定义，改一处整个面板跟着变。
   自定义属性不受 all:initial 影响（规范里 all 就排除了它们），--fs 那个字号
   旋钮一直是这么走的，这里跟着走。 */
:host {
    --ac: #2563eb; --ac-h: #1d4ed8; --ac-s: #eef4ff; --ac-b: #c9dafe;
    --ok: #15a34a; --ok-s: #eefaf3; --ok-b: #b8e6cb;
    --wr: #c2740a; --wr-s: #fff8ec; --wr-b: #f4dcae;
    --er: #dc2626; --er-s: #fef2f2; --er-b: #f8c9c9;
    /* 文字四档：标题 / 正文 / 次要 / 极弱 */
    --t1: #101828; --t2: #384252; --t3: #697586; --t4: #98a2b3;
    /* 正文底色。卡片是白的、底是浅灰的，卡片才"浮"得起来 —— 上一版白底上画
       一圈灰线当卡片，一屏五张就是五个空框子，这一笔比换主色管用 */
    --bg: #f3f5f9; --sf: #ffffff;
    --ln: #e3e7ee; --ln2: #eef0f5; --fill: #f2f4f8;
    --ink: #ffffff;   /* 铺在主色/绿色上的字色，深色模式要反过来 */
    --chip: #667085;  /* 角标底色：它上面永远是白字，所以不能跟着 --t3 走 */
    --r1: 6px; --r2: 9px; --r3: 12px;
    --sh1: 0 1px 2px rgba(16,24,40,.06);
    --sh2: 0 4px 12px -4px rgba(16,24,40,.16), 0 1px 3px rgba(16,24,40,.06);
    --sh3: 0 18px 44px -14px rgba(16,24,40,.32), 0 2px 8px rgba(16,24,40,.10);
}
/* 跟着系统走，不加设置项：面板是浮在别人页面上的一块，多一个开关就多一处存档、
   多一处和 syncShow 对不上的可能。只换令牌，下面两百行布局一条都不用动 —— 这就是
   上面那张令牌表的红利 */
@media (prefers-color-scheme: dark) {
    :host {
        --ac: #5b9bff; --ac-h: #7cb0ff; --ac-s: #16233c; --ac-b: #2c4570;
        --ok: #3ddc84; --ok-s: #12281c; --ok-b: #2a5138;
        --wr: #f5b93b; --wr-s: #2a2213; --wr-b: #56431f;
        --er: #ff6b6b; --er-s: #2b1919; --er-b: #5a2a2a;
        --t1: #f2f4f7; --t2: #cdd3dc; --t3: #9aa3b2; --t4: #6b7480;
        --bg: #14171d; --sf: #1b1f26; --ln: #2b3138; --ln2: #232830; --fill: #252b33;
        --ink: #0b1220; --chip: #4b5563;
        --sh1: 0 1px 2px rgba(0,0,0,.4);
        --sh2: 0 4px 12px -4px rgba(0,0,0,.6), 0 1px 3px rgba(0,0,0,.4);
        --sh3: 0 18px 44px -14px rgba(0,0,0,.8), 0 2px 8px rgba(0,0,0,.5);
    }
}
* { box-sizing: border-box; margin: 0; padding: 0; }
button, input, select, textarea { font: inherit; color: inherit; outline: none; }
button { cursor: pointer; border: none; background: none; }
/* 上面统一关掉了 outline（鼠标点完残留一个框很难看），但键盘得看得见焦点在哪儿：
   面板里四十来个 button，含设置开关和题号方格，全靠 Tab 走 */
/* outline 拆成长写不是啰嗦：简写里带 var() 的话，CSSOM 会把整条当"待替换值"存起来，
   规则上的 outlineStyle / outlineWidth 都读成空 —— 画得出来但读不出来，而 panelcheck 就是
   走 cssRules 读这两个长写来确认焦点环真的在（见那条断言）*/
:focus-visible { outline-width: 2px; outline-style: solid; outline-color: var(--ac);
                 outline-offset: 2px; border-radius: 3px; }
.hide { display: none !important; }
/* 数字用等宽字形：进度百分数、日志时间戳、题号每秒都在变，比例字形会让整行左右抖 */
.pg, .lg .t, .sum, .qn, .in { font-variant-numeric: tabular-nums; }

/* 整个面板就这一个盒子，三个视觉状态只换它的 class（参考实现的 container-element）。
   外框那圈线改成 box-shadow 的第一层：border 会参与 520px 的盒模型，阴影不会 */
.box { font: var(--fs, 13px)/1.55 -apple-system, "Segoe UI", "Microsoft YaHei", sans-serif;
       color: var(--t2); letter-spacing: .2px; width: 520px; position: relative;
       display: flex; flex-direction: column; background: var(--sf); overflow: hidden;
       border-radius: 14px; box-shadow: 0 0 0 1px var(--ln), var(--sh3); }
.box.hidden { display: none; }
/* 最小化：正文/标签/页脚/作者条全收起，顶栏本身留下当药丸，进度和运行灯还在 */
.box.mini { width: auto; border-radius: 999px; }
.box.mini .tabs, .box.mini .pages, .box.mini .foot, .box.mini .author,
.box.mini .acts, .box.mini .brand .name, .box.mini .stat .tp { display: none; }
.box.mini .head { border-bottom: none; padding: 7px 12px; background: var(--sf); }

/* 顶栏 = 拖拽手柄 */
.head { display: flex; align-items: center; gap: 9px; padding: 8px 10px; flex: none;
        cursor: move; user-select: none; border-bottom: 1px solid var(--ln2);
        background: linear-gradient(180deg, var(--sf), var(--bg)); }
.brand { display: flex; align-items: center; gap: 7px; flex: none; font-weight: 600; }
/* ⬢ 从"一个蓝字"改成一块图标砖：24px 的圆角方块 + 渐变。品牌区有了体积，顶栏才
   像标题栏而不是一行字 */
.brand b { width: 24px; height: 24px; flex: none; border-radius: 8px; font-size: 13px;
           color: var(--ink); display: flex; align-items: center; justify-content: center;
           background: linear-gradient(135deg, var(--ac), var(--ac-h)); box-shadow: var(--sh1); }
.brand .name { white-space: nowrap; font-size: 13px; color: var(--t1); letter-spacing: .4px; }
/* 运行灯从"整个点闪明灭"改成往外推一圈涟漪：明灭那种在浅色顶栏上像坏点，
   涟漪一眼看得出是"在跑" */
.dot { width: 8px; height: 8px; border-radius: 50%; background: var(--t4); flex: none;
       box-shadow: 0 0 0 3px rgba(152,162,179,.22); }
.dot.run { background: var(--ok); animation: pulse 1.8s infinite; }
@keyframes pulse { 0% { box-shadow: 0 0 0 2px rgba(21,163,74,.28) }
                   70% { box-shadow: 0 0 0 7px rgba(21,163,74,0) }
                   100% { box-shadow: 0 0 0 2px rgba(21,163,74,0) } }
/* 进度在前且 flex:none：状态文字再长也挤不掉它，这就是"常驻"的意思。
   前提是它真的短 —— 只放百分数，章节名走状态页，见 setProgress */
.stat { flex: 1; min-width: 0; display: flex; align-items: center; gap: 7px; font-size: 12px; }
.stat .pg { flex: none; padding: 1px 7px; border-radius: 999px; font-size: 11px; font-weight: 600;
            color: var(--ok); background: var(--ok-s); border: 1px solid var(--ok-b); }
.stat .tp { min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
            color: var(--wr); font-size: 11.5px; }
.acts, .vis { display: flex; align-items: center; gap: 4px; flex: none; }

.ic { width: 26px; height: 26px; border-radius: var(--r2); color: var(--t3); font-size: 13px;
      display: flex; align-items: center; justify-content: center; transition: background .15s, color .15s; }
.ic:hover { background: var(--fill); color: var(--ac); }
.ic.danger:hover { background: var(--er-s); color: var(--er); }
.ic:disabled { opacity: .35; cursor: not-allowed; }
.ic:disabled:hover { background: none; color: var(--t3); }
.run-btn { height: 26px; padding: 0 13px; border-radius: 999px; color: var(--ink); font-size: 12px;
           font-weight: 600; letter-spacing: .3px; background: var(--ok); box-shadow: var(--sh1);
           transition: filter .15s, background .2s; }
.run-btn:hover { filter: brightness(1.07); }
.run-btn.off { background: var(--t3); }

/* 标签页：从"下面一条蓝线"改成分段控件（底是灰的，选中那格是白药丸 + 一点阴影）。
   七个标签靠一条 2px 下划线区分，选中态在 520px 宽里几乎看不见 */
.tabs { display: flex; flex: none; padding: 6px 8px; gap: 3px; border-bottom: 1px solid var(--ln2);
        background: var(--bg); overflow-x: auto; scrollbar-width: none; }
.tabs::-webkit-scrollbar { display: none; }
.tab { position: relative; flex: none; padding: 5px 10px; border-radius: var(--r2); font-size: 12px;
       font-weight: 500; color: var(--t3); white-space: nowrap; transition: background .15s, color .15s; }
.tab:hover { color: var(--t1); background: rgba(105,117,134,.12); }
.tab.on { color: var(--ac); background: var(--sf); font-weight: 600; box-shadow: var(--sh1); }
.tab .bd { display: inline-block; min-width: 16px; height: 16px; padding: 0 4px; margin-left: 4px;
           border-radius: 999px; background: var(--chip); color: #fff; font-size: 10px; line-height: 16px;
           text-align: center; font-weight: 600; }
.tab.on .bd { background: var(--ac); color: var(--ink); }
.tab .bd.warn { background: var(--wr); color: #fff; }
.tab .bd.error { background: var(--er); color: #fff; }

/* 进度页顶部的分段控件（任务点 / 答题记录）。跟标签页同一套视觉：灰底槽 + 选中白药丸。
   第 85 轮「答题」「任务」两个标签合成「进度」一页，靠它切换。*/
.seg { display: inline-flex; padding: 3px; gap: 2px; border-radius: var(--r2); background: var(--fill);
       border: 1px solid var(--ln2); flex: none; }
.seg-btn { padding: 3px 12px; border-radius: var(--r1); font-size: 12px; font-weight: 500; color: var(--t3);
           white-space: nowrap; transition: background .15s, color .15s; }
.seg-btn:hover { color: var(--t1); }
.seg-btn.on { background: var(--sf); color: var(--ac); font-weight: 600; box-shadow: var(--sh1); }
/* 进度页两段各自占满标题栏以下的高度、内部自己滚（.page 是 flex 列，这一层要 flex:1 撑开，
   否则里面 flex:1 的 .scroll 拿不到高度就塌成 0）*/
.prog-pane { flex: 1; min-height: 0; display: flex; flex-direction: column; }

/* 页面：高度由 JS 跟视口夹一次（参考实现的 $.onresize），内部自己滚。
   flex 那一栏必须是 none：写 flex: 1 的时候 flex-basis 是 0%，而 .box 高度不定 ——
   百分比 basis 遇上不定高会退回 content，于是 elPages.style.height 那句夹高整个失效，
   面板直接长到内容那么高（量过：设置页 .pages 1336px、整块 1472px，挂在 803px 的窗口里，
   下半截连赞赏码一起在屏幕外），而且每换一个标签页面板就变一次高矮 */
.pages { flex: none; min-height: 0; }
.page { display: none; height: 100%; flex-direction: column; }
.page.on { display: flex; }
/* 正文底色铺在滚动区上，卡片浮在它上面。整行铺开的列表（任务点/日志/题目详情）自己
   刷白，白到边就看不出底色，只有列表末尾那截露出灰的 —— 正好当"到底了"的收口 */
.scroll { flex: 1; overflow: auto; background: var(--bg); }
/* 默认那条又粗又灰的滚动条挤在 520px 面板里特别显眼，收细、去掉轨道 */
.scroll::-webkit-scrollbar, .qgrid::-webkit-scrollbar, .dc::-webkit-scrollbar { width: 9px; height: 9px; }
.scroll::-webkit-scrollbar-track, .qgrid::-webkit-scrollbar-track, .dc::-webkit-scrollbar-track { background: none; }
.scroll::-webkit-scrollbar-thumb, .qgrid::-webkit-scrollbar-thumb, .dc::-webkit-scrollbar-thumb {
      border-radius: 999px; border: 3px solid transparent; background-clip: padding-box;
      background-color: rgba(105,117,134,.3); }
.scroll::-webkit-scrollbar-thumb:hover, .qgrid::-webkit-scrollbar-thumb:hover,
.dc::-webkit-scrollbar-thumb:hover { background-color: rgba(105,117,134,.55); }
.phead { display: flex; align-items: center; gap: 7px; flex: none; padding: 9px 12px;
         border-bottom: 1px solid var(--ln2); font-size: 11px; color: var(--t3); background: var(--sf); }
.phead b { color: var(--t1); font-size: 13.5px; font-weight: 600; letter-spacing: .3px; }
.phead .sp { flex: 1; }
/* 「12 个｜完成 3」那截汇总：套个灰药丸，跟标题分开，不然读成一句长句 */
.phead .sum { padding: 1px 7px; border-radius: 999px; background: var(--fill); color: var(--t3); }
.phead button { font-size: 11.5px; font-weight: 500; color: var(--ac); padding: 3px 7px;
                border-radius: var(--r1); transition: background .15s; }
.phead button:hover { background: var(--ac-s); }
.phead button.del { color: var(--er); }
.phead button.del:hover { background: var(--er-s); }
.phead button:disabled { color: var(--t4); cursor: not-allowed; background: none; }

/* 卡片 / 分组 / 说明块，都是 参考实现那三个 */
.card { margin: 9px 10px; padding: 11px 12px; border-radius: var(--r3); background: var(--sf);
        border: 1px solid var(--ln2); box-shadow: var(--sh1); overflow: hidden; }
/* 卡片标题。上一版拿 .secondary（11px 灰）当标题，跟卡里的正文一样弱 —— 现在是深色
   小标题 + 一根主色竖条，扫一眼就知道这一屏有几块、每块管什么 */
.ct { display: flex; align-items: center; gap: 7px; font-size: 12px; font-weight: 600; color: var(--t1); }
.ct::before { content: ""; flex: none; width: 3px; height: 12px; border-radius: 2px; background: var(--ac); }
.card > .ct { margin-bottom: 8px; }
.hd { display: flex; align-items: center; justify-content: space-between; gap: 8px; margin-bottom: 8px; }
.hd .ct { margin: 0; }
.lnk { padding: 2px 6px; margin-right: -6px; border: 0; background: none; color: var(--ac); font-size: 11px;
       font-weight: 500; cursor: pointer; border-radius: var(--r1); transition: background .15s; }
.lnk::after { content: " ›"; }
.lnk:hover { background: var(--ac-s); }
.notes { margin: 10px 12px; padding: 8px 11px; background: var(--ac-s); border: 1px solid var(--ac-b);
         border-radius: var(--r2); font-size: 11.5px; color: var(--t2); line-height: 1.75; }
.notes ul { padding-left: 17px; }
.notes li { margin: 2px 0; }
.notes code { padding: 1px 5px; border-radius: 4px; background: var(--sf); border: 1px solid var(--ac-b);
              font-family: Consolas, monospace; font-size: 11px; color: var(--ac-h); }
.sep { display: flex; align-items: center; gap: 8px; font-size: 12.5px; font-weight: 600; color: var(--t1); }
.sep .cnt { font-weight: 400; font-size: 11px; color: var(--t4); }
.sep::after { content: ""; flex: 1; }
/* 设置分组是原生 <details>：零 JS，而 name= 是浏览器自带的手风琴 —— 展开一组自动收上
   一组，所以那一页永远只有"六行标题 + 一组内容"这么高。整组现在自己就是一张卡：
   六组收着的时候是六个可点的行，而不是六条飘在灰底上的字 */
.grp { margin: 9px 10px; border-radius: var(--r3); background: var(--sf); border: 1px solid var(--ln2);
       box-shadow: var(--sh1); overflow: hidden; }
.grp > summary.sep { cursor: pointer; list-style: none; padding: 11px 12px; transition: background .15s; }
.grp > summary.sep::-webkit-details-marker { display: none; }
.grp > summary.sep:hover { background: var(--fill); }
/* 收起来要真收上：UA 样式里那句 details:not([open]) > *{display:none} 压不过任何作者
   样式（作者样式无论特异性都赢 UA），而 .cfg 的 display:table 正好写在 details 的直接
   子元素上 —— 于是收着的组里 30 行还占着高度（量到 33px/行）。自己写一句同样的话，
   特异性够高就管得住。Chromium 新版改用 ::details-content + content-visibility，这句是
   给还在用 display:none 的版本兜的，两边都不冲突 */
.grp:not([open]) > :not(summary) { display: none; }
.grp > summary.sep::before { content: "▸"; flex: none; width: 12px; text-align: center;
       font-size: 10px; color: var(--t4); }
.grp[open] > summary.sep { border-bottom: 1px solid var(--ln2); background: var(--fill); }
.grp[open] > summary.sep::before { content: "▾"; color: var(--ac); }
.grp > .notes { margin: 10px 12px 0; }
.grp > .cfg { margin: 8px 12px; }
.empty { text-align: center; color: var(--t4); padding: 36px 16px 40px; font-size: 12px; }
.empty i { display: flex; width: 54px; height: 54px; margin: 0 auto 11px; border-radius: 50%;
           align-items: center; justify-content: center; background: var(--fill);
           font-size: 25px; font-style: normal; }
.secondary { color: var(--t3); font-size: 11px; }

/* 进度条 */
.bar { height: 5px; border-radius: 999px; background: var(--ln); overflow: hidden; }
.bar i { display: block; height: 100%; border-radius: 999px; transition: width .35s ease;
         background: linear-gradient(90deg, var(--ok), var(--ok) 60%, rgba(255,255,255,.45)); }
.bar.nb { margin-top: 8px; }

/* 首页第一张卡的头一行：接管标记 + 平台名 + 主机名。上一版三样都是 12px 挨在一起，
   现在平台名放到 15px 当这一屏的主角，主机名压成 --t4 */
.hero { display: flex; align-items: center; flex-wrap: wrap; gap: 7px; margin-bottom: 8px; }
.hero b { font-size: 15px; font-weight: 600; color: var(--t1); letter-spacing: .3px; }
.hero .secondary { color: var(--t4); }

/* 这一页的账：七种状态排成一行灰字是一句读不动的长句（「7 个｜完成 2 · 进行中 1 ·
   服务器代跑 1 · 待做 1 · 失败 1 · 不支持 1」），得逐字数。改成一串药丸，颜色沿用
   任务点行尾那套 .tag —— 同一个状态在两处是同一个颜色，扫一眼就够 */
.tally { display: flex; flex-wrap: wrap; gap: 5px; margin-top: 9px; }
/* 合成一张卡之后里面是两段：上半"这门课到哪了"，下半"手上这一个"。两条进度条长得一样，
   紧挨着就读成一条断了的 —— 一条发丝线把两段分开，比拉大间距省地方 */
.band { margin-top: 10px; padding-top: 10px; border-top: 1px solid var(--ln2); }
.tally .secondary { line-height: 20px; }

/* 总览页：当前任务那一行（借任务点的 .tk，去掉它的行边框、内边距和白底，卡片自己有）*/
.now .tk { padding: 0; border: 0; background: none; }
.now .tk:hover { background: none; }

/* 首页那张「常用设置」卡：借设置页的 .cfg 表和 .grp 折叠，外层换成 .card 而已。
   .cfg 和 .grp 自带的外边距、卡壳（白底/圆角/阴影）都要卸掉 —— 不卸就是卡里再套一张卡。
   「更多开关」那一行改成满出卡片左右内边距的底条：负外边距顶到卡沿，.card 的
   overflow:hidden 帮它把下面两个角切圆 */
.card .cfg { margin: 0; }
.card .grp { margin: 11px -12px -11px; border: 0; border-top: 1px solid var(--ln2);
             border-radius: 0; box-shadow: none; background: none; }
.card .grp > summary.sep { margin: 0; padding: 8px 12px; font-size: 12px; }
.card .grp[open] > summary.sep { background: none; }
.card .grp > .cfg { margin: 0 12px 10px; }

.tag { display: inline-block; padding: 0 8px; border-radius: 999px; font-size: 11px; line-height: 18px;
       border: 1px solid; font-weight: 500; }
.tag.success { color: var(--ok); border-color: var(--ok-b); background: var(--ok-s); }
.tag.primary { color: var(--ac); border-color: var(--ac-b); background: var(--ac-s); }
.tag.info    { color: var(--t3); border-color: var(--ln); background: var(--fill); }
.tag.warning { color: var(--wr); border-color: var(--wr-b); background: var(--wr-s); }
.tag.danger  { color: var(--er); border-color: var(--er-b); background: var(--er-s); }

/* 答题：题号方格 + 选中那题的详情（参考实现的 search-infos-num）。
   一百道题的考试，概览是这片方格，不是一百行表格 */
/* 上限跟着这一页的高度走：写死 96px 的话，一百道题的概览只有三行半可看（要在小格子里
   滚），而下面那道题的详情空着四百像素 —— 两头都不好用。max() 保证小窗口时不比原来的
   96px 更矮。题少的时候方格区本来就只有一行高，上限根本用不上，所以这一句只在题多时起作用 */
.qgrid { display: flex; flex-wrap: wrap; gap: 5px; padding: 9px 12px; flex: none;
         max-height: max(96px, 34%); overflow: auto; border-bottom: 1px solid var(--ln2);
         background: var(--sf); }
.qn { width: 26px; height: 22px; border-radius: var(--r1); border: 1px solid var(--ln); background: var(--sf);
      font-size: 11px; font-weight: 600; color: var(--t3); transition: transform .12s, box-shadow .15s; }
.qn:hover { transform: translateY(-1px); box-shadow: var(--sh1); }
.qn.ok { border-color: var(--ok-b); background: var(--ok-s); color: var(--ok); }
.qn.warn { border-color: var(--wr-b); background: var(--wr-s); color: var(--wr); }
.qn.on { background: var(--ac) !important; border-color: var(--ac) !important; color: var(--ink) !important;
         box-shadow: 0 0 0 3px var(--ac-s); }
/* .qd 自己就是滚动容器（class="scroll qd"）：底色让给 .scroll 的浅灰，题干和答案
   各自是一块白 —— 一道短题下面透出来的浅底就是"没有更多了"，和任务页一个读法。
   之前这里是白的，短题下面就是一大片说不清是加载中还是没了的空白 */
.qd { padding: 0 0 11px; background: var(--bg); }
.qd .q { padding: 11px 12px; background: var(--sf); border-bottom: 1px solid var(--ln2); }
.qd .q { font-weight: 600; font-size: 13px; line-height: 1.7; color: var(--t1); word-break: break-word; }
.qd .q img { max-width: 100%; border-radius: var(--r1); }
/* 答案那块从"一条虚线下面接着写"改成一个独立的浅底块 —— 题干和答案是两件事。
   底色是中性的：这块里既可能是绿的「已填充」，也可能是黄的「题库没给精确答案」 */
.qd .ans { margin: 10px 10px 0; padding: 9px 11px; border-radius: var(--r2); background: var(--sf);
           border: 1px solid var(--ln2); }
.qd .ans .a { color: var(--ok); font-weight: 600; font-size: 13px; word-break: break-word; margin-top: 6px; }
.qd .ans details { margin-top: 7px; }
.qd summary { cursor: pointer; color: var(--wr); font-size: 12px; font-weight: 500; }
.qd .sim { margin-top: 7px; padding: 7px 9px; background: var(--fill); border: 1px solid var(--ln2);
           border-radius: var(--r1); font-size: 12px; color: var(--t2); word-break: break-word; }

/* 任务点。图标塞进一块 28px 的浅底砖里：一行行扫下来，图标列自己就成了一条对齐的边 */
.tk { display: flex; align-items: center; gap: 10px; padding: 8px 12px; background: var(--sf);
      border-bottom: 1px solid var(--ln2); transition: background .15s; }
.tk:hover { background: var(--fill); }
.tk .ico { flex: none; width: 28px; height: 28px; border-radius: var(--r2); background: var(--fill);
           display: flex; align-items: center; justify-content: center; font-size: 15px; }
.tk .nm { flex: 1; min-width: 0; }
.tk .nm div { font-size: 12px; line-height: 1.4; color: var(--t1); word-break: break-all; }
.tk .nm small { color: var(--t3); font-size: 11px; }
.tk .mk { display: inline-block; margin-right: 5px; padding: 0 5px; border-radius: 4px;
          font-size: 10px; font-style: normal; font-weight: 600; line-height: 15px; vertical-align: 1px;
          background: var(--fill); color: var(--t3); }
.tk .mk.w { background: var(--wr-s); color: var(--wr); }
.tk .mk.g { background: var(--ok-s); color: var(--ok); }

/* 日志。警告/报错那两行左边多一条 2px 的色条：光靠字色，一屏三十行里看不出哪几行要紧 */
.lg { display: flex; gap: 7px; padding: 4px 12px; font-size: 12px; align-items: baseline;
      background: var(--sf); border-bottom: 1px solid var(--ln2); }
.lg .t { color: var(--t4); font-family: Consolas, monospace; flex: none; font-size: 11px; }
/* 同一秒里连着来的行不再重复印时间戳（见 logRow）。用 visibility 而不是 display:none：
   那一列还得占着位，否则正文左边缘每隔几行就忽进忽出一次 */
.lg .t.dup { visibility: hidden; }
.lg .m { flex: 1; word-break: break-all; }
.lg .c { color: var(--t3); font-size: 11px; flex: none; }
.lg.warn { box-shadow: inset 2px 0 0 var(--wr); }
.lg.warn .m { color: var(--wr); }
.lg.error { box-shadow: inset 2px 0 0 var(--er); background: var(--er-s); }
.lg.error .m { color: var(--er); font-weight: 500; }

/* AI 对话。自己说的话改成主色气泡：灰底对灰底那一版，谁说的分不出来 */
.msg { display: flex; margin: 9px 12px; }
.msg .bb { max-width: 86%; padding: 8px 12px; border-radius: var(--r3); font-size: 13px; line-height: 1.65;
           background: var(--sf); border: 1px solid var(--ln2); box-shadow: var(--sh1);
           color: var(--t2); border-top-left-radius: 3px; word-break: break-word; }
.msg.me { justify-content: flex-end; }
.msg.me .bb { background: var(--ac); color: var(--ink); border-color: transparent;
              border-top-left-radius: var(--r3); border-top-right-radius: 3px; }
.msg.sys { justify-content: center; }
.msg.sys .bb { background: none; border: 0; box-shadow: none; color: var(--t4); font-size: 11px; }
.ai-in { flex: none; display: flex; gap: 7px; padding: 9px 12px; border-top: 1px solid var(--ln2);
         background: var(--sf); }
.ai-in input { flex: 1; height: 30px; padding: 0 12px; border: 1px solid var(--ln); border-radius: 999px;
               background: var(--sf); color: var(--t1); transition: border-color .15s, box-shadow .15s; }
.ai-in input::placeholder { color: var(--t4); }
.ai-in input:focus { border-color: var(--ac); box-shadow: 0 0 0 3px var(--ac-s); }
.ai-in button { width: 30px; height: 30px; flex: none; border-radius: 50%; background: var(--ac);
                color: var(--ink); font-size: 13px; }
.ai-in button:hover { background: var(--ac-h); }
.ai-in button:disabled { background: var(--t4); cursor: not-allowed; }

/* 设置：display:table 让一组里的 label 自动对齐到最宽那个（参考实现的 .configs） */
/* 表格宽度只跟内容走，于是 520px 的面板里「刷视频 [开关]」全挤在左边 —— 量过：11 栏
   那一组右边空出 290px，一半的面板没在用。撑满只需要下面 .cfglb 那一句 width:100%：
   带百分比宽度的单元格会把 shrink-to-fit 的表推到外框那么宽，所以这儿不用再写宽度。
   （原来这四处 .cfg 各写了一条 calc(100% - 外边距)，量过一条都不起作用，还带来"改间距
   要跟着改 calc"的耦合。删掉之后守卫照样绿 —— 见 panelcheck 那条"一栏占满整行"。） */
.cfg { display: table; margin: 0 10px; }
.cfgrow { display: table-row; }
.cfglb { display: table-cell; white-space: nowrap; padding: 5px 14px 5px 0; font-size: 12px;
         color: var(--t2); vertical-align: middle; width: 100%; }
.cfgin { display: table-cell; padding: 5px 0; vertical-align: middle; white-space: nowrap;
         text-align: right; }
/* 控件贴到右沿之后，它和标签隔着两三百像素 —— 一条发丝线 + 整行 hover 把两头系回一起，
   一栏就是一行，不是飘在空白里的一对东西。线只能画在单元格上：table-row 上的 border
   在 border-collapse:separate（默认值）下根本不渲染 */
.cfglb, .cfgin { border-bottom: 1px solid var(--ln2); }
.cfgrow:last-child .cfglb, .cfgrow:last-child .cfgin { border-bottom: none; }
.cfgrow:hover .cfglb, .cfgrow:hover .cfgin { background: var(--fill); }
.cfgrow:hover .cfglb { color: var(--t1); }
/* text-align:right 会继承进输入框，把用户填的接口地址/令牌顶到右边去 —— 只要控件靠右，
   框里的字还是从左往右读。开关是 display:block，靠 auto 边距推过去 */
.cfgin .in { text-align: left; }
.cfgin .sw { margin-left: auto; }
.in { height: 27px; padding: 0 9px; border: 1px solid var(--ln); border-radius: var(--r1); font-size: 12px;
      background: var(--sf); color: var(--t1); min-width: 132px;
      transition: border-color .15s, box-shadow .15s; }
.in::placeholder { color: var(--t4); }
.in:hover { border-color: var(--t4); }
.in:focus { border-color: var(--ac); box-shadow: 0 0 0 3px var(--ac-s); }
input.in[type=number] { width: 78px; min-width: 0; }
.cfgin .un { color: var(--t3); font-size: 11px; margin-left: 6px; }
.cfgrow.hide { display: none !important; }
/* 开关。ElementUI 那个 el-switch 的外观，手搓 8 行：滑块回弹用了个过冲曲线，
   19px 的东西上这点动静就够读出"啪"的一声了 */
.sw { width: 38px; height: 20px; border-radius: 999px; background: var(--ln); position: relative;
      transition: background .22s; display: block; box-shadow: inset 0 1px 2px rgba(16,24,40,.1); }
.sw::after { content: ""; position: absolute; top: 2px; left: 2px; width: 16px; height: 16px;
             border-radius: 50%; background: #fff; box-shadow: 0 1px 3px rgba(16,24,40,.35);
             transition: transform .22s cubic-bezier(.34,1.56,.64,1); }
.sw.on { background: var(--ok); }
.sw.on::after { transform: translateX(18px); }

/* 页脚：跳过本题。它只在卡着的时候出现，所以底色给淡红 —— 出现本身就是要说话 */
.foot { flex: none; padding: 7px 12px; border-top: 1px solid var(--er-b); text-align: center;
        background: var(--er-s); }
.foot button { color: var(--er); font-weight: 600; font-size: 12px; padding: 2px 10px;
               border-radius: var(--r1); }
.foot button:hover { background: var(--sf); }

/* 作者条（常驻） */
.author { flex: none; display: flex; align-items: center; gap: 10px; padding: 9px 12px;
          border-top: 1px solid var(--ln2); background: linear-gradient(180deg, var(--sf), var(--bg)); }
.author .qr { width: 46px; height: 46px; border-radius: 50%; border: 2px solid var(--sf); flex: none;
              box-shadow: var(--sh2); cursor: pointer; transition: transform .25s; }
.author .qr:hover { transform: scale(1.09); }
.author .who { flex: 1; min-width: 0; font-size: 11px; color: var(--t3); line-height: 1.65; }
.author .who b { color: var(--t1); font-size: 12px; }
.author .who .pill { display: inline-block; padding: 0 6px; margin-left: 6px; border-radius: 999px;
                     background: var(--ac-s); border: 1px solid var(--ac-b); color: var(--ac);
                     font-size: 9px; font-weight: 600; vertical-align: 1px; }
.qq { user-select: text; color: var(--ac); font-weight: 600; }

/* 关于页 */
.about .big { display: block; width: 152px; margin: 12px auto 6px; border-radius: var(--r3);
              box-shadow: var(--sh2); }
.about p { margin-bottom: 6px; font-size: 12px; color: var(--t2); line-height: 1.8; }
.about .quote { margin: 9px 0; padding: 8px 11px; border-left: 3px solid var(--wr);
                border-radius: 0 var(--r2) var(--r2) 0; color: var(--wr); font-size: 12px;
                background: var(--wr-s); }
.btn { height: 28px; padding: 0 14px; border-radius: var(--r1); border: 1px solid var(--ln);
       background: var(--sf); font-size: 12px; font-weight: 500; color: var(--t2);
       transition: border-color .15s, color .15s, background .15s; }
.btn:hover { border-color: var(--ac); color: var(--ac); background: var(--ac-s); }
.btn.main { background: var(--ac); border-color: var(--ac); color: var(--ink); }
.btn.main:hover { background: var(--ac-h); border-color: var(--ac-h); color: var(--ink); }
.btnrow { display: flex; flex-wrap: wrap; gap: 8px; margin-top: 10px; }
/* 测试连接：按钮一行、结果另起一整行铺满并换行 —— 否则长错误信息横着溢出、右边看不见。
   flex:1 1 100% 把结果挤到按钮下一行占满宽度；break-all 让没有空格的长串（URL、JSON）也能断行。
   ok/err 只换文字颜色（longhand，cssRules 读得回来）。 */
.ai-test { display: flex; flex-wrap: wrap; align-items: center; gap: 8px; padding: 8px 0 2px; }
.ai-test-msg { flex: 1 1 100%; font-size: 12px; line-height: 1.6; color: var(--t3);
               word-break: break-all; white-space: normal; }
.ai-test-msg.ok { color: var(--ok); }
.ai-test-msg.err { color: var(--er); }
/* 没有 token？扫这个小程序码去领。图内联（WX_QR），不走网络 */
.ai-qr { display: flex; flex-direction: column; gap: 6px; padding: 4px 0 8px; }
.ai-qr-tip { font-size: 12px; color: var(--t3); line-height: 1.6; }
.ai-qr-img { width: 150px; height: 150px; border-radius: var(--r2); align-self: flex-start; }

/* 提示条 */
.toast { position: absolute; top: 10px; left: 50%; transform: translateX(-50%); z-index: 50;
         display: flex; flex-direction: column; gap: 6px; align-items: center; pointer-events: none; }
.toast > div { padding: 7px 14px; border-radius: 999px; font-size: 12px; font-weight: 500;
               background: var(--ok-s); color: var(--ok); border: 1px solid var(--ok-b);
               box-shadow: var(--sh2); animation: pop .2s ease-out; }
.toast > div.error { background: var(--er-s); color: var(--er); border-color: var(--er-b); }
.toast > div.info  { background: var(--fill); color: var(--t3); border-color: var(--ln); }
@keyframes pop { from { opacity: 0; transform: translateY(-8px) scale(.96) } }
@keyframes fade { from { opacity: 0 } }

/* 弹窗：原生 confirm 的替代品，返回 promise */
.mask { position: absolute; inset: 0; background: rgba(16,24,40,.45); z-index: 60; display: flex;
        align-items: center; justify-content: center; animation: fade .16s ease-out; }
.dlg { width: 86%; max-height: 84%; display: flex; flex-direction: column; background: var(--sf);
       border-radius: var(--r3); overflow: hidden; box-shadow: var(--sh3); animation: pop .2s ease-out; }
.dlg > .dh { flex: none; padding: 11px 14px; border-bottom: 1px solid var(--ln2); font-weight: 600;
             color: var(--t1); }
.dlg > .dc { flex: 1; overflow: auto; padding: 13px 14px; font-size: 13px; line-height: 1.75; }
.dlg > .dc img { display: block; max-width: 100%; margin: 0 auto; border-radius: var(--r2); }
.dlg > .df { flex: none; display: flex; gap: 8px; justify-content: flex-end; padding: 10px 14px;
             border-top: 1px solid var(--ln2); background: var(--bg); }

/* tooltip：跟着光标，能换行。原生 title 换不了行、出现还慢（参考实现的 $ui.tooltip） */
.tipbox { position: fixed; z-index: 99; max-width: 240px; padding: 6px 9px; border-radius: var(--r2);
          background: rgba(16,24,40,.95); color: #fff; font-size: 11px; line-height: 1.6;
          white-space: pre-line; pointer-events: none; display: none; box-shadow: var(--sh2); }

/* 系统里关了动画就一条都不放（前庭失调的人看着会晕）。运行灯那圈涟漪也一起停 */
@media (prefers-reduced-motion: reduce) {
    * { animation-duration: .01ms !important; animation-iteration-count: 1 !important;
        transition-duration: .01ms !important; }
}
`;

    const TASK_ICON = { video: "📹", document: "📄", book: "📚",
                        hyperlink: "🔗", live: "📡", workid: "📝" };
    const TASK_TAG = { "已完成": "success", "进行中": "primary", "待做": "info", "待确认": "warning",
                       "跳过": "warning", "失败": "danger", "不支持": "warning" };
    // 顶栏留给这一格的宽度量出来只有 190px 上下（11.5px 的字 ≈ 16 个汉字），写长了就是
    // 一句永远读不完的半句话 —— 而这一格随时会被 setTip 换成"正在做什么"，读不完
    // 等于没写。关于页那份列表也用这四条，那儿不限宽，短一点照样成立。
    const TIPS = [
        "每栏设置停一下就有说明",
        "面板没了？按 Ctrl+O 叫回来",
        "真看最高 2 倍，关了复习模式才更快",
        "填了服务器令牌就能关页面"
    ];
    // 分组说明（参考实现的 notes）。挂在这里而不是塞进 PANEL_SETTINGS：那张表的形状
    // check.cjs 第 11、12 条在盯，加字段要跟着改守卫；而这些话只有面板自己用。
    const GROUP_NOTES = {
        "答题": ["搜到的答案会填进页面，但<b>不会</b>自动交卷 —— 交卷要另开「自动提交」。",
                 "题库搜不到精确答案时才轮到 AI，AI 也要单独开。"],
        "自动提交": ["交上去就撤不回来了。没搜到答案的题也会一起交，先想清楚。"],
        "AI 配置": ["换平台会自动把接口地址和模型名一起换掉，一般不用手改。",
                    "火山引擎的模型名是你自己的 Endpoint ID，猜不出来，得自己填。"]
    };

    // 面板本体。一个普通对象，没有框架 —— 13 种消息各自只动自己那一块 DOM。
    let PANEL = null;
    let PANEL_SOURCE = window;
    const PANEL_RELAY_TYPES = new Set(["push", "update_answer", "clear", "progress", "task", "tip", "stop",
        "start_pay", "update", "ai_fill_question", "ai_response", "retry_ai", "settings_updated", "homework_scope"]);
    function panelRelay(type, message) {
        try {
            if (window.top === window.self) return false;
            const origin = window.top.location.origin;
            window.top.postMessage({ panelRelay: 1, type: type, message: message }, origin);
            return true;
        } catch (e) { return false; }
    }
    if (window.top === window.self) {
        window.addEventListener("message", event => {
            const m = event.data;
            if (!m || m.panelRelay !== 1 || event.source === window || event.origin !== location.origin) return;
            PANEL_SOURCE = event.source;
            if (m.type === "ensure") { showPanel(m.message && m.message.where || "题库助手"); return; }
            if (!PANEL || !PANEL_RELAY_TYPES.has(m.type)) return;
            const p = m.message || {};
            PANEL.recv(m.type, m.type === "tip"
                ? { tip: String(p.tip || ""), level: p.level, logOnly: true, src: p.src, ctx: p.ctx }
                : p);
        });
    }


    function questionKind(data) {
        if (data.type === 1) return data.choiceMin === 1 ? "不定项选择题" : "多选题";
        return ({ 0: "单选题", 2: "填空题", 3: "判断题", 4: "简答题", 5: "名词解释", 6: "论述题", 7: "计算题", 9: "分录题", 10: "资料题" })[data.type] || "未支持题型";
    }
    function questionPrompt(data) {
        const options = data.options || [], kind = questionKind(data);
        const range = options.map((_, i) => String.fromCharCode(65 + i)).join("、");
        let rule;
        if (data.type === 0) rule = "只输出一个正确选项的大写字母，范围：" + range + "。";
        else if (data.type === 1) rule = "输出所有正确选项的大写字母，至少 " + (data.choiceMin === 1 ? 1 : 2) + " 个，范围：" + range + "；不加分隔符或解释。";
        else if (data.type === 3) rule = "只输出“对”或“错”。";
        else if (data.type === 2) rule = "共有 " + (data.blankCount || data.$options && data.$options.length || 1) + " 个空，按顺序作答，多个空用 ### 分隔，不加解释。";
        else rule = "直接完整作答，保留必要的计算、论证和段落；不要用填空分隔符，不限制字数。";
        const opts = [0, 1, 3].includes(data.type) && options.length
            ? "\n选项：\n" + options.map((o, i) => String.fromCharCode(65 + i) + ". " + o).join("\n") : "";
        return "题型：" + kind + (data.typeLabel ? "（页面标注：" + data.typeLabel + "）" : "")
            + "\n题目：" + data.question + opts + "\n要求：" + rule
            + "\n如题干、公式或条件缺失，或无法按该题型确定答案，请回答“无法确定”并说明原因。不要自行假设题意或为凑选项数量补选。";
    }
    function finalAnswerText(answer) {
        let text = String(answer == null ? "" : answer).replace(/<think\b[^>]*>[\s\S]*?<\/think>/gi, "").trim();
        if (/<think\b/i.test(text)) return "";
        // Only an explicit conclusion or a standalone response is an answer. Never collect letters from reasoning.
        const markers = Array.from(text.matchAll(/(?:最终答案|最后答案|最终结论|最后结论|final\s+answer)\s*(?:\*\*)?\s*(?:[：:]|为|是)?\s*/gi));
        if (markers.length) { const m = markers[markers.length - 1]; text = text.slice(m.index + m[0].length); }
        else {
            const ordinary = Array.from(text.matchAll(/(?:^|\n|[。；;])\s*(?:\*\*)?(?:正确答案|答案|回答|解答|故选|应选|选择|应填|填入)\s*(?:\*\*)?\s*(?:[：:]|为|是)?\s*/g));
            if (ordinary.length) { const m = ordinary[ordinary.length - 1]; text = text.slice(m.index + m[0].length); }
        }
        text = text.replace(/^\s*(?:\*\*|：|:)\s*/, "").trim();
        const fence = text.match(/^\x60\x60\x60(?:text|plaintext|json)?\s*\n?([\s\S]*?)\x60\x60\x60/i);
        if (fence) text = fence[1].trim();
        else text = text.replace(/^\*\*([\s\S]*?)\*\*$/, "$1").replace(/^\x60([^\x60]+)\x60$/, "$1").trim();
        if (/^[{\[]/.test(text)) {
            try { const parsed = JSON.parse(text); const value = parsed.answer ?? parsed.answers ?? parsed;
                if (typeof value === "string") text = value;
                else if (Array.isArray(value) && value.every(v => typeof v === "string")) text = value.join("、");
            } catch (e) {}
        }
        return text.trim();
    }
    function answerTruth(value) {
        const text = String(value || "").normalize("NFKC").trim().replace(/^[A-Z][.、:]\s*/i, "").replace(/[。.!！]$/, "").toLowerCase();
        if (/^(?:对|正确|是|是的|√|✓|true|t|yes|right|correct)$/.test(text)) return true;
        if (/^(?:错|错误|否|不对|不正确|×|✗|false|f|no|wrong|incorrect)$/.test(text)) return false;
        return undefined;
    }
    function choiceIndexesError(indexes, data) {
        const count = data.$options ? data.$options.length : (data.options || []).length;
        if (![0, 1, 3].includes(data.type)) return "此题型不支持按选项填写";
        if (data.typeConflict) return data.typeConflict;
        if (!indexes.length || indexes.some(i => !Number.isInteger(i) || i < 0 || i >= count)) return "答案包含不存在的选项或未识别到选项";
        if (data.type !== 1 && indexes.length !== 1) return questionKind(data) + "只能选择 1 个选项，返回了 " + indexes.length + " 个";
        if (data.type === 1 && indexes.length < (data.choiceMin === 1 ? 1 : 2)) return "多选题只返回了 1 个选项，请复核题目与 AI 答案";
        return "";
    }
    function parseAiAnswer(answer, data) {
        const text = finalAnswerText(answer), bad = error => ({ valid: false, value: "", error });
        if (!text || /^(?:无法确定|无法判断|无法作答|题目信息不足)/.test(text)) return bad("AI 未给出可确认的答案，请检查题干、公式及选项是否完整");
        if (data.typeConflict) return bad(data.typeConflict);
        if ([0, 1, 3].includes(data.type)) {
            let indexes;
            const truth = data.type === 3 ? answerTruth(text) : undefined;
            if (truth !== undefined) {
                indexes = (data.options || []).map((o, i) => answerTruth(o) === truth ? i : -1).filter(i => i >= 0);
                if (indexes.length !== 1) return bad("判断题选项顺序未识别，无法将对错对应到选项");
            } else {
                let candidate = text.normalize("NFKC").replace(/\*\*/g, "").trim();
                // 口语开头：剥掉"选项/选择/应选/故选/应该选/应该是/正确答案/答案/我选/选/填/答/是"这类
                // 结论引导词（白名单、仅限开头）——"选A""应该是A""答案是A"都能认到 A。
                // 刻意不收"分析/讨论/因为"，也绝不"扫到第一个字母就取"，免得从推理里捞字母（守卫钉死）。
                candidate = candidate.replace(/^(?:正确答案|答案|选项|故选|应选|应该选|我选|选择|应该是|应填|选|填|答|是)\s*(?:是|为|选|填)?\s*[:：]?\s*/, "").trim();
                // 结论后面可以跟解释（逗号/顿号/句号/括号/中文都算分界），但字母本身必须在最前、无歧义。
                const m = candidate.match(/^([A-Z](?:[\s、,，;；/]*[A-Z])*)\s*(?:[.。,，、;；:：]|[（(]|[一-龥]|$)/i);
                if (!m) return bad("未识别到明确的最终选项答案，请复核 AI 回复");
                indexes = Array.from(new Set(m[1].toUpperCase().match(/[A-Z]/g))).map(c => c.charCodeAt(0) - 65).sort((a, b) => a - b);
            }
            const error = choiceIndexesError(indexes, data);
            return error ? bad(error) : { valid: true, value: indexes.map(i => String.fromCharCode(65 + i)).join(""), indexes };
        }
        if (![2, 4, 5, 6, 7, 9, 10].includes(data.type)) return bad("此题型尚未支持自动填写，请手动作答");
        return { valid: true, value: text };
    }

    function buildPanel(where) {
        const profile = panelPlatform(where);
        const settings = panelSettingsFor(profile);
        // 宿主自己就是那个 position:fixed 的容器：位置归它管，拖拽在同一个文档里算一次。
        // 上一版位置在外层 #model-id 上，才要把 screenX/screenY 转发给父页面。
        const host = top.document.createElement("div");
        host.id = "panelNode";
        host.style.cssText = "position:fixed;z-index:9999999;border:none;";
        // closed：页面上的脚本拿不到 shadowRoot，也就改不了、删不掉面板
        const root = host.attachShadow({ mode: "closed" });
        root.appendChild(h("style", null, PANEL_CSS));

        const st = {
            rows: [], tasks: [], logs: [], chat: [],
            visual: "normal", stop: false, needJump: false, tab: "stat", cur: -1,
            aiLoading: false, aiQuestion: "", aiReqId: 0,
            // token 无效时置真：自动答题这一路就别再逐题空打 AI（每题都 401 白等 25 秒），
            // 只弹一次"去重新获取"引导；用户重填 token（settings_updated）或测试连接成功后清掉。
            aiKeyBad: false, aiKeyHelpShown: false
        };

        // ── 顶栏 ──
        const elDot = h("span", { class: "dot run" });
        const elPg = h("span", { class: "pg hide" });
        // 顶栏状态文字只显示「正在做什么」（setTip 填），不再轮播 TIPS —— 那几条小贴士
        // 第 85 轮挪进了 ⓘ 弹窗（openAbout），顶栏和关于两处不再重复。开机先留空，
        // 一开工就被 setTip 填上。
        const elTip = h("span", { class: "tp" }, "");
        const elRun = h("button", { class: "run-btn", tip: "暂停 / 继续（键盘 S / D 同样能切）",
                                    onclick: () => toggleStop() }, "运行中");
        const icon = (glyph, tipText, onclick, cls) =>
            h("button", { class: "ic" + (cls ? " " + cls : ""), tip: tipText, onclick: onclick }, glyph);

        const bVis = icon("—", "最小化", () => setVisual(st.visual === "mini" ? "normal" : "mini"));
        const elHead = h("div", { class: "head" }, [
            h("div", { class: "brand" }, [h("b", null, "⬢"), h("span", { class: "name" }, "六边形战士"), elDot]),
            h("div", { class: "stat" }, [elPg, elTip]),
            h("div", { class: "acts" }, [elRun]),
            h("div", { class: "vis" }, [
                icon("ⓘ", "关于 · 使用说明 · 检查更新", () => openAbout()),
                bVis,
                icon("✕", "隐藏面板（Ctrl+O / 右方向键叫回来）",
                    () => setVisual("hidden"), "danger")
            ])
        ]);

        // ── 标签页骨架 ──
        // 第 85 轮 7 → 5：答题 + 任务合成「进度」页（页内分段切换，见下面 progSeg）；
        // 关于页删掉，挪进顶栏 ⓘ 弹窗（openAbout）。总览/进度/日志/AI/设置。
        const PAGES = [
            { key: "stat", label: "总览" }, { key: "prog", label: "进度" },
            { key: "log", label: "日志" }, { key: "ai", label: "AI" },
            { key: "set", label: "设置" }
        ];
        const tabs = {}, badges = {}, pages = {};
        const elTabs = h("div", { class: "tabs" });
        const elPages = h("div", { class: "pages" });
        PAGES.forEach(p => {
            badges[p.key] = h("span", { class: "bd hide" });
            tabs[p.key] = h("button", { class: "tab", onclick: () => openTab(p.key) },
                [p.label, badges[p.key]]);
            pages[p.key] = h("div", { class: "page" });
            elTabs.appendChild(tabs[p.key]);
            elPages.appendChild(pages[p.key]);
        });
        function openTab(key) {
            st.tab = key;
            PAGES.forEach(p => {
                tabs[p.key].classList.toggle("on", p.key === key);
                pages[p.key].classList.toggle("on", p.key === key);
            });
            if (key === "log") elLogScroll.scrollTop = elLogScroll.scrollHeight;
            if (key === "ai") { elAiScroll.scrollTop = elAiScroll.scrollHeight; elAiIn.focus(); }
            if (key === "stat") setTimeout(maybeDailyKeyReminder, 0);
        }

        // ── 页脚 / 作者条 / 浮层 ──
        const elFoot = h("div", { class: "foot hide" },
            h("button", { onclick: () => { post({ type: "jump" }); setNeedJump(false); } }, "跳过本题"));
        const elToast = h("div", { class: "toast" });
        const elLayer = h("div");
        const elTipBox = h("div", { class: "tipbox" });

        const elQr = h("img", { class: "qr", src: PAY_QR, draggable: false,
            tip: "点开放大赞赏码", onclick: () => dialog({
                title: "赞赏作者", ok: "关了", cancel: null,
                content: h("div", null, [
                    h("img", { src: PAY_QR, style: { width: "220px" } }),
                    h("p", { class: "secondary", style: { textAlign: "center", marginTop: "8px" } },
                        "感谢哥哥姐姐们的零碎小费～")
                ])
            }) });
        const elAuthor = h("div", { class: "author" }, [
            elQr,
            h("div", { class: "who" }, [
                h("div", null, [h("b", null, "😊 Smiley face"), h("span", { class: "pill" }, "开发者")]),
                h("div", null, ["QQ群 ", h("span", { class: "qq" }, "1030887796"),
                    h("span", { class: "secondary" }, "　首次使用需等待 15 秒")])
            ])
        ]);

        const elBox = h("div", { class: "box normal" },
            [elHead, elTabs, elPages, elFoot, elAuthor, elToast, elLayer]);
        root.appendChild(elBox);
        // tooltip 挂在 box 外面：box 是 overflow:hidden 的，挂里面贴边就被切掉
        root.appendChild(elTipBox);

        // 面板和页面在同一个文档里，postMessage 收在同一个 window 上（父页面那个
        // addEventListener("message") 监听器一字未动）。现在只剩真正需要父页面出手的
        // 那几种消息：jump / stop / save_setting / ai_request / ai_fill。
        const post = msg => {
            if (yktHomeworkPost(msg)) return;
            const target = PANEL_SOURCE || window;
            target.postMessage(msg, target === window ? "*" : location.origin);
        };

        // ── tooltip：一个委托监听器管全部 [data-tip] ──
        root.addEventListener("mouseover", e => {
            const t = e.target.closest && e.target.closest("[data-tip]");
            if (!t) return;
            elTipBox.textContent = t.dataset.tip;
            elTipBox.style.display = "block";
            moveTipBox(e.clientX, e.clientY);
        });
        root.addEventListener("mousemove", e => {
            if (elTipBox.style.display === "block") moveTipBox(e.clientX, e.clientY);
        });
        root.addEventListener("mouseout", e => {
            if (e.target.closest && e.target.closest("[data-tip]")) elTipBox.style.display = "none";
        });
        function moveTipBox(x, y) {
            // 贴右边缘时往左收，否则说明会被窗口切掉一半
            const w = elTipBox.offsetWidth || 230;
            elTipBox.style.left = Math.max(4, Math.min(x + 12, (top.innerWidth || 1e4) - w - 8)) + "px";
            elTipBox.style.top = (y + 16) + "px";
        }

        // ── 提示条 / 弹窗 ──
        function toast(text, kind, sec) {
            const t = h("div", { class: kind || "" }, text);
            elToast.appendChild(t);
            setTimeout(() => t.remove(), (sec || 2.6) * 1000);
            return t;
        }
        // 原生 confirm 的替代品：不阻塞页面、样式可控、超星屏蔽不掉。
        // cancel 传 null 就只有一个按钮（当 alert 用）。
        function dialog(opts) {
            // 面板正藏着/缩着的时候弹窗等于没弹（mask 是 box 的子元素）。
            // 一个要人回答的问题必须先把面板露出来 —— 原来那个 confirm() 无论如何都会出现。
            if (st.visual !== "normal") setVisual("normal");
            return new Promise(resolve => {
                let done = false;
                const finish = v => {
                    if (done) return;
                    done = true; mask.remove(); resolve(v);
                    setTimeout(maybeDailyKeyReminder, 0);
                };
                const foot = [];
                if (opts.cancel !== null)
                    foot.push(h("button", { class: "btn", onclick: () => finish(false) }, opts.cancel || "取消"));
                foot.push(h("button", { class: "btn main", onclick: () => finish(true) }, opts.ok || "确定"));
                const body = h("div", { class: "dc" },
                    typeof opts.content === "string" ? h("div", null, opts.content) : opts.content);
                const mask = h("div", { class: "mask" }, h("div", { class: "dlg" }, [
                    h("div", { class: "dh" }, opts.title || "提示"), body, h("div", { class: "df" }, foot)
                ]));
                // 点遮罩空白处 = 取消，但别把弹窗内部的点击也算上
                mask.onclick = e => { if (e.target === mask) finish(false); };
                elLayer.appendChild(mask);
            });
        }
        function maybeDailyKeyReminder() {
            // 按本地自然日记一次,跨刷新/换平台保留;只在可见的首页提醒。
            if (!host.isConnected || st.tab !== "stat" || st.visual !== "normal"
                || top.document.visibilityState === "hidden" || elLayer.childElementCount) return;
            const day = new Date().toDateString();
            if (st.keyReminderDay === day || GM_getValue("daily_key_reminder_day") === day) return;
            st.keyReminderDay = day;
            GM_setValue("daily_key_reminder_day", day);
            dialog({
                title: "每日 key 获取提醒", ok: "去填写 key", cancel: "知道了",
                content: h("div", null, [
                    h("p", { style: { marginBottom: "12px", lineHeight: "1.8" } }, [
                        "微信扫码打开小程序，点击右下角", h("b", null, "「我的」"), "页面获取 key。"
                    ]),
                    h("img", { src: WX_QR, draggable: false, alt: "微信小程序码",
                        style: { width: "168px", maxWidth: "100%", display: "block", margin: "0 auto 12px", borderRadius: "8px" } }),
                    h("p", { class: "secondary", style: { lineHeight: "1.7" } }, "复制 key 后，粘贴到「设置 → AI 配置 → key」。"),
                    // 图解：粘到面板「key」栏（弹窗体可滚动，图随容器宽度不撑破布局）
                    guideImg("把小程序领取的 key 填进面板的 key 栏"),
                    h("p", { class: "secondary", style: { marginTop: "6px" } }, "每天提醒一次，今天关闭后不再弹出。")
                ])
            }).then(go => { if (go) { openTab("set"); toast("在 AI 配置 → key 里粘贴 key", "info"); } });
        }

        // ── 顶栏状态 ──
        function setTip(text) {
            elTip.textContent = text;
            // 状态行是截断显示的，长提示只能靠悬停看全
            elTip.dataset.tip = text;
        }
        function setProgress(text, pct) {
            // 载荷里的 text 是整句（"第 3/12 章 · 马克思主义基本原理概论 25%"）。顶栏那个
            // 进度是 flex:none 的常驻元素，塞二三十个字进去会横着盖到右边的运行按钮和
            // 最小化/✕ 上 —— .box 是 overflow:hidden 的，超出去的部分连按钮一起被切掉。
            // 所以顶栏只留百分数（药丸上也是它），整句去状态页那张卡，顺带当悬停说明。
            const on = typeof pct === "number" && pct >= 0;
            elPg.textContent = on ? Math.round(pct) + "%" : "";
            elPg.classList.toggle("hide", !on);
            elPg.dataset.tip = text || "";
            elStatBar.classList.toggle("hide", !on);
            if (on) elStatBarFill.style.width = Math.max(0, Math.min(100, pct)) + "%";
            elStatNow.textContent = text || "";
            elStatNow.classList.toggle("hide", !text);
        }
        function setStop(v) {
            st.stop = !!v;
            elRun.textContent = st.stop ? "已暂停" : "运行中";
            elRun.classList.toggle("off", st.stop);
            elDot.classList.toggle("run", !st.stop);
        }
        function toggleStop() {
            setStop(!st.stop);
            setTip(st.stop ? "已暂停搜索" : "继续搜索");
            post({ type: "stop", val: st.stop });
        }
        function setNeedJump(v) {
            st.needJump = !!v;
            elFoot.classList.toggle("hide", !st.needJump);
        }
        // 三个视觉状态只换一个 class，剩下的交给 CSS（参考实现的 setVisual）
        function setVisual(v) {
            st.visual = v;
            elBox.className = "box " + v;
            bVis.textContent = v === "mini" ? "▢" : "—";
            bVis.dataset.tip = v === "mini" ? "展开面板" : "最小化";
            if (v !== "hidden") clampPos();
            if (v === "normal") setTimeout(maybeDailyKeyReminder, 0);
        }

        // ── 位置：自己管，存回 pos ──
        // 存档里的坐标可能落在屏幕外（换了显示器、缩了窗口），那时候面板是"在的但看不见"。
        // 参考实现开机就夹一次，跟着照做——连点召回删掉后，越界找回全靠这一夹（外加 Ctrl+O/方向键）。
        function clampPos() {
            const W = top.innerWidth || 1200, H = top.innerHeight || 800;
            const w = elBox.offsetWidth || 520;
            let x = parseInt(host.style.left, 10), y = parseInt(host.style.top, 10);
            if (isNaN(x) || isNaN(y)) { x = 30; y = 30; }
            // 至少留 60px 在窗口里，抓得住就行
            x = Math.max(60 - w, Math.min(x, W - 60));
            y = Math.max(0, Math.min(y, H - 40));
            host.style.left = x + "px";
            host.style.top = y + "px";
        }
        function savePos() {
            GM_setValue("pos", parseInt(host.style.left, 10) + "px," + parseInt(host.style.top, 10) + "px");
        }
        const startPos = readPos(GM_getValue("pos"));
        host.style.left = startPos[0];
        host.style.top = startPos[1];

        // ── 拖拽（鼠标 + 触屏）。同文档，直接算 ──
        function enableDrag(el) {
            const begin = (sx, sy, isTouch) => {
                const x0 = parseInt(host.style.left, 10) || 0, y0 = parseInt(host.style.top, 10) || 0;
                let moved = false;
                const move = (x, y) => {
                    if (Math.abs(x - sx) > 3 || Math.abs(y - sy) > 3) moved = true;
                    host.style.left = (x0 + x - sx) + "px";
                    host.style.top = Math.max(0, y0 + y - sy) + "px";
                };
                const up = () => {
                    top.document.removeEventListener("mousemove", onM);
                    top.document.removeEventListener("mouseup", up);
                    top.document.removeEventListener("touchmove", onT);
                    top.document.removeEventListener("touchend", up);
                    if (moved) { clampPos(); savePos(); }
                    // 药丸"没拖动"才算点击展开。另挂一个 click 的话，拖完一松手也会展开
                    else if (st.visual === "mini") setVisual("normal");
                };
                // 鼠标移出窗口后在外面松开，这边收不到 mouseup，靠 buttons 兜一下，
                // 否则监听器一次次往上叠
                const onM = e => { if (e.buttons === 0) return up(); move(e.clientX, e.clientY); };
                const onT = e => {
                    const t = e.touches[0];
                    if (!t) return up();
                    e.preventDefault();
                    move(t.clientX, t.clientY);
                };
                if (isTouch) {
                    top.document.addEventListener("touchmove", onT, { passive: false });
                    top.document.addEventListener("touchend", up);
                } else {
                    top.document.addEventListener("mousemove", onM);
                    top.document.addEventListener("mouseup", up);
                }
            };
            el.addEventListener("mousedown", e => {
                if (e.target.closest("button, input, select, textarea, img")) return;
                e.preventDefault();
                begin(e.clientX, e.clientY, false);
            });
            // 触屏：手机上课的人不少，没有这条整个面板挪不动
            el.addEventListener("touchstart", e => {
                if (e.target.closest("button, input, select, textarea, img")) return;
                const t = e.touches[0];
                if (t) begin(t.clientX, t.clientY, true);
            }, { passive: true });
        }
        enableDrag(elHead);

        // ── 高度跟着视口夹（参考实现的 $.onresize，防抖 200ms）──
        function fitHeight() {
            // 460 是自己的上限，不是 GLOBAL.length 减出来的：那一项注释写着
            // 「默认搜索框的长度」，是旧面板的宽度旋钮，拿来当高度用纯属同名巧合
            const room = (top.innerHeight || 800) - 250;
            elPages.style.height = Math.max(200, Math.min(460, room)) + "px";
        }
        let fitTimer = 0;
        top.addEventListener("resize", () => {
            clearTimeout(fitTimer);
            fitTimer = setTimeout(() => { fitHeight(); clampPos(); }, 200);
        });

        // ── 状态页 ──
        // 上一版没有这一页，于是"脚本到底认不认得当前页面"完全看不出来 ——
        // 只能靠"等了半天没动静"去猜。
        // 认哪个页面这件事，每个 WorkerJSPlus 配置的 name 字段早就写着了（"学习通作业"、
        // "超星新版考试"…112 条），只是从来没人读过它。原来这里读的是 GLOBAL.isMatch，
        // 那个布尔只有 WorkerJSPlus 那条路会写；刷课（cxStudyDispatch）是另一个入口，不写它，
        // 于是在最常用的学习页上这一页显示的是"这个页面不是任务页，脚本不会动它"——
        // 正好说反。现在改成建面板的人把名字传进来：两个调用点都知道自己在干什么。
        const elStatBarFill = h("i", { style: { width: "0%" } });
        const elStatBar = h("div", { class: "bar ch hide" }, elStatBarFill);
        const elStatNow = h("div", { class: "hide", style: { marginBottom: "6px", fontSize: "12px" } });
        const elWhere = h("div");
        const elTaskLine = h("div", { class: "tally" });
        function paintStat() {
            // 认出来了就别再说一遍："已接管"那个绿标 + 下面的进度已经把这句话说完了，
            // 而它占掉一整行 —— 首页四张卡在 390px 的滚动区里本来就装不下。
            // 没认出来那句得留着：那句带的是"接下来该干什么"，不是复述。
            // 走 apply + filter，不能直接 replaceChildren(hero, 三元)：replaceChildren 是原生
            // DOM 接口，非节点的参数一律当字符串收 —— null 会照原样印出"null"三个字母。
            // h() 那边有滤空，这里没有，两处不是一套。
            elWhere.replaceChildren.apply(elWhere, [
                h("div", { class: "hero" }, [
                    h("span", { class: "tag " + (where ? "success" : "info") }, where ? "已接管" : "已启动"),
                    h("b", null, where || "未识别的页面"),
                    h("span", { class: "secondary" }, String(location.hostname || ""))
                ]),
                where ? null : h("div", { class: "secondary" },
                    "脚本起来了，但没认出这是哪种页面 —— 手动进到视频/作业/考试页就会自己开工。")
            ].filter(Boolean));
        }
        // ── 首页的「任务进度」──
        // 原来首页这张卡只有一行汇总（"12 个｜完成 3 · 进行中 1"），"现在到底在放哪个视频、
        // 放到第几分钟"只能去日志页一行行翻 —— 而日志是流水：同一句"视频「x」3/12 分钟"
        // 每分钟来一条，往上滚一屏就再也对不上是哪个任务了。
        // 所以首页改成盯住"当前在做的那一个"：刷视频显示分钟数和进度条，答题显示填了几题
        // （和答题页看到的一样）。数据没有新来源 —— 画的全是 st.tasks / st.rows 里本来就
        // 有的东西，只有视频那个分钟数是 cxTaskNote 顺手带回来的。
        // 任务点名字前面那个小标。绿的是「复习·真看」——播放器真在放，学习时长是真的；
        // 灰的是「复习·补报」——够不着播放器，退回接口把整段时长重发一遍；黄的是「非任务点」，
        // 刷完了进度条也不会涨，这件事比"在复习"更需要一眼看见。
        // 定在这儿是因为首页的当前任务和任务点那一屏都要用它。
        const MK_CLS = { "非任务点": " w", "复习·真看": " g" };
        const taskMark = m => m ? h("em", { class: "mk" + (MK_CLS[m] || "") }, m) : null;
        const elNowFill = h("i", { style: { width: "0%" } });
        const elNowBar = h("div", { class: "bar nb hide" }, elNowFill);
        const elNow = h("div", { class: "now" });
        function nowRow() {
            // 同时只会有一个任务点在跑（cxStudyFrame 是 await 串着来的），所以 find 就够。
            const t = st.tasks.find(x => x.state === "进行中");
            if (t) return {
                icon: t.icon, name: t.name, sub: t.chapter, mark: t.mark,
                note: t.note, pct: t.pct
            };
            // 答题页没有任务点，进度就是"填到第几题"
            if (st.rows.length) {
                const sim = st.rows.filter(r => r.style === "warning-row" && !r.searchError).length;
                const unresolved = st.rows.filter(r => r.style === "warning-row" && r.searchError).length;
                return { icon: "📝", name: "已处理 " + st.rows.length + " 题",
                         sub: [sim ? sim + " 题只搜到相似答案" : "", unresolved ? unresolved + " 题尚未取得答案" : ""].filter(Boolean).join(" · "), note: "" };
            }
            return null;
        }
        function paintNow() {
            const r = nowRow();
            const on = !!r && typeof r.pct === "number" && r.pct >= 0;
            elNowBar.classList.toggle("hide", !on);
            if (on) elNowFill.style.width = Math.max(0, Math.min(100, r.pct)) + "%";
            elNow.replaceChildren(r ? h("div", { class: "tk" }, [
                h("span", { class: "ico" }, r.icon),
                h("div", { class: "nm" }, [h("div", null, [taskMark(r.mark), r.name]),
                    r.sub ? h("small", null, r.sub) : null]),
                r.note ? h("span", { class: "tag primary" }, r.note) : null
            ]) : h("div", { class: "secondary" }, "还没开工 —— 进到视频 / 作业 / 考试页就会自己开始"));
        }
        // ── 首页的「常用设置」──
        // 开关原来只在设置页：正刷着课想关掉「自动提交」，得切标签页、展开那一组、点完再切回来。
        // 常用的几栏直接铺在首页，剩下的折进「更多开关」。AI 的 token / 接口地址 / 模型这种
        // 配一次就不动的仍然只在设置页 —— 首页放的是"跑着的时候会想改"的那些。
        // 控件不是抄一份：同一个 key 首页和设置页各有一个，值只有存档里那一个，谁被按了
        // 都由 inputs[key].set 把两边一起翻（见 buildSettings 里的 mk）。
        const elHomeCfg = h("div", { class: "cfg" });
        const elHomeMoreCfg = h("div", { class: "cfg" });
        // 这个 <details> 故意不带 name=：设置页那六组是 name="cfg" 的原生手风琴，同一个
        // shadow root 里重名的会互相收 —— 在首页展开「更多开关」会把设置页展开的那组收上去，
        // 反过来也一样，两边都像是自己弹回去的。
        const elHomeMore = h("details", { class: "grp" }, [
            h("summary", { class: "sep" }, ["更多开关",
                h("span", { class: "cnt" }, settings.filter(s => s.home === 2).length + " 项")]),
            elHomeMoreCfg
        ]);
        elHomeMore.classList.toggle("hide", !settings.some(s => s.home === 2));
        // 「在哪个页面」「整门课到哪了」「正在做的这一个」「这一页的账」是同一件事的四层，
        // 原来拆成两张卡：多一层卡壳（上下内边距 + 外边距 + 边框 ≈ 40px）、多一个
        // 「任务进度」标题（20px），而这两样都在重复上面那张卡已经说过的话。合成一张之后
        // 首页从四张卡变三张，第三张「常用设置」才进得了这块 390px 的滚动区。
        // 第 85 轮去掉了「最近动态」卡（=日志页尾巴的重复渲染）：正在做什么，上面那张
        // 总览卡的「当前任务 + 进度」已经说了；要翻动态去日志页。总览剩两张卡：总览 + 常用设置。
        const elYktCourses = h("div", { class: "card hide" });
        let yktCoursesKey = "", yktCourseAction = null;
        const elYktCourseSelect = h("select", { style: { width: "100%", minWidth: "0", margin: "8px 0" },
            onchange: () => { bYktCourse.disabled = !elYktCourseSelect.value; } });
        const bYktCourse = h("button", { type: "button", disabled: true, onclick: () => {
            if (elYktCourseSelect.value && yktCourseAction) yktCourseAction(elYktCourseSelect.value);
        } }, "进入并扫描任务");
        function setYktCourses(courses, onSelect) {
            yktCourseAction = onSelect;
            elYktCourses.classList.toggle("hide", !courses);
            if (!courses) { yktCoursesKey = ""; return; }
            const key = JSON.stringify(courses.map(c => [c.id, c.name, c.className]));
            if (key === yktCoursesKey) return;
            yktCoursesKey = key;
            const selected = elYktCourseSelect.value;
            elYktCourseSelect.replaceChildren(h("option", { value: "" }, "请选择课程"));
            courses.forEach(c => elYktCourseSelect.appendChild(h("option", { value: c.id },
                c.name + (c.className ? " · " + c.className : ""))));
            elYktCourseSelect.value = courses.some(c => c.id === selected) ? selected : "";
            bYktCourse.disabled = !elYktCourseSelect.value;
            elYktCourses.replaceChildren(
                h("div", { class: "hd" }, h("span", { class: "ct" }, "雨课堂课程")),
                h("div", { class: "secondary" }, courses.length
                    ? "首页已识别 " + courses.length + " 门课程，进入课程后读取具体任务。"
                    : "等待首页课程加载；请在网站选择「我听的课」。"),
                elYktCourseSelect, bYktCourse,
                h("div", { class: "secondary", style: { marginTop: "8px" } },
                    "开启「自动播放并连播」后，扫描完成会自动播放。"));
        }
        pages.stat.appendChild(h("div", { class: "scroll" }, [
            elYktCourses,
            h("div", { class: "card" }, [elWhere,
                h("div", { style: { marginTop: "8px" } }, [elStatNow, elStatBar]),
                h("div", { class: "band" }, [elNow, elNowBar, elTaskLine])]),
            h("div", { class: "card" }, [
                h("div", { class: "hd" }, [h("span", { class: "ct" }, profile.name + " · 常用功能"),
                    h("button", { class: "lnk", onclick: () => openTab("set") }, "本平台设置")]),
                elHomeCfg, elHomeMore
            ])
        ]));

        // ── 答题页：题号方格 + 选中那题的详情 ──
        const elQGrid = h("div", { class: "qgrid" });
        const elQDetail = h("div", { class: "scroll qd" });
        const bExport = h("button", { onclick: () => exportRows() }, "导出 CSV");
        bExport.disabled = true;
        // 那片题号方格是三种颜色，颜色自己不说自己是什么意思。数字放标题栏，黄格代表什么
        // 直接写在同一句里 —— 比另起一行画图例省一行高度，说的是同一件事。
        const elQSum = h("span", { class: "sum" });
        // 进度页的「答题记录」段：题号方格 + 选中那题详情。页面骨架在下面 progSeg 处统一拼。

        function addRow(p) {
            // 同一道题重复 push(重试、或引擎 index-- 重跑)时按 rowKey 原地更新，别再追加一行 ——
            // 追加会让方格顺序和题号错位、后面题的答案(按行键回填)又盖到前面，这正是"顺序重复/错位"的根。
            if (p.rowKey) {
                const exist = st.rows.find(r => r.rowKey === p.rowKey);
                if (exist) {
                    exist.question = p.question; exist.answer = p.answer; exist.style = p.style;
                    exist.searchError = p.searchError || ""; exist.requestAi = p.requestAi === true; exist.aiError = "";
                    const k = st.rows.indexOf(exist);
                    exist.btn.dataset.tip = String(p.question || "").replace(/<[^>]*>/g, "").slice(0, 90);
                    paintQnum(exist, k); selectRow(k); showProgSeg("quiz");
                    return exist;
                }
            }
            const row = { question: p.question, answer: p.answer, style: p.style, rowKey: p.rowKey,
                searchError: p.searchError || "", requestAi: p.requestAi === true, aiError: "" };
            const i = st.rows.length;
            st.rows.push(row);
            row.btn = h("button", { class: "qn", onclick: () => selectRow(i) }, String(i + 1));
            // 方格上只有个号，题干靠悬停看
            row.btn.dataset.tip = String(p.question || "").replace(/<[^>]*>/g, "").slice(0, 90);
            elQGrid.appendChild(row.btn);
            bExport.disabled = false;
            // 新题自动选中：默认看到的就是刚做的那一道
            selectRow(i);
            elQGrid.scrollTop = elQGrid.scrollHeight;
            // 开始答题了就把进度页切到「答题记录」段，否则新题落在藏着的那段里看不见
            showProgSeg("quiz");
            return row;
        }
        function paintQnum(row, i) {
            if (i === undefined) i = st.rows.indexOf(row);
            row.btn.className = "qn"
                + (row.style === "warning-row" ? " warn" : row.style === "success-row" ? " ok" : "")
                + (i === st.cur ? " on" : "");
        }
        function selectRow(i) {
            st.cur = i;
            st.rows.forEach(paintQnum);
            paintQuiz();
        }
        function paintQuiz() {
            paintProgBadge();
            const sim = st.rows.filter(r => r.style === "warning-row" && !r.searchError).length;
            const unresolved = st.rows.filter(r => r.style === "warning-row" && r.searchError).length;
            elQSum.textContent = !st.rows.length ? ""
                : st.rows.length + " 题" + (sim ? " · 黄格 " + sim + " 题只有相似答案" : "")
                    + (unresolved ? " · " + unresolved + " 题尚未取得答案" : "");
            paintNow();
            const row = st.rows[st.cur];
            if (!row) {
                elQDetail.replaceChildren(h("div", { class: "empty" }, [h("i", null, "📝"), "等着抓题目…"]));
                return;
            }
            const kids = [h("div", { class: "q" }, safeHtml(row.question))];
            if (row.style === "warning-row" && (row.searchError || row.aiError || row.requestAi)) {
                kids.push(h("div", { class: "ans" }, [
                    h("span", { class: "tag warning" }, row.aiError ? "AI 未完成答题" : row.requestAi ? "正在等待 AI 回答" : "尚未取得答案"),
                    h("div", { class: "secondary" }, row.searchError || "题库未返回精确答案"),
                    row.aiError ? h("div", { class: "a" }, row.aiError) : null
                ]));
            } else if (row.style === "warning-row") {
                // 相似答案往往几百字，默认折起来。details/summary 是原生的，零 JS
                kids.push(h("div", { class: "ans" }, [
                    h("span", { class: "tag warning" }, "题库没给精确答案"),
                    h("details", null, [
                        h("summary", null, "点开看相似答案"),
                        h("div", { class: "sim" }, safeHtml(row.answer))
                    ])
                ]));
            } else {
                kids.push(h("div", { class: "ans" }, [
                    h("span", { class: "tag success" }, "已填充"),
                    h("div", { class: "a" }, safeHtml(row.answer))
                ]));
            }
            elQDetail.replaceChildren(h("div", null, kids));
        }

        // ── 进度页的「任务点」段 ──
        const elTaskBox = h("div", { class: "scroll" });
        const bTaskClear = h("button", { class: "del", onclick: () => { st.tasks = []; paintTasks(); } }, "清空");
        const elTaskSum = h("span", { class: "sum" });

        // ── 进度页骨架：任务点 / 答题记录 分段切换 ──
        // 第 85 轮把原来的「答题」「任务」两个标签合成这一个。两段很少同时用：刷课看任务点、
        // 考试看答题记录。分段控件切哪段就显示哪段，标题栏右边的动作按钮（清空 / 导出）跟着换。
        const segTask = h("button", { class: "seg-btn on", type: "button", onclick: () => showProgSeg("task") }, "任务点");
        const segQuiz = h("button", { class: "seg-btn", type: "button", onclick: () => showProgSeg("quiz") }, "答题记录");
        const elTaskPane = h("div", { class: "prog-pane" }, elTaskBox);
        const elQuizPane = h("div", { class: "prog-pane hide" }, [elQGrid, elQDetail]);
        function showProgSeg(which) {
            st.prog = which;
            segTask.classList.toggle("on", which === "task");
            segQuiz.classList.toggle("on", which === "quiz");
            elTaskPane.classList.toggle("hide", which !== "task");
            elQuizPane.classList.toggle("hide", which !== "quiz");
            // 标题栏右边只留当前段那套（汇总数字 + 动作按钮），另一套藏起来
            elTaskSum.classList.toggle("hide", which !== "task");
            bTaskClear.classList.toggle("hide", which !== "task");
            elQSum.classList.toggle("hide", which !== "quiz");
            bExport.classList.toggle("hide", which !== "quiz");
        }
        pages.prog.appendChild(h("div", { class: "phead" }, [
            h("div", { class: "seg" }, [segTask, segQuiz]),
            elTaskSum, elQSum, h("span", { class: "sp" }), bTaskClear, bExport
        ]));
        pages.prog.appendChild(elTaskPane);
        pages.prog.appendChild(elQuizPane);
        showProgSeg("task");
        paintQuiz();

        function upsertTask(p) {
            // 按 key 合并，不是整行替换。视频每分钟只报 note/pct 两样（见 cxTaskNote），
            // 整行替换会把 name/chapter 抹成空、state 从"进行中"退回"待做" —— 任务点那
            // 一行就变成一个光秃秃的 jobid。所以只有载荷里真带了的字段才动。
            const i = st.tasks.findIndex(t => t.key === p.key);
            const row = i >= 0 ? st.tasks[i]
                : { key: p.key, icon: "•", name: p.key, chapter: "", mark: "", state: "待做" };
            if (i < 0) st.tasks.push(row);
            if (p.kind !== undefined) row.icon = TASK_ICON[p.kind] || "•";
            if (p.name !== undefined) row.name = p.name || p.key;
            if (p.chapter !== undefined) row.chapter = p.chapter || "";
            if (p.mark !== undefined) row.mark = p.mark || "";
            if (p.note !== undefined) row.note = p.note;
            if (p.pct !== undefined) row.pct = p.pct;
            // 状态一变，上个状态留下的分钟数就过期了 —— "已完成 11/12 分钟"是骗人
            if (p.state !== undefined && p.state !== row.state) {
                row.state = p.state;
                if (p.state !== "进行中") {
                    if (p.note === undefined) row.note = "";
                    if (p.pct === undefined) row.pct = -1;
                }
            }
            paintTasks();
        }
        // 这份账有两个读者，能给的地方不一样大：进度页任务点段的标题栏右边还有「清空」，塞下
        // 这些数字就是一条灰句子，而且每个数在同屏每行行尾本来就各挂着一个状态标签 —— 等于把
        // 看得见的东西又说了一遍。总览那张卡有整行宽度，排药丸。所以这里只出数，画法各自写。
        const TASK_STATES = ["已完成", "进行中", "待确认", "待做", "跳过", "失败", "不支持"];
        function taskCounts() {
            return TASK_STATES.map(k => [k, st.tasks.filter(t => t.state === k).length])
                .filter(p => p[1]);
        }
        function taskSummary() {
            if (!st.tasks.length) return "";
            return taskCounts()
                .map(p => (p[0] === "已完成" ? "完成 " : p[0] + " ") + p[1]).join(" · ");
        }
        function paintTasks() {
            elTaskBox.replaceChildren();
            if (!st.tasks.length) {
                elTaskBox.appendChild(h("div", { class: "empty" }, [h("i", null, "🎬"), "还没扫到任务点"]));
            } else {
                st.tasks.forEach(t => elTaskBox.appendChild(h("div", { class: "tk" }, [
                    h("span", { class: "ico" }, t.icon),
                    h("div", { class: "nm" }, [h("div", null, [taskMark(t.mark), t.name]),
                        t.chapter ? h("small", null, t.chapter) : null]),
                    h("span", { class: "tag " + (TASK_TAG[t.state] || "info") },
                        t.state + (t.note ? " " + t.note : ""))
                ])));
            }
            // 标题栏只放一个数："做完几个 / 共几个"。细分在下面每一行的行尾都写着。
            const c = taskCounts();
            const done = st.tasks.filter(t => t.state === "已完成").length;
            elTaskSum.textContent = st.tasks.length ? "完成 " + done + "/" + st.tasks.length : "";
            elTaskLine.replaceChildren.apply(elTaskLine, c.length
                ? c.map(p => h("span", { class: "tag " + (TASK_TAG[p[0]] || "info") },
                    p[0] + " " + p[1]))
                : [h("span", { class: "secondary" }, "还没扫到任务点")]);
            bTaskClear.disabled = !st.tasks.length;
            paintProgBadge();
            paintNow();
        }
        // 进度标签上的角标：任务点 + 答题两段合一个数（两段很少同时有数：刷课用任务点、
        // 考试用答题）。有任务失败/不支持就变黄，一眼看出"有没做成的"。答题那段本来就没有
        // 失败态（只有"相似答案"的黄格，不算错），所以红/黄只看任务段。
        function paintProgBadge() {
            const n = st.tasks.length + st.rows.length;
            const bad = st.tasks.filter(t => t.state === "失败" || t.state === "不支持").length;
            badges.prog.textContent = n;
            badges.prog.className = "bd" + (bad ? " warn" : "") + (n ? "" : " hide");
        }

        // ── 日志页 ──
        // 级别：type 是调用点明确给的，最可信；只有文字的那些才去猜。
        // ponytail: 关键词表是启发式，认错了顶多颜色不对。要让新的失败提示标红就往里加词。
        function logLevel(msg, type) {
            if (type === "error") return "error";
            // 'stop' 是普通 tip 那条路上的副作用指令，'warn' 是 logMsg 直接给的级别
            if (type === "stop" || type === "warn") return "warn";
            const s = String(msg || "");
            if (/失败|异常|错误|未找到|无法|不可用/.test(s)) return "error";
            if (/超时|跳过|暂停|未达标|无精确|请手动/.test(s)) return "warn";
            return "info";
        }
        const elLogScroll = h("div", { class: "scroll" });
        const bLogExport = h("button", { onclick: () => exportLogs() }, "导出");
        const bLogClear = h("button", { class: "del", onclick: () => { st.logs = []; paintLogs(); } }, "清空");
        const elLogSum = h("span", { class: "sum" });
        pages.log.appendChild(h("div", { class: "phead" },
            [h("b", null, "运行日志"), elLogSum, h("span", { class: "sp" }), bLogExport, bLogClear]));
        // 定位用的筛选条：按级别、按来源（超星/智慧树/…/AI）筛，再加关键字搜索。长日志里快速找那几条。
        const logFilter = { level: "", src: "", q: "" };
        const selStyle = { fontSize: "12px", padding: "2px 4px", borderRadius: "6px", border: "1px solid var(--ln)",
            background: "var(--sf)", color: "var(--t2)", maxWidth: "92px" };
        const elLogLevel = h("select", { style: selStyle, onchange: e => { logFilter.level = e.target.value; paintLogs(); } }, [
            h("option", { value: "" }, "全部级别"), h("option", { value: "error" }, "仅错误"),
            h("option", { value: "warn" }, "仅警告"), h("option", { value: "info" }, "仅信息")]);
        const elLogSrc = h("select", { style: selStyle, onchange: e => { logFilter.src = e.target.value; paintLogs(); } },
            [h("option", { value: "" }, "全部来源")]);
        const elLogQ = h("input", { type: "search", placeholder: "搜索日志…",
            style: { flex: "1 1 90px", minWidth: "70px", fontSize: "12px", padding: "3px 6px", borderRadius: "6px",
                     border: "1px solid var(--ln)", background: "var(--sf)", color: "var(--t1)" },
            oninput: e => { logFilter.q = e.target.value.trim().toLowerCase(); paintLogs(); } });
        pages.log.appendChild(h("div", { class: "lg-filter",
            style: { display: "flex", gap: "6px", alignItems: "center", padding: "0 0 6px", flexWrap: "wrap" } },
            [elLogLevel, elLogSrc, elLogQ]));
        pages.log.appendChild(elLogScroll);

        function pushLog(msg, type, src, ctx) {
            if (!msg) return;
            const d = new Date();
            const pad = n => String(n).padStart(2, "0");
            const t = pad(d.getHours()) + ":" + pad(d.getMinutes()) + ":" + pad(d.getSeconds());
            const last = st.logs[st.logs.length - 1];
            // "正在使用 AI 搜题，请稍候..." 这类一轮要发好几次，不折叠的话日志九成是它
            if (last && last.msg === msg && last.src === (src || "")) { last.n++; last.t = t; }
            else {
                st.logs.push({ t: t, msg: String(msg), level: logLevel(msg, type), n: 1, src: src || "", ctx: ctx || "" });
                // 一场考试能刷出很多条，不封顶就是内存泄漏
                if (st.logs.length > 500) st.logs.splice(0, st.logs.length - 500);
            }
            paintLogs();
        }
        // 来源标签的小色片：一眼区分超星/智慧树/职教云/雨课堂/AI/问答。
        const SRC_COLOR = { "超星": "#2563eb", "智慧树": "#15a34a", "职教云": "#c2740a", "雨课堂": "#7c3aed",
            "AI": "#db2777", "问答": "#0891b2", "通用": "#697586" };
        function srcChip(src) {
            if (!src) return null;
            const c = SRC_COLOR[src] || "#697586";
            return h("span", { class: "lg-src", style: { flex: "none", fontSize: "11px", lineHeight: "1.4",
                padding: "0 5px", borderRadius: "6px", color: c, border: "1px solid " + c,
                background: "transparent" } }, src);
        }
        // 一条日志长什么样只写一处（日志页画全部，上限 500）。
        // prev 是上一行（同一份渲染里的），只用来判"时间戳跟上一行一样吗"。脚本一秒能出
        // 五六条，每条都印满就是一列重复的数字：真机日志里九行挂着九个一模一样的
        // 10:15:42，占掉整行 13% 的宽，一个字的信息都没有。
        function logRow(l, prev) {
            return h("div", { class: "lg " + l.level }, [
                h("span", { class: "t" + (prev && prev.t === l.t ? " dup" : "") }, l.t),
                srcChip(l.src),
                h("span", { class: "m" }, l.ctx ? ("[" + l.ctx + "] " + l.msg) : l.msg),
                l.n > 1 ? h("span", { class: "c" }, "×" + l.n) : null
            ]);
        }
        function logMatchesFilter(l) {
            if (logFilter.level && l.level !== logFilter.level) return false;
            if (logFilter.src && (l.src || "") !== logFilter.src) return false;
            if (logFilter.q && ((l.ctx || "") + " " + l.msg).toLowerCase().indexOf(logFilter.q) < 0) return false;
            return true;
        }
        function syncLogSrcOptions() {
            // 来源下拉只列当前日志里真出现过的来源，选中项保留
            const seen = Array.from(new Set(st.logs.map(l => l.src).filter(Boolean)));
            const want = '["' + seen.join('","') + '"]';
            if (elLogSrc.dataset.seen === want) return;
            elLogSrc.dataset.seen = want;
            const cur = logFilter.src;
            elLogSrc.replaceChildren(h("option", { value: "" }, "全部来源"));
            seen.forEach(s => elLogSrc.appendChild(h("option", { value: s }, s)));
            elLogSrc.value = seen.includes(cur) ? cur : "";
            if (elLogSrc.value !== cur) logFilter.src = elLogSrc.value;
        }
        function paintLogs() {
            syncLogSrcOptions();
            elLogScroll.replaceChildren();
            const shown = st.logs.filter(logMatchesFilter);
            if (!st.logs.length) {
                elLogScroll.appendChild(h("div", { class: "empty" }, [h("i", null, "📋"), "还没有日志"]));
            } else if (!shown.length) {
                elLogScroll.appendChild(h("div", { class: "empty" }, [h("i", null, "🔍"), "没有符合筛选的日志"]));
            } else {
                shown.forEach((l, i) => elLogScroll.appendChild(logRow(l, shown[i - 1])));
            }
            const filtering = logFilter.level || logFilter.src || logFilter.q;
            elLogSum.textContent = filtering ? (shown.length + " / " + st.logs.length) : (st.logs.length + "/500");
            bLogExport.disabled = bLogClear.disabled = !st.logs.length;
            // 收起时也看得见"出过几次错"，不用点开翻
            const errs = st.logs.reduce((s, l) => s + (l.level === "error" ? l.n : 0), 0);
            badges.log.textContent = errs;
            badges.log.className = "bd error" + (errs ? "" : " hide");
            // 新日志贴着底部走，否则看到的永远是最早那几条
            if (st.tab === "log") elLogScroll.scrollTop = elLogScroll.scrollHeight;
        }

        // ── 导出 ──
        // CSV 转义只写一份：题干带逗号/引号/换行/HTML 都很常见，双引号包起来、
        // 内部双引号翻倍，否则 Excel 打开就串列。表格里存的是 HTML 片段，导出成纯文本。
        function csvEsc(v) {
            return '"' + String(v == null ? "" : v).replace(/<[^>]*>/g, "").replace(/"/g, '""') + '"';
        }
        function downloadCsv(rows, name) {
            // BOM 要写成 \ufeff 转义，不能写那个字符本身：去掉它 Excel 打开中文全是乱码，
            // 而字符本身是看不见的 —— 谁顺手整理一下文件编码就能把它弄丢，还没人看得出少了什么
            const blob = new Blob(["\ufeff" + rows.join("\r\n")], { type: "text/csv;charset=utf-8" });
            const url = URL.createObjectURL(blob);
            const d = new Date();
            const pad = n => String(n).padStart(2, "0");
            const a = h("a", {
                href: url,
                download: name + "_" + d.getFullYear() + pad(d.getMonth() + 1) + pad(d.getDate())
                    + "_" + pad(d.getHours()) + pad(d.getMinutes()) + pad(d.getSeconds()) + ".csv"
            });
            top.document.body.appendChild(a);
            a.click();
            a.remove();
            // 立刻 revoke 会让下载拿不到内容，等一拍再放
            setTimeout(() => URL.revokeObjectURL(url), 1000);
        }
        function exportRows() {
            if (!st.rows.length) return;
            const label = { "success-row": "已填充", "warning-row": "无精确答案" };
            const out = [["题号", "题目", "答案", "状态"].join(",")];
            st.rows.forEach((r, i) => out.push([i + 1, csvEsc(r.question), csvEsc(r.answer),
                csvEsc(label[r.style] || r.style || "")].join(",")));
            downloadCsv(out, "答题记录");
            toast("已导出 " + st.rows.length + " 条记录");
        }
        function exportLogs() {
            if (!st.logs.length) return;
            // 导出带一段环境头：版本 / 平台 / 页面地址 / UA / 时间 —— 你把日志发来我能先对上版本和环境再定位。
            const head = [
                "# 答题助手日志导出",
                "# 版本," + csvEsc((GM_info && GM_info.script && GM_info.script.version) || "未知"),
                "# 平台," + csvEsc(panelPlatform(location.href).name || ""),
                "# 页面," + csvEsc(location.href),
                "# UA," + csvEsc(navigator.userAgent),
                "# 导出时间," + csvEsc(new Date().toLocaleString())
            ];
            const out = head.concat([["时间", "来源", "级别", "定位", "内容", "重复次数"].join(",")]);
            st.logs.forEach(l => out.push([l.t, csvEsc(l.src || ""), l.level, csvEsc(l.ctx || ""), csvEsc(l.msg), l.n].join(",")));
            downloadCsv(out, "答题日志");
        }

        // ── AI 页 ──
        const elAiScroll = h("div", { class: "scroll" });
        const elAiIn = h("input", { placeholder: "输入题目或粘贴内容…", onkeydown: e => {
            if (e.key === "Enter") sendAi(false);
        } });
        const elAiSend = h("button", { tip: "发送", onclick: () => sendAi(false) }, "➤");
        // 别的页标题栏都带一句"这一页是干什么的"。这一页不写，看着就像个可选的聊天玩具，
        // 而它其实是答题那条链的最后一环。
        pages.ai.appendChild(h("div", { class: "phead" },
            [h("b", null, "AI 智能助手"),
             h("span", { class: "secondary" }, "题库没给精确答案时自动转到这里"),
             h("span", { class: "sp" }),
             // 随时能重新领 key 的入口（key 过期是 AI 用不了的头号原因）
             h("button", { class: "lnk", onclick: () => openTokenHelp() }, "重新获取 key")]));
        pages.ai.appendChild(elAiScroll);
        pages.ai.appendChild(h("div", { class: "ai-in" }, [elAiIn, elAiSend]));

        function pushChat(role, content) {
            st.chat.push({ role: role, content: content });
            elAiScroll.appendChild(h("div", { class: "msg " + (role === "user" ? "me" : role === "system" ? "sys" : "") },
                h("div", { class: "bb" }, safeHtml(String(content).split("\n").join("<br>")))));
            elAiScroll.scrollTop = elAiScroll.scrollHeight;
        }
        function setAiLoading(v) {
            st.aiLoading = !!v;
            elAiSend.disabled = st.aiLoading;
            elAiSend.textContent = st.aiLoading ? "…" : "➤";
        }
        // 测试、手动提问、自动搜题统一读取当前面板的同一份配置。
        // 不依赖另一帧的 GM 存档何时同步,也不在空输入框下偷偷补一个默认地址。
        function readAiConfig() {
            const read = key => String(inputs[key] ? inputs[key].read() : cxSet(key) || "").trim();
            return { ai_platform: read("ai_platform"), ai_api_url: read("ai_api_url"),
                ai_api_key: read("ai_api_key"), ai_model: read("ai_model") };
        }
        // silent：自动答题走的路。消息照样进历史（方便回看），但不切标签页打断用户
        function sendAi(silent, text) {
            const q = String(text === undefined ? elAiIn.value : text).trim();
            if (!q) return;
            const id = ++st.aiReqId;
            const config = readAiConfig();
            if (!config.ai_api_key || !config.ai_api_url) {
                setAiLoading(false);
                const miss = !config.ai_api_key ? "AI key" : "接口地址";
                if (!silent) toast("请先在设置里填" + miss, "error");
                // 静默路径必须回一声，否则父页面的 waitForAiAnswer 会一直等到超时
                else post({ type: "ai_fill", answer: "", question: st.aiQuestion, error: true, reason: "请先在设置里填写" + miss });
                return;
            }
            // token 已被判定无效：自动答题这一路别再逐题空打（每题都 401、每题白等 25 秒，一份卷子
            // 拖成几分钟）。直接回一声让引擎接着走；用户重填 token 或测试连接成功后 aiKeyBad 会清掉。
            // 手动问答（!silent）不拦：用户可能刚重填了 key 想当场试。
            if (silent && st.aiKeyBad) {
                post({ type: "ai_fill", answer: "", question: st.aiQuestion, error: true, reason: "AI key 无效或已过期,请更新后重试" });
                return;
            }
            if (silent && st.chat.length) pushChat("system", "--- 自动搜题 ---");
            pushChat("user", q);
            if (text === undefined) elAiIn.value = "";
            setAiLoading(true);
            // 前端超时：父页面那边万一一声不回，按钮不能永远转着。
            // 引擎现在会自动重试（最多 3 次、每次上限 120s + 退避），单题总耗时能到几分钟，
            // 所以这个兜底要比"引擎重试到底"的最坏耗时还长，否则还在重试这边就先报超时了。
            setTimeout(() => {
                if (st.aiLoading && st.aiReqId === id) {
                    setAiLoading(false);
                    pushChat("assistant", "请求超时，请重试或检查网络连接");
                }
            }, 500000);
            post({
                type: "ai_request",
                requestId: id,
                api_url: config.ai_api_url,
                api_key: config.ai_api_key,
                model: config.ai_model,
                // 只发当前这一题：带上历史会让 AI 拿上一题的选项来答这一题
                messages: [{ role: "user", content: q }]
            });
        }
        function recvAi(p) {
            if (p.requestId !== undefined && p.requestId !== st.aiReqId) return;
            setAiLoading(false);
            let err = "";
            if (!p.success) {
                // 引擎把非 200 拼成 "HTTP错误 401: {一大段 JSON}"，直接显示又长又难懂 ——
                // 走 cleanAiErr 抽成 "HTTP 401：无效的令牌" 这种短句（跟测试连接一个口径）。
                err = cleanAiErr(p.error);
            } else {
                const raw = p.response || "";
                if (!raw || typeof raw !== "string") err = "AI 响应为空";
                else if (raw.trim()[0] === "<") err = "API 返回了 HTML 错误页面，请检查接口地址";
                else {
                    try {
                        const res = JSON.parse(raw);
                        // 原生 aip.baidubce.com 返的是 { result: "..." }，不是 OpenAI 的 choices ——
                        // 只认 choices 的话，「百度原生接口」这一档必定报"未知响应格式"
                        const content = res.choices && res.choices[0] && res.choices[0].message
                            ? res.choices[0].message.content
                            : (typeof res.result === "string" ? res.result : null);
                        if (content) {
                            // 有答案 = key 是好的，撤掉之前的"无效"标记，AI 答题恢复
                            st.aiKeyBad = false; st.aiKeyHelpShown = false;
                            pushChat("assistant", content);
                            post({ type: "ai_fill", answer: content, question: st.aiQuestion });
                            return;
                        }
                        err = res.error ? "API 错误: " + (res.error.message || JSON.stringify(res.error))
                            : res.message ? "API 错误: " + res.message + (res.code ? " (" + res.code + ")" : "")
                            : "未知响应格式";
                    } catch (e) {
                        err = "解析响应失败: " + e.message + "，请检查 API Key 是否正确";
                    }
                }
            }
            // token/令牌无效：标记住，自动答题这一路就别再逐题空打 AI（每题都 401 白等 25 秒，
            // 见 sendAi 开头那道闸）；并弹一次"去重新获取"引导（扫码领新 key）。
            if (isAiKeyErr(err)) {
                err += "（key 无效或已过期，请重新获取）";
                st.aiKeyBad = true;
                if (!st.aiKeyHelpShown) {
                    toast("AI key 无效，去重新获取", "error");
                    openTokenHelp("当前 key 无效或已过期，AI 答不了题了。扫码领一个新的填回去。");
                }
            }
            pushChat("assistant", err);
            // 通知父页面别再等了，否则 waitForAiAnswer 要空等满 ai_timeout
            post({ type: "ai_fill", answer: "", question: st.aiQuestion, error: true, reason: err });
        }

        // ── 测试连接 ──
        // 拿当前这三栏（接口地址 / token / 模型）真打一发，把成败和耗时显示在按钮旁边。
        // 用的是和自动答题一模一样的 ai_request 通路（带 test:true），所以测得过 = 答题也用得了；
        // 顺带量一下往返耗时，比「AI 等待上限」还慢就当场提示调大——这正是自定义接口"用不了"
        // 最常见的原因：接口通、但冷启动几十秒，答题时每题都等超时被跳过。
        let elAiTest = null;
        function setAiTest(text, cls) {
            if (!elAiTest) return;
            elAiTest.textContent = text;
            elAiTest.className = "ai-test-msg" + (cls ? " " + cls : "");
        }
        function sendAiTest() {
            const config = readAiConfig();
            if (!config.ai_api_key) { setAiTest("请先填 key", "err"); return; }
            if (!config.ai_api_url) { setAiTest("请先填接口地址", "err"); return; }
            // 包含尚未触发 change/blur 的输入;保存和请求都使用这个快照。
            save(config);
            st.aiTesting = true;
            st.aiTestT0 = Date.now();
            st.aiTestId = (st.aiTestId || 0) + 1;
            const id = st.aiTestId;
            st.aiTestConfig = config;
            setAiTest("测试中…", "");
            post({
                type: "ai_request", test: true,
                requestId: "test:" + id,
                api_url: config.ai_api_url, api_key: config.ai_api_key, model: config.ai_model,
                messages: [{ role: "user", content: "回复一个字：好" }]
            });
            // 引擎那次 GM_xmlhttpRequest 上限 120 秒；给 125 秒兜底，让它自己的超时错先回来
            // （否则慢接口还在路上，这边先报了假超时）
            setTimeout(() => {
                if (st.aiTesting && st.aiTestId === id) {
                    st.aiTesting = false;
                    setAiTest("超时没回话，检查地址 / 网络 / key", "err");
                }
            }, 125000);
        }
        // 是不是 token/令牌类的错（401/403、鉴权失败、无效令牌、api key 之类）。命中就该
        // 提示重新获取，而不是让用户对着一串鉴权错自己猜。判据放宽一点，宁可多提示一次。
        function isAiKeyErr(text) {
            const s = String(text || "");
            return /\b(401|403)\b/.test(s)
                || /令牌|鉴权|认证失败|未授权|无效.{0,4}(key|token|密钥)|(key|token|密钥).{0,4}(无效|错误|过期|失效)/i.test(s)
                || /unauthor|invalid[\s_-]*(api[\s_-]*)?(key|token)|api[\s_-]*key.*(invalid|expired)|forbidden/i.test(s);
        }
        // 「重新获取 token」引导弹窗：扫码领新 key + 一键跳去设置填。复用 AI 配置里那张小程序码。
        function openTokenHelp(reason) {
            st.aiKeyHelpShown = true;
            dialog({
                title: "重新获取 AI key", ok: "去设置填 key", cancel: "关了",
                content: h("div", null, [
                    h("p", { class: "secondary", style: { marginBottom: "8px", lineHeight: "1.7" } },
                        reason || "key 无效或已过期，AI 答题用不了。微信扫码进小程序领一个新的，填回「设置 → AI 配置 → key」。"),
                    h("img", { src: WX_QR, draggable: false, alt: "扫码获取 key",
                        style: { width: "168px", display: "block", margin: "0 auto 6px", borderRadius: "8px" } }),
                    h("p", { class: "secondary", style: { textAlign: "center" } }, "微信扫码领取 key"),
                    // 图解：小程序复制 API Key → 粘到面板「key」栏（弹窗体 .dc 可滚动，图不撑破布局）
                    h("p", { class: "secondary", style: { margin: "10px 0 6px" } }, "填到哪？照着下图："),
                    guideImg("把小程序领取的 key 填进面板的 key 栏")
                ])
            }).then(go => { if (go) { openTab("set"); toast("在 AI 配置 → key 里填新 key", "info"); } });
        }
        // 引擎把非 200 的错拼成 "HTTP错误 401: {一大段 JSON}"，直接显示又长又难懂。
        // 抽出 JSON 里的 message、配上 HTTP 码，去掉 request id 那截噪声，短句显示。
        function cleanAiErr(raw) {
            raw = String(raw == null ? "请求出错" : raw);
            const code = (raw.match(/\b([45]\d\d)\b/) || [])[1];
            const brace = raw.indexOf("{");
            let msg = "";
            if (brace >= 0) {
                try {
                    const j = JSON.parse(raw.slice(brace));
                    msg = (j.error && (j.error.message || j.error.code)) || j.message || "";
                } catch (e) { /* 不是 JSON 就原样截断 */ }
            }
            if (!msg) msg = raw;
            msg = msg.replace(/\s*[（(]request id:[^）)]*[）)]/i, "").trim();  // 去掉 request id 噪声
            return (code ? "HTTP " + code + "：" : "") + msg.slice(0, 90);
        }
        function recvAiTest(p) {
            if (!st.aiTesting) return;   // 兜底超时已经处理过、或根本没在测：迟到的回话直接丢
            if (p.requestId !== undefined && p.requestId !== "test:" + st.aiTestId) return;
            st.aiTesting = false;
            if (JSON.stringify(readAiConfig()) !== JSON.stringify(st.aiTestConfig)) {
                setAiTest("配置已更改，请重新测试当前配置", "err"); return;
            }
            const ms = st.aiTestT0 ? ((Date.now() - st.aiTestT0) / 1000).toFixed(1) : "?";
            if (!p.success) {
                let e = cleanAiErr(p.error);
                // 401 / 令牌类错误最常见的原因就一个：token 填错或过期。标记 aiKeyBad（自动答题
                // 就不再空打），提示里挂个"重新获取"入口，点开就是扫码领 key 那张弹窗。
                if (isAiKeyErr(e)) {
                    e += "（key 填错或过期，扫下面的小程序码重新领一个）";
                    st.aiKeyBad = true;
                    setAiTest("失败（" + ms + "秒）：" + e, "err");
                    return;
                }
                setAiTest("失败（" + ms + "秒）：" + e, "err");
                return;
            }
            // 成败判据跟 recvAi 一套：认 choices[0].message.content，也认原生百度的 { result }
            let ok = false, why = "响应里没有答案内容";
            const raw = p.response || "";
            if (!raw || typeof raw !== "string") why = "响应为空";
            else if (raw.trim()[0] === "<") why = "返回的是 HTML，接口地址多半不对";
            else {
                try {
                    const res = JSON.parse(raw);
                    const content = res.choices && res.choices[0] && res.choices[0].message
                        ? res.choices[0].message.content
                        : (typeof res.result === "string" ? res.result : null);
                    if (content) ok = true;
                    else if (res.error) why = "API 错误：" + String(res.error.message || JSON.stringify(res.error)).slice(0, 60);
                    else if (res.message) why = "API 错误：" + String(res.message).slice(0, 60);
                } catch (e) { why = "响应解析失败：" + e.message; }
            }
            if (!ok) { setAiTest("失败（" + ms + "秒）：" + why, "err"); return; }
            // 测通了 = token 有效，撤掉"无效"标记，自动答题恢复用 AI
            st.aiKeyBad = false; st.aiKeyHelpShown = false;
            let msg = "连接成功（" + ms + "秒）";
            const limit = Number(cxSet("ai_timeout")) || 25;
            if (Number(ms) > limit * 0.7) {
                msg += "，偏慢：建议把「AI 等待上限」调到 " + (Math.ceil(Number(ms)) + 10)
                    + " 秒以上，否则答题时这题容易等不及被跳过";
            }
            setAiTest(msg, "ok");
        }
        // 「测试连接」按钮 + 结果。不塞进设置表格里（table-cell 会被长文本撑破、横着溢出）——
        // 单独一个 flex 块挂在 AI 配置组末尾，结果另起一整行铺满换行（见 buildSettings、.ai-test 样式）
        function aiTestRow() {
            const btn = h("button", { class: "btn", type: "button", onclick: sendAiTest }, "测试连接");
            elAiTest = h("span", { class: "ai-test-msg" });
            return h("div", { class: "ai-test" }, [btn, elAiTest]);
        }
        // 填 key 教程图：小程序复制 API Key → 粘到面板「key」栏（内联 GUIDE_KEY_IMG，不走网络）。
        // 统一一个元素，弹窗和设置页都用；宽度跟随容器、绝不撑破布局。
        function guideImg(alt) {
            return h("img", { src: GUIDE_KEY_IMG, draggable: false, alt: alt || "填 key 教程",
                style: { width: "100%", maxWidth: "100%", display: "block", borderRadius: "8px",
                         border: "1px solid rgba(0,0,0,.1)" } });
        }
        // 没有 key？默认档的额度就靠扫这个微信小程序码去领，领来填到上面「key」栏
        function aiTokenQrRow() {
            return h("div", { class: "ai-qr" }, [
                h("div", { class: "ai-qr-tip" }, "没有 key？微信扫码进小程序领取，把拿到的 key 填到上面「key」栏"),
                h("img", { class: "ai-qr-img", src: WX_QR, draggable: false, alt: "扫码获取 key" }),
                // 教程图默认折叠：收起时不撑高设置页；点开才展开大图（设置页布局不乱）。
                // summary 做成醒目的蓝色提示条（原来是灰色小字，很多人没注意到），display:flex 顺带去掉默认三角。
                h("details", { class: "ai-guide", style: { marginTop: "6px" } }, [
                    h("summary", { style: { cursor: "pointer", listStyle: "none", display: "flex",
                        alignItems: "center", gap: "6px", fontSize: "13px", fontWeight: "600",
                        color: "var(--ac)", background: "rgba(37,99,235,.08)", border: "1px solid var(--ac)",
                        borderRadius: "var(--r2)", padding: "8px 10px" } },
                        "📖 第一次用？点这里看「怎么填 key」图解 ›"),
                    h("div", { style: { marginTop: "6px" } }, guideImg("把小程序领取的 key 填进面板的 key 栏"))
                ])
            ]);
        }

        // ── 设置页 ──
        // 控件、初值、载荷全部从 PANEL_SETTINGS 生成。以前这三处各写一遍，
        // 加一个设置要改五个地方，漏一个就是"填了不起作用"。
        //
        // 改一栏存一栏（参考实现的做法），保存/取消两个按钮没了：父页面那个 save_setting
        // 处理器本来就是逐键的（`if (event.data[s.key] === undefined) return;`），
        // 单键载荷它已经能正确处理，所以这一改父页面零改动，而"填了忘点保存"这个坑没了。
        const inputs = {}, cfgRows = {};
        const elSetBox = h("div", { class: "scroll" });
        pages.set.appendChild(h("div", { class: "phead" },
            [h("b", null, profile.name + "设置"), h("span", { class: "secondary" }, "改一栏存一栏，即时生效")]));
        pages.set.appendChild(elSetBox);
        buildSettings();

        function buildSettings() {
            // 一屏 460px 装不下 30 栏（平铺量出来 1304px，找一项要滚三屏），所以每组包一个
            // 原生 <details>，默认全收起。收起来的标题得说清里面有什么，不然折叠等于藏 ——
            // 所以标题上带一句"几项"。
            // ponytail: 不记住上次展开的是哪一组，每次进设置页都从全收起开始（切走再回来要
            // 再点一下）。升级路是 details 的 ontoggle 里把组名 GM_setValue 存一下，建的时候读回来。
            const counts = {};
            let g = null;
            settings.forEach(s => {
                if (s.kind === "hidden") return;
                if (s.group) g = s.group;
                counts[g] = (counts[g] || 0) + 1;
            });
            let table = null, grp = null;
            // 一栏画一个控件。首页那张「常用设置」卡和设置页共用这一个 —— 抄一份的话，
            // 「改一栏存一栏」这套接线（初值 panelGet、改完存单键、show 联动）就有两份，
            // 其中一份迟早忘了跟着改，而症状还是那个老症状："填了不起作用"。
            const mk = (s, box) => {
                const cur = panelGet(s);
                let input, read;
                if (s.kind === "switch") {
                    // 状态就是那个 on class，不另存一个布尔：同一个 key 现在可能有两个开关
                    // （首页一个、设置页一个），各记一份迟早各说各话
                    input = h("button", { class: "sw" + (cur ? " on" : ""), type: "button" });
                    read = () => input.classList.contains("on");
                    input.onclick = () => {
                        const on = !read();
                        // 同一个 key 的每个控件一起翻，不只是被点的那个 —— 设置页正是拿来
                        // 核对的地方，它显示着旧值等于没得核对
                        inputs[s.key].set(on);
                        syncShow();
                        saveOne(s.key, on);
                    };
                } else if (s.kind === "select") {
                    input = h("select", { class: "in" }, s.options.map(o => h("option", { value: o[0] }, o[1])));
                    input.value = cur;
                    read = () => input.value;
                    input.onchange = () => {
                        inputs[s.key].set(input.value);
                        // 下拉也可能当别的一栏的 show 条件(如「正确率阈值」只在「提交方式 = 自动提交」时露),
                        // 所以改完要重算联动 —— 开关那支一直有,下拉这支原来漏了。
                        syncShow();
                        if (s.key === "ai_platform") applyPreset();
                        else saveOne(s.key, input.value);
                    };
                } else {
                    input = h("input", {
                        class: "in",
                        type: s.kind === "password" ? "password" : s.kind === "number" ? "number" : "text",
                        min: s.kind === "number" ? s.min : null,
                        max: s.kind === "number" ? s.max : null,
                        step: s.kind === "number" ? (s.step || 1) : null
                    });
                    input.value = cur;
                    read = () => input.value;
                    input.onchange = () => {
                        if (s.kind === "number") input.value = panelNorm(s, input.value);
                        inputs[s.key].set(input.value);
                        saveOne(s.key, input.value);
                    };
                }
                const set = v => {
                    if (s.kind === "switch") input.classList.toggle("on", !!v);
                    else input.value = v;
                };
                // read 读哪个控件都一样（值同源，set 保证两边一致），留第一个登记的
                const reg = inputs[s.key] || (inputs[s.key] = { el: input, read: read, sets: [] });
                reg.sets.push(set);
                reg.set = v => reg.sets.forEach(f => f(v));
                const row = h("div", { class: "cfgrow", tip: s.tip || null }, [
                    h("label", { class: "cfglb" }, s.label),
                    h("div", { class: "cfgin" }, [input, s.unit ? h("span", { class: "un" }, s.unit) : null])
                ]);
                row.dataset.setting = s.key;
                (cfgRows[s.key] || (cfgRows[s.key] = [])).push(row);
                box.appendChild(row);
            };
            settings.forEach(s => {
                if (s.kind === "hidden") return;
                if (s.group) {
                    grp = h("details", { class: "grp", name: "cfg" },
                        h("summary", { class: "sep" },
                            [s.group, h("span", { class: "cnt" }, counts[s.group] + " 项")]));
                    elSetBox.appendChild(grp);
                    if ((GROUP_NOTES[s.group] || []).length) grp.appendChild(
                        h("div", { class: "notes" }, h("ul", null,
                            GROUP_NOTES[s.group].map(t => h("li", null, safeHtml(t))))));
                    table = null;
                }
                // 每组自己一张 table：display:table 只在同一张表里对齐 label，
                // 分组各自对齐才不会被最长的那一组拖着全体缩进
                if (!table) { table = h("div", { class: "cfg" }); grp.appendChild(table); }
                mk(s, table);
                // 「模型」是 AI 配置组最后一栏，紧跟着在这组末尾（表格外）摆「测试连接」+「扫码领 token」——
                // 就在这三栏底下，填完当场能验，不用切页面。放表格外是为了结果长了能整行换行
                if (s.key === "ai_model") { grp.appendChild(aiTestRow()); grp.appendChild(aiTokenQrRow()); }
            });
            // 首页那张卡：同一张表、同一个 mk，只挑标了 home 的几栏（2 = 折进「更多开关」）
            settings.forEach(s => {
                if (s.home) mk(s, s.home === 2 ? elHomeMoreCfg : elHomeCfg);
            });
            syncShow();
        }
        // hidden 的那几栏不用带：父页面跳过 undefined，存档里的值不动
        function save(obj) {
            post(Object.assign({ type: "save_setting" }, obj));
        }
        function saveOne(key, val) {
            const one = {};
            one[key] = val;
            save(one);
        }
        // show 联动是活的：开关一按就重算，不是打开面板时算一次（参考实现的 showIf）
        function syncShow() {
            settings.forEach(s => {
                if (!s.show || !cfgRows[s.key]) return;
                // show 指向的可以是开关(真值即显示),也可以是 [键, 值](那个下拉等于该值才显示,如
                // 「正确率阈值」只在「提交方式 = 自动提交」时露出)。原来只认前者,把后者当开关读
                // 会把 "off"/"save" 也当成真值 —— 那一行就一直露着。
                const src = Array.isArray(s.show) ? s.show[0] : s.show;
                const on = inputs[src] ? inputs[src].read() : panelGet(
                    settings.find(x => x.key === src) || { key: src });
                const vis = Array.isArray(s.show) ? String(on) === String(s.show[1]) : !!on;
                cfgRows[s.key].forEach(r => r.classList.toggle("hide", !vis));
            });
        }
        // 换平台时把接口地址和模型名一起换掉。没有这一步，选了 DeepSeek
        // 却还带着百度的 URL，报错信息还长得像 key 不对
        const PRESET = {
            // 默认档：地址预置好，用户只填 token；模型预填 DeepSeek-V4-Flash[free]，可随便改。
            // 这条要和 ai_api_url / ai_model 的 def 一致（新装即用），守卫钉死这条一致性。
            "default":     ["https://ai.64696225.xyz/v1/chat/completions", "DeepSeek-V4-Flash[free]"],
            "deepseek":    ["https://api.deepseek.com/v1/chat/completions", "deepseek-chat"],
            "aliyun":      ["https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions", "qwen-plus"],
            "baidu":       ["https://qianfan.baidubce.com/v2/chat/completions", "ernie-3.5-8k"],
            // 原生接口：父页面认 aip.baidubce.com 这个域名走 ?access_token= 而不是 Bearer，
            // 返回的也是 { result: "..." }
            "baidu-native":["https://aip.baidubce.com/rpc/2.0/ai_custom/v1/wenxinworkshop/chat/completions", ""],
            "volcengine":  ["https://ark.cn-beijing.volces.com/api/v3/chat/completions", ""],
            "moonshot":    ["https://api.moonshot.cn/v1/chat/completions", "moonshot-v1-8k"],
            "zhipu":       ["https://open.bigmodel.cn/api/paas/v4/chat/completions", "glm-4"],
            "custom":      ["", ""]
        };
        function applyPreset() {
            if (!inputs.ai_platform) return;
            const which = inputs.ai_platform.read();
            const p = PRESET[which];
            if (!p) return;
            inputs.ai_api_url.set(p[0]);
            inputs.ai_model.set(p[1]);
            // 三栏一条载荷发出去：分三条发就是三次存档、三条"已保存"提示
            save({ ai_platform: which, ai_api_url: p[0], ai_model: p[1] });
            // 火山引擎的模型名是每个人自己的 Endpoint ID，猜不出来，只能提醒
            if (which === "volcengine") toast("火山引擎请把 Endpoint ID 填进模型", "info");
        }

        // ── 关于：第 85 轮从一个整标签页改成顶栏 ⓘ 点开的弹窗 ──
        // 原来关于页里那张赞赏大图和 QQ 群，跟底部常驻作者条重复；作者条点一下也能放大赞赏码。
        // 所以这里不再重复大图，只留作者简介 + 检查更新 + 使用说明（TIPS 也只在这一处，不再占顶栏）。
        function openAbout() {
            dialog({
                title: "关于 · 六边形战士", ok: "关了", cancel: null,
                content: h("div", { class: "about" }, [
                    h("div", { style: { marginBottom: "5px" } },
                        [h("b", null, "😊 Smiley face"), h("span", { class: "secondary" }, "　开发者")]),
                    h("p", null, "本人大四学生，看网课觉得浪费时间，当时脚本作者不更新，索性自己改改用。"
                        + "后来想干脆发布出去，没想到现在还有人用。"),
                    h("p", null, "放赞赏码纯属侥幸，感谢哥哥姐姐们的零碎小费～（赞赏码在面板底部，点一下放大）"),
                    h("div", { class: "quote" }, "✨ 过程很长，但我更加明白了『走捷径就是绕远路』"),
                    h("div", { style: { fontSize: "12px", marginBottom: "10px" } },
                        ["QQ群 ", h("span", { class: "qq" }, "1030887796")]),
                    h("button", { class: "btn main", type: "button",
                        onclick: () => { toast("正在检查更新…", "info"); checkVersion(); } }, "检查更新"),
                    h("div", { class: "notes", style: { margin: "12px 0 0" } }, h("ul", null, [
                        h("li", null, "首次使用需等待 15 秒"),
                        h("li", null, "暂停 / 继续：面板上那个按钮，或键盘 S / D")
                    ].concat(TIPS.map(t => h("li", null, t)))))
                ])
            });
        }

        // ── 消息入口。iframeMsg() 直接调这里，64 个调用点一个都没动 ──
        function recv(type, p) {
            p = p === undefined || p === null ? {} : p;
            if (type === "homework_scope") {
                st.aiReqId++; st.aiQuestion = ""; setAiLoading(false);
            } else if (type === "push") {
                addRow(p);
                // 题库没搜到精确答案就交给 AI 补。style==='warning-row' 表示只有相似答案
                if (p.requestAi !== true && !cxSet("auto_ai_search")) return;
                if (p.requestAi === false) return;
                const ans = p.answer || "";
                // 「暂无/未找到/无精确/无」这几个是搜题层"没搜到"的说辞，只在没填成时才当无效。
                // 若引擎已经 success-row 填对了、而答案内容本身恰好是"无"（填空/判断真会这样），
                // 再触发一次 AI 补就会把已经填对的覆盖掉。所以这些内容判据要挡在 !success-row 后面。
                // warning-row（只有相似答案）和空答案照旧算无效、照旧转 AI。
                const bad = p.style === "warning-row" || !ans
                    || (p.style !== "success-row" && (ans.indexOf("暂无") !== -1
                        || ans.indexOf("未找到") !== -1 || ans.indexOf("无精确") !== -1 || ans.trim() === "无"));
                if (!bad || !p.question) return;
                st.aiQuestion = p.question;
                sendAi(true, buildPrompt(p));
            } else if (type === "update_answer") {
                const index = p.rowKey ? st.rows.findIndex(r => r.rowKey === p.rowKey) : p.index;
                const row = st.rows[index];
                if (row) {
                    row.answer = p.answer;
                    row.style = p.style || "success-row";
                    row.aiError = p.aiError || "";
                    row.requestAi = false;
                    paintQnum(row, index);
                    if (st.cur === index) paintQuiz();
                    paintNow();
                }
            } else if (type === "clear") {
                st.rows = [];
                st.cur = -1;
                elQGrid.replaceChildren();
                bExport.disabled = true;
                paintQuiz();
            } else if (type === "progress") {
                setProgress(p.text || "", p.pct);
            } else if (type === "task") {
                upsertTask(p);
            } else if (type === "tip") {
                if (p.type === "jump") post({ type: "jump" });
                else if (p.type === "error") setNeedJump(true);
                else if (p.type === "hidden") setVisual("hidden");
                else if (p.type === "stop") setStop(true);
                // 全脚本 42 处 iframeMsg("tip") 都汇到这一句，而 tip 是直接覆盖 ——
                // 除了最后一条，其余的闪一下就没了。在这一个点上截一份进日志。
                // 级别：普通 tip 沿用 type（它同时也是副作用指令），
                // logOnly 的诊断走 level —— 那条路径不带 type，就不会触发上面几个副作用
                pushLog(p.tip, p.level || p.type, p.src, p.ctx);
                // logOnly：只进日志、不动头部状态行。诊断信息比状态多得多，
                // 也去刷 tip 的话状态行就成了一片看不清的流水
                if (!p.logOnly) setTip(p.tip);
            } else if (type === "stop") {
                setStop(p);
            } else if (type === "start_pay") {
                // 赞赏码那一路，面板这边不需要做什么：它一直在底部作者条上
            } else if (type === "update") {
                dialog({
                    title: "有新版本",
                    content: "检测到新版本 " + p.v2 + "（当前 " + p.v1 + "），去更新？",
                    ok: "去更新", cancel: "以后再说"
                }).then(yes => { if (yes) top.open(p.href); });
            } else if (type === "ai_fill_question") {
                st.aiQuestion = p.question;
                sendAi(true, p.prompt);
            } else if (type === "ai_response") {
                // 带 test 标记的是「测试连接」的回话，分流到测试处理器：不进聊天、不发 ai_fill
                if (p.test) recvAiTest(p); else recvAi(p);
            } else if (type === "retry_ai") {
                pushChat("system", "--- 重试请求 ---");
                st.aiQuestion = p.question;
                openTab("ai");
                sendAi(false, p.prompt);
            } else if (type === "settings_updated") {
                // 存回来的值可能被夹过/擦过（panelNorm），抄回控件 —— 不抄的话
                // "我填了 90 它却按 60 跑"这件事在面板上看不出来（参考实现的 sync）
                PANEL_SETTINGS.forEach(s => {
                    if (p[s.key] === undefined || !inputs[s.key]) return;
                    if (String(inputs[s.key].read()) !== String(p[s.key])) inputs[s.key].set(p[s.key]);
                });
                applyFont();
                syncShow();
                // 存过设置(多半连 token 一起改了)：撤掉"token 无效"标记，让 AI 重新试一次；
                // 要是新 token 还是坏的，下一题失败时会重新标上并再提示。
                st.aiKeyBad = false; st.aiKeyHelpShown = false;
                toast("已保存并生效");
            }
        }

        // 自动答题的提示词。题型决定回答格式 —— 不钉死格式的话 AI 会回一整段解析，
        // 填进选择题里就是一堆废话
        function buildPrompt(p) {
            return questionPrompt(p);
        }

        function applyFont() {
            // 字体大小设置删掉后固定 13px（.box 那句 var(--fs, 13px) 本来就兜着，这里显式再设一次，
            // 语义清楚，也省得哪天有人改 .box 忘了兜底）。--fs 能穿过 shadow 边界继承进去。
            host.style.setProperty("--fs", "13px");
        }

        // ── 开机 ──
        applyFont();
        fitHeight();
        paintStat();
        paintTasks();
        paintLogs();
        setStop(false);
        openTab("stat");
        setVisual(GM_getValue("hide") ? "hidden" : "normal");
        top.document.addEventListener("visibilitychange", maybeDailyKeyReminder);

        // ── 面板丢了怎么找回来（连点召回已删，剩 Ctrl+O 和方向键两条路）──
        // Ctrl+O 开关。capture 阶段拦，否则课程页面自己的快捷键会先吃掉
        top.addEventListener("keydown", e => {
            if (!e.ctrlKey || e.key !== "o") return;
            e.preventDefault();
            e.stopPropagation();
            setVisual(st.visual === "hidden" ? "normal" : "hidden");
        }, { capture: true });

        return {
            host: host, recv: recv, toast: toast, dialog: dialog, setVisual: setVisual, setYktCourses: setYktCourses,
            visual: () => st.visual,
            moveTo: (x, y) => {
                host.style.left = x + "px";
                host.style.top = y + "px";
                clampPos();
                savePos();
            }
        };
    }

    function showPanel(where) {
        if (yktHomeworkRelay("ready", {})) return;
        if (window.top !== window.self) { panelRelay("ensure", { where: where }); return; }
        if (PANEL) return;
        if (top.document.getElementById("panelNode")) return;
        PANEL = buildPanel(where);
        // 上一版这里是 addModal2()：建 #model-id > content-modal > [作者卡 + 面板] 三层容器，
        // 作者卡还兼任拖拽手柄。现在宿主自己就是那个 fixed 容器，一挂就完事。
        top.document.body.appendChild(PANEL.host);
        // 面板只在顶层创建；子帧的题目、进度和日志通过 panelRelay 汇入这一个实例。
        checkVersion();
        // 藏着开机的时候得有个页面级的提示，否则用户不知道脚本在跑（面板自己看不见）
        if (GM_getValue("hide")) vm.hideTip();
    }
    // 参考实现那份冗余词清单里有三条不是括号开头的：单选题(必考) / 多选题(必考) / 填空题(必考)。
    // 下面剥括号那条正则要求括号在最前面，题型两个字挡着它就什么都删不掉，这里补一条。
    // 但硬要求后面跟一组括号 —— 不加这个要求，「判断题的特点是什么」会被剥成「的特点是什么」，
    // 等于把搜不到的原因从"多了三个字"换成"少了三个字"，后者还更难查。
    const RE_TYPE_PREFIX = /^(单选题|多选题|判断题|填空题|简答题|單選题|多選题|判斷题)\s*[(（][^)）]{0,8}[)）]\s*/;
    const init$1 = async ($TiMu, select, wrap) => {
        let question = formatString(filterImg($TiMu.find(select.elements.question)));
        if (select.elements.type && select.elements.type.includes("input[name^=type]:eq")) {
            select.elements.type = "input[name^=type]:eq(" + GLOBAL.i + ")";
        }
        let data = {
            $item: $TiMu,
            question_text: $TiMu.find(select.elements.question).text(),
            question: question.length === 0 ? $TiMu.find(select.elements.question) : question.replace(/^\d+、/, "").replace(/[(（](\d+\s?(\.\d+)?分)[)）]$/, "").replace(/^((\d+.(\s+)?)?)[\[(（【](.*?)[】)）\]]/, "").replace(RE_TYPE_PREFIX, "").trim(),
            $options: select.elements.$options ? $TiMu.find(select.elements.$options) : undefined,
            options: select.elements.options ? jQuery.map($TiMu.find(select.elements.options), function(val) {
                return formatString(filterImg(val)).replace(/^[A-Ga-g][.、]/, "").trim();
            }) : undefined
        };
        if (select.elements.type) {
            data.typeLabel = $TiMu.find(select.elements.type).text();
            const getType = getQuestionType(data.typeLabel);
            const val = $TiMu.find(select.elements.type).val();
            data.type = isNaN(getType) ? isNaN(val) ? val : parseInt(val) : getType;
        } else {
            console.log("自动获取题目类型", defaultWorkTypeResolver(data.$options));
            data.type = defaultWorkTypeResolver(data.$options);
        }
        if (select.elements.answer) {
            data.answer = getAnswer(filterImg($TiMu.find(select.elements.answer)) || $TiMu.find(select.elements.answer).val(), data.options, data.type);
        }
        if (data && data.type === 3 && data.options.length === 0) {
            data.options = [ "正确", "错误" ];
        }
        const r = await wrap(data);
        if (typeof r === "boolean") return undefined;
        resolveQuestionType(data);
        return data;
    };
    async function WorkerJSPlus(options) {
        if (options.match === yktHomeworkPage) return yktHomeworkBoot(options);
        if (GLOBAL.isMatch) return;
        const match = options.match ? typeof options.match === "boolean" ? options.match : options.match() : false;
        if (!match) return;
        GLOBAL.isMatch = true;
        if (options.hook && typeof options.hook === "function") {
            if (options.hook()) return;
        }
        const defaultFunc = () => {};
        const main = () => {
            setTimeout(() => {
                showPanel(options.name);
                if (options.init && typeof options.init === "function") {
                    if (options.init()) return;
                }
                const select = {
                    root: options.root,
                    elements: options.elements,
                    ignore_click: options.ignore_click
                };
                // fill 不能兜底成空函数：全脚本有 4 处 `typeof fillHander === "function"` 靠它区分
                // 「平台有专用填充逻辑」和「走通用逻辑」。传 () => {} 会让这些分支全部命中空函数，
                // 表现就是「显示出答案但页面没填」。没配 fill 的平台必须传 undefined。
                new WorkerJS(select, options.wrap ? options.wrap : defaultFunc, options.fill, options.finished ? options.finished : defaultFunc, options.fillFinish ? options.fillFinish : defaultFunc).fillAnswer();
            }, GLOBAL.delay);
        };
        if (options.intv) {
            setIntervalFunc(options.intv, main);
        } else {
            main();
        }
    }
    var WorkerJS = function(select, searchHander, fillHander, onFinish = function(need_jump) {}, fillFinish = function() {}) {
        GLOBAL.index = 0;
        GLOBAL.successCount = 0;  // 重置成功计数
        GLOBAL.answeredTotal = 0; // 分母得跟它同生共死，否则跨页时数的不是同一批题
        // AI 瞎猜填进去的题数：AI 给的答案无从核对对错，不能当"答对"去推高正确率、触发自动交卷。
        // 自动交卷的达标判定只认"题库命中"(successCount - aiGuessCount)，AI 填的另算、不计入分子。
        GLOBAL.aiGuessCount = 0;
        this.init = init$1;
        this.fillAnswer = async () => {
            if (select.active && !select.active()) return;
            let arr = jQuery(select.root);
            
            // 在答题开始时锁定模式，避免中途切换导致问题
            const lockedAiFirstMode = GM_getValue("ai_first_mode");
            // 老版本存进去的 key 可能带空格，" " 是真值 —— 会以为配好了，
            // 然后带着个空的 Bearer 一道道题去请求。存的时候已经擦了，这里兜住旧存档。
            const lockedHasApiKey = String(GM_getValue("ai_api_key") || "").trim();
            console.log('★ 答题模式锁定:', lockedAiFirstMode ? 'AI优先模式' : '题库模式', 'API Key:', lockedHasApiKey ? '已配置' : '未配置');
            // 开局记一条：模式和 key 是"为什么 AI 没动"最常见的答案，
            // 而它们在答题开始时就锁定了，中途改设置也不生效（见上面几行）
            logMsg('开始答题：' + (lockedAiFirstMode ? 'AI优先模式' : '题库模式')
                + '，AI ' + (GM_getValue("auto_ai_search") ? '已启用' : '未启用')
                + '，API Key ' + (lockedHasApiKey ? '已配置' : '未配置')
                + '，共 ' + arr.length + ' 题',
                (lockedAiFirstMode && !lockedHasApiKey) ? 'error' : undefined);
            // 答题一开始就占住"有声"，别等用户最小化了才想起来 ——
            // 那时候计时器已经被节流，这句本身都不一定按时跑到
            keepTabAwake();
            // 定时停止在答题这一路也生效。答完一页跳下一页是真的页面重载，脚本整个重来，
            // 所以期限不能现算 —— cxArm 从 GM 里取这一趟的起点，跨页面接得上。
            const cxLimit = cxArm();
            if (cxLimit) logMsg("定时停止已开：" + new Date(cxStopAt).toLocaleTimeString() + " 自动暂停");

            // 同一道题连着失败几次就跳过它，见下面 catch 里的说明
            let lastFailIndex = -1, failCount = 0, lastEmptyIndex = -1, emptyCount = 0;

            while (true) {
                if (select.active && !select.active()) return;
                if (arr.length === 0) return;
                // isNaN 那半边判的是 parseInt 的结果，乘的却是原始值："3s" 会乘成 NaN、
                // sleep(NaN) 立刻返回，间隔设置直接失效（一秒能刷完一整页题）
                const delaySec = parseInt(GM_getValue("search_delay"));
                // 固定间隔每道题都一模一样，很好认。加一段 [0, delay_random) 的随机量，
                // 让节奏看起来不那么机械。设 0 就退回原来的固定间隔。
                const jitterSec = parseInt(GM_getValue("delay_random"));
                const jitter = isNaN(jitterSec) || jitterSec <= 0 ? 0 : Math.random() * jitterSec;
                await sleep(((isNaN(delaySec) ? 2 : delaySec) + jitter) * 1e3);
                if (select.active && !select.active()) return;
                // 到点了：扳的是 GLOBAL.stop 这道已有的闸，跟按 S / 点面板暂停完全同一条路。
                // 所以下面自动交卷、自动跳页那几处都会跟着停，不用各补一遍判断 ——
                // 另起一套停止标志的话，漏掉哪一处就是"说停了却自己把卷子交了"。
                // 判在 sleep 之后：这里正是两道题的交界，不会打断正在填的那一题。
                if (!GLOBAL.stop && cxTimeUp()) {
                    cxDisarm();
                    GLOBAL.stop = true;
                    iframeMsg("stop", GLOBAL.stop);
                    logMsg("到了设定的停止时间（" + cxLimit + " 分钟），答题已暂停，不会自动交卷。"
                        + "点面板上的「已暂停」可以继续，那会重新开始计时", "warn");
                }
                if (GLOBAL.stop) {
                    continue;
                }
                if (GLOBAL.index >= arr.length) {
                    GLOBAL.logCtx = "";   // 这一页做完了，清掉"第 N 题"定位标，别让后续日志挂着旧题号
                    // 这一趟做完的题数累进分母。successCount 是在 WorkerJS 构造时清零的，
                    // 一份多页的卷子里它跨页累加（下面 next 为真时 index 归零、再跑一趟 fillAnswer），
                    // 而 arr.length 只是当前这一页。分子分母数的不是同一批题：
                    // 一页一题的站点答完 20 题就是 20/1 = 2000%，被下面的 Math.min 夹成漂亮的 100%，
                    // 于是阈值形同虚设 —— 任何卷子都达标。分母得跟分子同一个生命周期。
                    GLOBAL.answeredTotal = (GLOBAL.answeredTotal || 0) + arr.length;
                    let auto_jump = GM_getValue("auto_jump") === undefined || GM_getValue("auto_jump");
                    const next = await onFinish(auto_jump);
                    if (select.active && !select.active()) return;
                    if (next) {
                        GLOBAL.index = 0;
                        if (select.active) { await sleep(300); return this.fillAnswer(); }
                        setTimeout(this.fillAnswer, 300);
                    }

                    // 雨课堂逐题提交并可能由网站自动翻题,由专属适配器确认结果。
                    // 不再落入通用交卷按钮搜索,避免重复提交或误点其它弹窗。
                    if (yktHomeworkPage()) return true;

                    // 检查是否需要自动提交
                    const submitMode = String(GM_getValue("submit_mode") || "off");
                    const autoSubmit = submitMode === "auto";
                    // 阈值 0 是合法设置（面板 :min="0"，意思是"不按正确率把关"），
                    // 但 `|| 80` 会把它悄悄换成 80。跟 search_delay 一样：判 parseInt 的结果。
                    const thresholdRaw = parseInt(GM_getValue("submit_threshold"));
                    const submitThreshold = isNaN(thresholdRaw) ? 80 : thresholdRaw;
                    console.log('自动提交检查: autoSubmit=', autoSubmit, 'next=', next);
                    if (autoSubmit && !next) {
                        // 计算正确率
                        const totalQuestions = GLOBAL.answeredTotal || arr.length;
                        // 夹一下上限：下面这个分支会去点"交卷"，点完没法撤。计数只要多加过一次
                        // （历史上就是 pendingAiFillQueue 攒死项导致的）正确率就能超过 100%，
                        // 那时任何阈值都拦不住，没做完的卷子照样交出去。
                        const filledCount = Math.min(GLOBAL.successCount || 0, totalQuestions);
                        // AI 填的题无从核对对错，不能当"答对"去凑达标 —— 否则 AI 瞎猜几个合法答案就把
                        // "正确率"顶过阈值，把错题自动交上去（唯一撤不回的动作）。达标判定只认"题库命中"
                        // 这些可核对的：verified = 填成功数 − AI 猜测数。AI 填的另算、只提示不计分子。
                        const aiGuessed = Math.min(GLOBAL.aiGuessCount || 0, filledCount);
                        const successCount = Math.max(0, filledCount - aiGuessed);
                        const accuracy = totalQuestions > 0 ? (successCount / totalQuestions * 100) : 0;
                        console.log('正确率检查:', successCount, '/', totalQuestions, '=', accuracy.toFixed(1) + '%', '阈值:', submitThreshold + '%', 'AI猜测', aiGuessed);
                        // 交卷决策是唯一撤不回来的动作，事后一定要能查到"当时是按什么数交的"。
                        // 原来这两行只在 console 里，关掉页面就没了。
                        logMsg('交卷判定：题库命中正确率 ' + accuracy.toFixed(1) + '%（' + successCount + '/' + totalQuestions
                            + '）' + (aiGuessed > 0 ? '，另有 ' + aiGuessed + ' 道 AI 推测题不计入（无法核对对错）' : '')
                            + '，阈值 ' + submitThreshold + '% → ' + (accuracy >= submitThreshold ? '达标，将自动提交' : '未达标，不提交'),
                            accuracy >= submitThreshold ? 'warn' : undefined);
                        console.log('比较结果:', accuracy, '>=', submitThreshold, '=', accuracy >= submitThreshold);

                        if (accuracy >= submitThreshold) {
                            iframeMsg("tip", {
                                tip: "题库命中正确率 " + accuracy.toFixed(1) + "% 达标"
                                    + (aiGuessed > 0 ? "（另 " + aiGuessed + " 道 AI 推测题不计入）" : "") + "，3秒后自动提交..."
                            });
                            setTimeout(() => {
                                // 全脚本唯一撤不回来的动作，也是唯一一处不看 GLOBAL.stop 的。
                                // 上面那句提示写着"3秒后自动提交"，用户按 S / 面板暂停 / 适配器判定
                                // 已交卷（6837、6914、6951、8448、9844 五处都会置 stop）都在这三秒里
                                // 拦不住它。刹车只有这一个，偏偏踩不到最该踩的地方。
                                if (GLOBAL.stop) {
                                    console.log('已暂停，取消自动提交');
                                    iframeMsg("tip", { tip: "已暂停，未自动提交" });
                                    return;
                                }
                                // 查找并点击提交按钮（扩展选择器）
                                const submitBtns = [
                                    $('a.btnSubmit'),
                                    $('a.workBtnIndex:contains("提交")'),
                                    $('a.jb_btn:contains("交卷")'),
                                    $('button:contains("交卷")'),
                                    $('button:contains("提交")'),
                                    $('input[value="提交"]'),
                                    $('a:contains("提交答卷")'),
                                    $('a:contains("交卷")'),
                                    $('.submitBtn'),
                                    $('[class*="submit"]').filter(':visible'),
                                    $('button.el-button--primary:contains("交卷")'),
                                    $('button.ant-btn-primary:contains("提交")'),
                                    $('button[type="submit"]'),
                                    $('input[type="submit"]'),
                                    // 学习通特定按钮
                                    $('a.submitBtn'),
                                    $('a.jb_btn'),
                                    $('button.jb_btn')
                                ];
                                let found = false;
                                for (const $btn of submitBtns) {
                                    // 原来是 $btn.is(':visible') 后取 $btn.eq(0)：is() 只要集合里有一个可见就为真，
                                    // eq(0) 拿的却是第一个 —— 可能正是那个隐藏的。先筛再取。
                                    const $vis = $btn.filter(':visible');
                                    if ($vis.length > 0) {
                                        console.log('找到提交按钮:', $vis.text() || $vis.val(), $vis.attr('class'));
                                        // 使用增强版点击
                                        safeClick($vis.eq(0).get(0), { clickInner: false });
                                        iframeMsg("tip", { tip: "点击提交，等待确认对话框..." });
                                        found = true;

                                        // 确认对话框可能来得慢，重试三次。每次都得重看 stop：
                                        // 卷子可能已经交了，但确认框还没点，这时停下来至少不会替用户按下确认。
                                        const delays = [1000, 1500, 2000];
                                        (function retryConfirm(i) {
                                            setTimeout(() => {
                                                if (GLOBAL.stop) {
                                                    iframeMsg("tip", { tip: "已暂停，未自动确认" });
                                                } else if (clickConfirmButton([document, top.document])) {
                                                    iframeMsg("tip", { tip: "已自动确认提交" });
                                                } else if (i + 1 < delays.length) {
                                                    console.log('第 ' + (i + 1) + ' 次未找到确认按钮，' + delays[i + 1] + 'ms 后重试...');
                                                    retryConfirm(i + 1);
                                                } else {
                                                    iframeMsg("tip", { tip: "未找到确认按钮，请手动确认" });
                                                }
                                            }, delays[i]);
                                        })(0);

                                        break;
                                    }
                                }
                                if (!found) {
                                    console.log('未找到提交按钮，请手动提交');
                                    iframeMsg("tip", { tip: "未找到提交按钮，请手动提交" });
                                }
                            }, 3000);
                        } else {
                            iframeMsg("tip", {
                                tip: "正确率 " + accuracy.toFixed(1) + "% 未达标（阈值" + submitThreshold + "%），请手动检查"
                            });
                        }
                        return true;
                    }

                    // 「仅保存答案不提交」:每题填完尽量点页面自己的「保存」把答案存成草稿(不点任何提交/交卷),
                    // 再照常翻下一题;翻到最后一题停住等用户手动交。找不到保存按钮就算了(答案已在页面上,
                    // 不强行造一个"保存",绝不误点提交)。off 模式连保存都不点(与旧「关闭」行为一致)。
                    if (submitMode === "save" && !next) {
                        const saveBtn = $('a.saveYl, a.jb_btn:contains("保存"), button:contains("保存"), input[value*="保存"]')
                            .filter(':visible').filter(function () { return !/提交|交卷/.test($(this).text() || $(this).val() || ""); });
                        if (saveBtn.length) {
                            safeClick(saveBtn.eq(0).get(0), { clickInner: false });
                            iframeMsg("tip", { tip: "已保存本题答案(未提交)" });
                        }
                        return true;
                    }

                    if (auto_jump) {
                        iframeMsg("tip", {
                            tip: "自动答题已完成,即将切换下一题"
                        });
                        next || setTimeout(() => {
                            iframeMsg("tip", {
                                type: "hidden",
                            tip: submitMode === "off" ? "答案已填好,未做任何提交,请自行检查提交" : submitMode === "save" ? "答案已保存为草稿,请自行检查并提交" : "自动答题已完成,请检查提交"
                            });
                        }, Math.max(GM_getValue("search_delay") || 2, 5) * 1e3);
                    } else {
                        iframeMsg("tip", {
                            tip: submitMode === "off" ? "答案已填好,未做任何提交" + (arr.length === 1 ? "" : ",请自行检查提交") : submitMode === "save" ? "答案已保存为草稿,请自行检查并提交" : "自动答题已完成" + (arr.length === 1 ? ",请手动切换" : "请检查提交")
                        });
                    }
                    return true;
                }
                try {
                    let data = await this.init(jQuery(arr[GLOBAL.index++]), select, searchHander);
                    if (select.active && !select.active()) return;
                    if (!data) {
                        if (GLOBAL.stop) return;
                        const emptyIndex = GLOBAL.index - 1;
                        if (emptyIndex === lastEmptyIndex) emptyCount++;
                        else { lastEmptyIndex = emptyIndex; emptyCount = 1; }
                        if (emptyCount <= 2) {
                            GLOBAL.index--;
                            iframeMsg("tip", { tip: "第" + (emptyIndex + 1) + "题内容尚未加载，重试 " + emptyCount + "/2" });
                            continue;
                        }
                        const message = "题目内容或题型连续未能识别，已跳过";
                        if (aiFailSkip()) {
                            logMsg('第' + GLOBAL.index + '题 ' + message, 'warn');
                            iframeMsg("push", { index: GLOBAL.index, question: "", answer: "", style: "warning-row",
                                searchError: message, requestAi: false });
                            if (GLOBAL.yktHomeworkRun) return await yktSkipOrPause(message);
                            continue;
                        }
                        GLOBAL.index--;
                        GLOBAL.stop = true;
                        iframeMsg("stop", true);
                        logMsg('第' + (GLOBAL.index + 1) + '题 ' + message + '，已暂停', 'warn');
                        continue;
                    }
                    if (data.yktSubmitted) { GLOBAL.answeredTotal--; continue; }
                    // 日志定位：标记"当前在做第几题"，这一轮里 logMsg 都会把它带进面板日志，
                    // "搜题失败""AI 超时跳过"这类才对得上是哪道题。退出答题循环时清掉（见 onFinish）。
                    GLOBAL.logCtx = "第 " + GLOBAL.index + " 题";
                    data.ignore_click = select.ignore_click;
                    if (![0, 1, 2, 3, 4, 5, 6, 7, 9, 10].includes(data.type) || data.typeConflict) {
                        const message = data.typeConflict || "未支持的题型（" + (data.typeLabel || data.type || "未知") + "），请手动作答";
                        answerFillFailure(data, message);
                        if (aiFailSkip()) {
                            // 不支持的题型也当"答不出"：记一行待答、跳过继续，别为一道题停住整份卷子。
                            logMsg('第' + GLOBAL.index + '题 ' + message + '，已跳过', 'warn');
                            iframeMsg("push", { index: GLOBAL.index, question: data.question, answer: "", style: "warning-row",
                                searchError: message, requestAi: false, options: data.options, type: data.type,
                                typeLabel: data.typeLabel, choiceMin: data.choiceMin, blankCount: data.$options ? data.$options.length : 0 });
                            if (GLOBAL.yktHomeworkRun) return await yktHomeworkNext(true, true);
                            continue;
                        }
                        GLOBAL.stop = true;
                        GLOBAL.index--;
                        iframeMsg("stop", true);
                        if (GLOBAL.yktHomeworkRun) return yktHomeworkPause(message);
                        continue;
                    }
                    // 使用优化的进度提示
                    updateProgress(GLOBAL.index, arr.length, '正在处理...');

                    // AI 优先模式：用 AI 替代题库搜索，但复用现有填充流程
                    // 使用锁定的模式变量，避免中途切换
                    let formatResult;
                    
                    if (lockedAiFirstMode && lockedHasApiKey) {
                        // AI 优先模式：直接用 AI 获取答案，跳过题库
                        console.log('★★★ AI优先模式 第' + GLOBAL.index + '题 ★★★');
                        iframeMsg("tip", { tip: "AI优先：第" + GLOBAL.index + "题，请求AI中..." });
                        
                        // 构建 AI prompt
                        const aiPrompt = buildAiPrompt(data, GLOBAL.index);
                        clearAiAnswerState();
                        
                        // 发送 AI 请求
                        iframeMsg("ai_fill_question", {
                            prompt: aiPrompt,
                            question: data.question,
                            questionIndex: GLOBAL.index,
                            style: 'warning-row'
                        });
                        
                        // 等待 AI 返回
                        const waitStart = Date.now();
                        let aiAnswer = await waitForAiAnswer(aiWaitMs(5), waitStart, data.question);
                        if (data.active && !data.active()) return;
                        
                        if (aiAnswer && aiAnswer !== 'AI_FILLED' && aiAnswer.trim()) {
                            console.log('★ AI优先模式：收到AI答案:', aiAnswer.substring(0, 50));
                            
                            const filled = await fillWithAiAnswer(aiAnswer, data, fillHander);
                            if (data.active && !data.active()) return;
                            iframeMsg("push", { index: GLOBAL.index, question: data.question,
                                answer: data.aiParsedAnswer || "", style: filled ? "success-row" : "warning-row",
                                aiError: data.answerError, requestAi: false, options: data.options, type: data.type,
                                typeLabel: data.typeLabel, choiceMin: data.choiceMin, blankCount: data.$options.length });
                            if (!filled) {
                                uploadQuestionBankCandidate(data, data.aiParsedAnswer || aiAnswer, "AI unresolved candidate");
                                const message = data.answerError || "AI 答案未能填入当前题，请检查后继续重试";
                                if (GLOBAL.yktHomeworkRun) return await yktSkipOrPause(message);
                                if (aiFailSkip()) { logMsg('第' + GLOBAL.index + '题 AI 没给出能填入的答案，已跳过（' + message + '）', 'warn'); continue; }
                                GLOBAL.index--; GLOBAL.stop = true; iframeMsg("stop", true);
                                continue;
                            }
                            clearAiAnswerState();
                            GLOBAL.successCount++;
                            GLOBAL.aiGuessCount++;   // AI 优先模式：这题是 AI 填的，不计入自动交卷的正确率
                            uploadQuestionBankCandidate(data, data.aiParsedAnswer, "AI candidate");
                            await fillFinish({ type: data.type, question: data.question, ans: data.aiParsedAnswer, style: "success-row" });
                            continue;
                        } else {
                            console.log('★ AI优先模式：AI无响应，使用空结果');
                            uploadQuestionBankCandidate(data, null, "AI unanswered candidate");
                            formatResult = {
                                success: false,
                                msg: 'AI无响应'
                            };
                        }
                    } else {
                        // 正常模式：搜索题库
                        formatResult = await formatSearchAnswer(data);
                    }
                    if (data.active && !data.active()) return;
                    const hookAnswer = data.answer && data.answer.length > 0 && GM_getValue("start_pay");
                    const formatAns = hookAnswer ? {
                        success: true,
                        num: formatResult.num,
                        list: [ data.answer ]
                    } : formatResult;

                    console.log('★ 搜题结果判断:', 'formatResult.answers:', !!formatResult.answers, 'formatAns.success:', formatAns.success, 'hookAnswer:', hookAnswer);

                    if (formatResult.answers || formatAns.success) {
                        iframeMsg("tip", {
                            tip: "准备填充答案," + (formatAns.num === -1 ? "扫码可以请我喝杯茶哦" : "扫码可以请我喝杯茶哦:" + formatAns.num)
                        });
                        const func = !hookAnswer && formatResult.answers ? defaultFillAnswer : defaultQuestionResolve;
                        let r = await func(hookAnswer ? formatAns.list : formatAns.answers ? formatResult.answers : formatAns.list, data, fillHander, select.ignore_click ? select.ignore_click : () => {
                            return false;
                        });
                        if (data.active && !data.active()) return;

                        console.log('搜题结果:', r.style, r.ans ? r.ans.substring(0, 20) : 'no ans');

                        // 判断答案是否无效（与 Vue 端保持一致）
                        const ansText = r.ans || '';
                        // 「无精确/暂无/未找到/无」是搜题层"没搜到"的说辞，只在没填成时才当无效。
                        // 引擎已 success-row 填对、而答案内容恰好是"无"（填空/判断真会这样）时，别再判无效去转 AI——
                        // 那会白等一轮、还可能被 AI 覆盖。跟面板 recv("push") 的 bad 判据同一套口径。
                        const isInvalidAnswer = r.style === 'warning-row' ||
                            !r.ans ||
                            (r.style !== 'success-row' && (
                                ansText.indexOf('无精确') !== -1 ||
                                ansText.indexOf('暂无') !== -1 ||
                                ansText.indexOf('未找到') !== -1 ||
                                ansText.trim() === '无'));
                        console.log('★ 答案有效性判断: isInvalidAnswer=', isInvalidAnswer, 'style=', r.style, 'ans=', ansText.substring(0, 20));
                        // 每题的去向：题库命中了、还是要转 AI。整份卷子答完之后，
                        // 这一条能回答"哪几题是题库给的、哪几题靠 AI"——原来只在 console 里。
                        logMsg('第' + GLOBAL.index + '题：' + (isInvalidAnswer
                            ? '题库无精确答案' + (GM_getValue("auto_ai_search") ? '，转 AI' : '（未开 AI）')
                            : '题库命中 ' + ansText.substring(0, 30)),
                            isInvalidAnswer ? 'warn' : undefined);

                        // 搜题优先，只有搜题失败时才使用 AI 答案作为兜底
                        if (GLOBAL.lastAiAnswer) {
                            // 这份存着的答案很可能是上一题超时之后才回来的。原来这里不看题干就拿来
                            // 填当前题，填错了还记成 success-row 把正确率抬上去，然后触发自动交卷。
                            const mine = isAnswerForQuestion(GLOBAL.lastAiQuestion || '', data.question);
                            if (isInvalidAnswer && mine) {
                                console.log('★★ 搜题无效，使用已保存的 AI 答案填充:', GLOBAL.lastAiAnswer.substring(0, 30));
                                const aiAnswer = GLOBAL.lastAiAnswer;
                                GLOBAL.lastAiAnswer = null;

                                // 使用 AI 答案填充
                                const filled = await fillWithAiAnswer(aiAnswer, data, fillHander);

                                if (filled) {
                                    iframeMsg("push", {
                                        index: GLOBAL.index,
                                        question: r.question,
                                        answer: 'AI: ' + aiAnswer.substring(0, 50),
                                        style: 'success-row',
                                        options: data.options,
                                        type: data.type, typeLabel: data.typeLabel, choiceMin: data.choiceMin, blankCount: data.$options.length
                                    });

                                    // 增加成功计数（AI 填充成功）
                                    GLOBAL.successCount++;
                                    GLOBAL.aiGuessCount++;   // AI 填的，不计入自动交卷的正确率
                                    uploadQuestionBankCandidate(data, data.aiParsedAnswer, "AI candidate");
                                    await fillFinish(Object.assign({}, r, { ans: data.aiParsedAnswer, style: 'success-row' }));
                                    continue;  // 继续下一题
                                } else uploadQuestionBankCandidate(data, data.aiParsedAnswer || aiAnswer, "AI unresolved candidate");
                            } else {
                                // 搜题成功、或这答案压根不是这道题的，两种都不再需要它
                                console.log(mine ? '搜题成功，清空不再需要的 AI 答案' : '存着的 AI 答案不是当前题的，丢弃');
                                GLOBAL.lastAiAnswer = null;
                            }
                        }

                        // 如果是无精确答案且开启了 AI 搜题，等待 AI 返回
                        const autoAiEnabled = GM_getValue("auto_ai_search");
                        const waitingForAi = isInvalidAnswer && autoAiEnabled;
                        console.log('等待条件检查: isInvalidAnswer=', isInvalidAnswer, 'autoAiEnabled=', autoAiEnabled);

                        // 只有真要等 AI 的题才入队。原来这里是无条件 push：搜到答案、
                        // 压根没走 AI 的题也往队列里塞一个，而队列只在 handleAiFill 匹配成功时
                        // 才出队 —— 于是每答一题就多攒一个死项。下一道题的 AI 答案回来时，
                        // handleAiFill 是按"题干前 15 字双向包含"找人的，同一份卷子里题干开头
                        // 撞车太常见了，它会命中那些早就答完的旧题：AI 答案覆盖掉已经答对的题，
                        // successCount 再多加一次（旧题在 3958 那行已经加过），
                        // 而当前这道题被 aiAnswerFilled 判成"已填充"直接跳过、实际是空的。
                        // 正确率于是虚高、甚至能超过 100%，然后把没做完的卷子自动交上去。
                        // 顺带：出队只有 dequeueAiFill 一处了。原来还有个 resolveFirstInQueue
                        // 在 AI 出错时 shift() 摘队头，摘的可能是下一题的项，已删。
                        let queueItem = null;
                        if (waitingForAi) {
                            if (!GLOBAL.pendingAiFillQueue) GLOBAL.pendingAiFillQueue = [];
                            // 先入队、再发 push 消息（顺序很重要：push 会触发 AI 请求，
                            // 答案可能比入队先回来）
                            queueItem = {
                                data: data,
                                fillHander: fillHander,
                                questionIndex: GLOBAL.index,
                                rowKey: rowKeyFor(GLOBAL.index),
                                questionText: data.question
                            };
                            GLOBAL.pendingAiFillQueue.push(queueItem);
                            GLOBAL.currentPendingItem = queueItem;
                            console.log('★★★ 添加到队列成功，当前长度:', GLOBAL.pendingAiFillQueue.length, '题目:', data.question ? data.question.substring(0, 20) : 'no question');
                        }

                        // 【重要】在发送 push 之前设置时间戳和清除状态
                        const waitStartTime = Date.now();
                        if (waitingForAi) {
                            clearAiAnswerState();
                        }

                        // 发送 push 消息更新表格（同时会触发 AI 请求）
                        iframeMsg("push", {
                            index: GLOBAL.index,
                            question: r.question,
                            answer: r.ans,
                            style: r.style,
                            requestAi: !!waitingForAi,
                            options: data.options,
                            type: data.type, typeLabel: data.typeLabel, choiceMin: data.choiceMin, blankCount: data.$options.length
                        });

                        let aiFilledInQueue = false;
                        if (waitingForAi) {
                            console.log('★★★ 开始等待 AI 返回答案...');
                            iframeMsg("tip", { tip: "正在使用 AI 搜题，请稍候..." });

                            const originalQuestionIndex = GLOBAL.index;

                            // 等待 AI 请求发送后再开始轮询
                            await new Promise(r => setTimeout(r, 300));
                            console.log('调用 waitForAiAnswer 等待...');
                            // 第三个参数是题干：不传的话 waitForAiAnswer 里的题目验证整段都不执行，
                            // 上一题超时后才回来的 AI 答案会被当成这一题的答案填进去。
                            // 传 data.question 是因为 push 消息带出去的 r.question 就是它（见各 return），
                            // 面板原样回传，所以两边比的是同一个字符串。
                            let aiAnswer = await waitForAiAnswer(aiWaitMs(), waitStartTime, data.question);
                            if (data.active && !data.active()) return;

                            console.log('★★★ AI 等待结束，aiAnswer:', aiAnswer ? (aiAnswer === 'AI_FILLED' ? 'AI_FILLED' : aiAnswer.substring(0, 30)) : 'null', 'aiAnswerFilled:', GLOBAL.aiAnswerFilled);

                            // 如果已经被 handleAiFill 填充过了，直接跳过
                            if (aiAnswer === 'AI_FILLED' || GLOBAL.aiAnswerFilled) {
                                console.log('AI 已通过队列成功填充，跳过后续处理');
                                aiFilledInQueue = GLOBAL.aiAnswerFilled === 'ok';
                                if (aiFilledInQueue) { r.style = 'success-row'; r.ans = data.aiParsedAnswer || r.ans; }
                                // 重置标志
                                GLOBAL.aiAnswerFilled = false;
                            }
                            // 等待结束后检查是否有 AI 答案
                            else if (aiAnswer) {
                                console.log('★★ 发现 AI 答案，立即填充，原始题号:', originalQuestionIndex);
                                clearAiAnswerState();

                                // 智能提取选项字母（支持多种 AI 响应格式）
                                let processedAnswer = extractAnswerLetter(aiAnswer, data.type, data);
                                console.log('★★ 提取的答案:', processedAnswer);
                                
                                const filled = await fillWithAiAnswer(aiAnswer, data, fillHander);
                                if (filled) {
                                    const shortAnswer = updateAnswerDisplay(processedAnswer, 'success-row', originalQuestionIndex);
                                    r.ans = shortAnswer;
                                    r.style = 'success-row';
                                    GLOBAL.aiGuessCount++;   // 这题 r.style 置 success 后由下方 5047 计 successCount；AI 填的，另记一笔不计入正确率
                                    console.log('★★ AI 答案填充成功:', shortAnswer, '题号:', originalQuestionIndex);
                                } else uploadQuestionBankCandidate(data, data.aiParsedAnswer || aiAnswer, "AI unresolved candidate");
                            } else {
                                console.log('等待超时，没有收到 AI 答案，跳过此题');
                                uploadQuestionBankCandidate(data, null, "AI unanswered candidate");
                                iframeMsg("tip", { tip: "AI 请求超时，跳过继续下一题" });
                                // 不再重试，直接跳过，避免等待时间过长
                            }
                        }
                        // 等 AI 这件事到这儿就结束了：填成、超时、没匹配上都一样要摘掉自己，
                        // 留在队列里就会被下一题的模糊匹配捞出来重填一遍
                        dequeueAiFill(queueItem);

                        if (waitingForAi && !aiFilledInQueue && r.style !== "success-row" && GLOBAL.yktHomeworkRun) {
                            iframeMsg("update_answer", { index: GLOBAL.index - 1, answer: r.ans, style: "warning-row",
                                aiError: "AI 答案未能填入当前题,请查看具体错误后继续重试" });
                            return await yktSkipOrPause(data.answerError || "AI 答案未能填入当前题,请查看具体错误后继续重试");
                        }

                        if (waitingForAi && !aiFilledInQueue && r.style !== "success-row" && data.answerError) {
                            if (aiFailSkip()) { logMsg('第' + GLOBAL.index + '题 AI 没给出能填入的答案，已跳过（' + data.answerError + '）', 'warn'); }
                            else { GLOBAL.index--; GLOBAL.stop = true; iframeMsg("stop", true); continue; }
                        }
                        // 增加成功计数（搜题成功或 AI 填充成功）
                        if (r.style === "success-row") {
                            uploadQuestionBankCandidate(data, r.ans, aiFilledInQueue || waitingForAi ? "AI candidate" : "answer-source candidate");
                        }
                        if (r.style === 'success-row' && !aiFilledInQueue) GLOBAL.successCount++;
                        await fillFinish(r);
                    } else {
                        console.log('★ 搜题失败，进入 else 分支');
                        const searchError = formatAns.error || formatAns.msg || "题库未返回答案";
                        logMsg(searchError, "warn");

                        // 等待 AI 返回（使用 GM_getValue 轮询）
                        const autoAiEnabled = GM_getValue("auto_ai_search");
                        if (autoAiEnabled) {
                            console.log('★★★ else分支：开始等待 AI 返回答案...');
                            iframeMsg("tip", { tip: "正在使用 AI 搜题，请稍候..." });

                            const originalQuestionIndex = GLOBAL.index;
                            
                            // 【关键】添加到队列，以便 handleAiFill 能匹配到
                            if (!GLOBAL.pendingAiFillQueue) GLOBAL.pendingAiFillQueue = [];
                            const queueItem = {
                                data: data,
                                fillHander: fillHander,
                                questionIndex: GLOBAL.index,
                                rowKey: rowKeyFor(GLOBAL.index),
                                questionText: data.question
                            };
                            GLOBAL.pendingAiFillQueue.push(queueItem);
                            GLOBAL.currentPendingItem = queueItem;
                            console.log('★ else分支：添加到队列，长度:', GLOBAL.pendingAiFillQueue.length);
                            
                            // 【重要】先设置时间戳和清除状态，再触发 AI 请求
                            const waitStartTime = Date.now();
                            clearAiAnswerState();
                            
                            // 发送 push 消息（触发 AI 请求）
                            iframeMsg("push", {
                                index: GLOBAL.index,
                                question: data.question,
                                answer: "",
                                searchError: searchError,
                                requestAi: true,
                                style: 'warning-row',
                                options: data.options,
                                type: data.type, typeLabel: data.typeLabel, choiceMin: data.choiceMin, blankCount: data.$options.length
                            });

                            // 等待 AI 请求发送
                            await new Promise(r => setTimeout(r, 200));
                            console.log('else分支：调用 waitForAiAnswer 等待...');
                            // 同上：题干必须传，否则题目验证不生效，会捡到别的题的答案
                            let aiAnswer = await waitForAiAnswer(aiWaitMs(), waitStartTime, data.question);
                            if (data.active && !data.active()) return;

                            console.log('★★★ else分支：AI 等待结束，aiAnswer:', aiAnswer ? (aiAnswer === 'AI_FILLED' ? 'AI_FILLED' : aiAnswer.substring(0, 30)) : 'null');

                            // 标记 AI 是否成功填充
                            let aiSuccess = false;
                            let aiSuccessAnswer = '';

                            // 如果已经被 handleAiFill 处理过了，直接跳过
                            if (aiAnswer === 'AI_FILLED' || GLOBAL.aiAnswerFilled) {
                                // 处理过 ≠ 填成了。原来无脑 aiSuccess = true，于是"AI答案无法匹配选项"
                                // 那种空题也不标 warning-row，正确率照记 —— 然后自动交卷。
                                aiSuccess = GLOBAL.aiAnswerFilled === 'ok';
                                console.log('else分支：AI 已处理，跳过后续处理，成功:', aiSuccess);
                                GLOBAL.aiAnswerFilled = false;
                            }
                            else if (aiAnswer) {
                                console.log('★★ else分支：发现 AI 答案，填充，原始题号:', originalQuestionIndex);
                                clearAiAnswerState();

                                // 智能提取答案
                                let processedAnswer = extractAnswerLetter(aiAnswer, data.type, data);
                                console.log('★★ else分支：提取的答案:', processedAnswer);
                                
                                const filled = await fillWithAiAnswer(aiAnswer, data, fillHander);
                                if (filled) {
                                    const shortAnswer = updateAnswerDisplay(processedAnswer, 'success-row', originalQuestionIndex);
                                    GLOBAL.successCount++;
                                    GLOBAL.aiGuessCount++;   // else 分支：搜题彻底失败后 AI 兜底填的，不计入自动交卷的正确率
                                    console.log('★★ else分支：AI 答案填充成功:', shortAnswer, '题号:', originalQuestionIndex);
                                    aiSuccess = true;
                                    aiSuccessAnswer = shortAnswer;
                                } else {
                                    console.log('★★ else分支：AI 答案填充失败');
                                    uploadQuestionBankCandidate(data, data.aiParsedAnswer || aiAnswer, "AI unresolved candidate");
                                }
                            } else {
                                console.log('else分支：等待超时，跳过此题');
                                uploadQuestionBankCandidate(data, null, "AI unanswered candidate");
                                iframeMsg("tip", { tip: "AI 请求超时，跳过继续下一题" });
                            }

                            // 同上：等待结束就摘掉自己，别留给下一题的模糊匹配
                            dequeueAiFill(queueItem);

                            if (!aiSuccess) {
                                iframeMsg("update_answer", { index: GLOBAL.index - 1, rowKey: rowKeyFor(GLOBAL.index), answer: "", style: "warning-row",
                                    aiError: "AI 答案未能填入当前题,请查看 AI 页后继续重试" });
                                if (GLOBAL.yktHomeworkRun) return await yktSkipOrPause(data.answerError || "AI 答案未能填入当前题,请查看具体错误后继续重试");
                                if (data.answerError) {
                                    if (aiFailSkip()) { logMsg('第' + GLOBAL.index + '题 AI 没给出能填入的答案，已跳过（' + data.answerError + '）', 'warn'); }
                                    else { GLOBAL.index--; GLOBAL.stop = true; iframeMsg("stop", true); continue; }
                                }
                            }

                            // 只有在 AI 未成功填充时，才标记为 warning-row
                            if (!aiSuccess) {
                                await fillFinish({ans: '', question: data.question, style: 'warning-row'});
                            } else {
                                // 如果 AI 成功了，也调用 fillFinish 以便触发后续流程（如自动跳转），但传入正确状态
                                // 注意：fillFinish 内部可能会再次更新表格，所以要传入正确参数
                                uploadQuestionBankCandidate(data, aiSuccessAnswer, "AI candidate");
                                await fillFinish({ans: aiSuccessAnswer || 'AI已填充', question: data.question, style: 'success-row'});
                            }
                        } else {
                             // 未开启 AI 搜题，直接结束
                             iframeMsg("push", { index: GLOBAL.index, question: data.question, answer: "",
                                 style: "warning-row", searchError: searchError, requestAi: false, options: data.options, type: data.type, typeLabel: data.typeLabel, choiceMin: data.choiceMin, blankCount: data.$options.length });
                             await fillFinish({ans: '', question: data.question, style: 'warning-row'});
                        }
                    }
                } catch (e) {
                    // 出错的是 GLOBAL.index - 1 那道题（上面 arr[GLOBAL.index++] 已经加过了）。
                    if (select.active && !select.active()) return;
                    // 原来这里无条件 GLOBAL.index--，注释却写着"自动尝试继续下一题" —— 实际是
                    // 退回去重试同一道题。偶发失败这样做是对的，但确定性的异常（适配器对不上
                    // 这个站点的 DOM、页面注入的第三方接口抛错、搜题接口全体超时）每次都一样抛，
                    // 循环就永远卡在这一道题上：既到不了 index >= arr.length，也不会停 ——
                    // GLOBAL.stop 没被置；题目无法识别的路径在上方单独按跳过设置处理。
                    // ponytail: 固定重试 2 次，纯粹是"够区分偶发和必然"的经验值，没有退避。
                    // 最坏情况多花 2×(答题间隔 + 30 秒搜题超时)，比卡死强。
                    const failedAt = GLOBAL.index - 1;
                    if (failedAt === lastFailIndex) failCount++;
                    else { lastFailIndex = failedAt; failCount = 1; }

                    console.error('答题过程异常（第' + (failedAt + 1) + '题，第' + failCount + '次）:', e);

                    // 更友好的错误提示
                    let errorMsg = '答题异常';
                    if (e.message) {
                        if (e.message.includes('network') || e.message.includes('Network')) {
                            errorMsg = '网络异常，请检查网络连接';
                        } else if (e.message.includes('timeout')) {
                            errorMsg = 'AI 响应超时';
                        } else {
                            errorMsg = '异常: ' + e.message.substring(0, 50);
                        }
                    }

                    // 第 12 轮这里是写死的 3（那时标了 ponytail: 经验值），现在归设置管：
                    // 「失败重试次数」= 同一道题最多再试几次，试完还是失败就跳过它继续下一题。
                    // 0 = 一失败就跳过。没设过按 2 走，跟原来的写死值一致。
                    const rl = parseInt(GM_getValue("retry_limit"));
                    const retryLimit = isNaN(rl) || rl < 0 ? 2 : rl;
                    if (failCount <= retryLimit) {
                        GLOBAL.index--;   // 当偶发，退回去重试这一题
                        iframeMsg("tip", {
                            type: "error",
                            tip: errorMsg + '（第' + (failedAt + 1) + '题，重试 ' + failCount + '/' + retryLimit + '）'
                        });
                    } else {
                        // 连着三次一模一样，不是偶发。index 不退回 = 跳过它继续下一题。
                        // 这题没填、也没记进 successCount，正确率会被它拉低，
                        // 自动提交那道阈值闸照常拦得住 —— 不用在这儿额外做什么。
                        console.log('第' + (failedAt + 1) + '题连续失败 3 次，跳过');
                        iframeMsg("tip", {
                            type: "error",
                            tip: '第' + (failedAt + 1) + '题异常已跳过：' + errorMsg
                        });
                    }
                }
            }
        };
    };
    var Typr = {};
    Typr["parse"] = function(buff) {
        var readFont = function(data, idx, offset, tmap) {
            Typr["B"];
            var T = Typr["T"];
            var prsr = {
                cmap: T.cmap,
                head: T.head,
                hhea: T.hhea,
                maxp: T.maxp,
                hmtx: T.hmtx,
                name: T.name,
                "OS/2": T.OS2,
                post: T.post,
                loca: T.loca,
                kern: T.kern,
                glyf: T.glyf,
                "CFF ": T.CFF,
                "SVG ": T.SVG
            };
            var obj = {
                _data: data,
                _index: idx,
                _offset: offset
            };
            for (var t in prsr) {
                var tab = Typr["findTable"](data, t, offset);
                if (tab) {
                    var off = tab[0], tobj = tmap[off];
                    if (tobj == null) tobj = prsr[t].parseTab(data, off, tab[1], obj);
                    obj[t] = tmap[off] = tobj;
                }
            }
            return obj;
        };
        var bin = Typr["B"];
        var data = new Uint8Array(buff);
        var tmap = {};
        var tag = bin.readASCII(data, 0, 4);
        if (tag == "ttcf") {
            var offset = 4;
            bin.readUshort(data, offset);
            offset += 2;
            bin.readUshort(data, offset);
            offset += 2;
            var numF = bin.readUint(data, offset);
            offset += 4;
            var fnts = [];
            for (var i = 0; i < numF; i++) {
                var foff = bin.readUint(data, offset);
                offset += 4;
                fnts.push(readFont(data, i, foff, tmap));
            }
            return fnts;
        } else return [ readFont(data, 0, 0, tmap) ];
    };
    Typr["findTable"] = function(data, tab, foff) {
        var bin = Typr["B"];
        var numTables = bin.readUshort(data, foff + 4);
        var offset = foff + 12;
        for (var i = 0; i < numTables; i++) {
            var tag = bin.readASCII(data, offset, 4);
            bin.readUint(data, offset + 4);
            var toffset = bin.readUint(data, offset + 8);
            var length = bin.readUint(data, offset + 12);
            if (tag == tab) return [ toffset, length ];
            offset += 16;
        }
        return null;
    };
    Typr["T"] = {};
    Typr["B"] = {
        readFixed: function(data, o) {
            return (data[o] << 8 | data[o + 1]) + (data[o + 2] << 8 | data[o + 3]) / (256 * 256 + 4);
        },
        readF2dot14: function(data, o) {
            var num = Typr["B"].readShort(data, o);
            return num / 16384;
        },
        readInt: function(buff, p) {
            var a = Typr["B"].t.uint8;
            a[0] = buff[p + 3];
            a[1] = buff[p + 2];
            a[2] = buff[p + 1];
            a[3] = buff[p];
            return Typr["B"].t.int32[0];
        },
        readInt8: function(buff, p) {
            var a = Typr["B"].t.uint8;
            a[0] = buff[p];
            return Typr["B"].t.int8[0];
        },
        readShort: function(buff, p) {
            var a = Typr["B"].t.uint8;
            a[1] = buff[p];
            a[0] = buff[p + 1];
            return Typr["B"].t.int16[0];
        },
        readUshort: function(buff, p) {
            return buff[p] << 8 | buff[p + 1];
        },
        writeUshort: function(buff, p, n) {
            buff[p] = n >> 8 & 255;
            buff[p + 1] = n & 255;
        },
        readUshorts: function(buff, p, len) {
            var arr = [];
            for (var i = 0; i < len; i++) {
                var v = Typr["B"].readUshort(buff, p + i * 2);
                arr.push(v);
            }
            return arr;
        },
        readUint: function(buff, p) {
            var a = Typr["B"].t.uint8;
            a[3] = buff[p];
            a[2] = buff[p + 1];
            a[1] = buff[p + 2];
            a[0] = buff[p + 3];
            return Typr["B"].t.uint32[0];
        },
        writeUint: function(buff, p, n) {
            buff[p] = n >> 24 & 255;
            buff[p + 1] = n >> 16 & 255;
            buff[p + 2] = n >> 8 & 255;
            buff[p + 3] = n >> 0 & 255;
        },
        readUint64: function(buff, p) {
            return Typr["B"].readUint(buff, p) * (4294967295 + 1) + Typr["B"].readUint(buff, p + 4);
        },
        readASCII: function(buff, p, l) {
            var s = "";
            for (var i = 0; i < l; i++) s += String.fromCharCode(buff[p + i]);
            return s;
        },
        writeASCII: function(buff, p, s) {
            for (var i = 0; i < s.length; i++) buff[p + i] = s.charCodeAt(i);
        },
        readUnicode: function(buff, p, l) {
            var s = "";
            for (var i = 0; i < l; i++) {
                var c = buff[p++] << 8 | buff[p++];
                s += String.fromCharCode(c);
            }
            return s;
        },
        _tdec: window["TextDecoder"] ? new window["TextDecoder"]() : null,
        readUTF8: function(buff, p, l) {
            var tdec = Typr["B"]._tdec;
            if (tdec && p == 0 && l == buff.length) return tdec["decode"](buff);
            return Typr["B"].readASCII(buff, p, l);
        },
        readBytes: function(buff, p, l) {
            var arr = [];
            for (var i = 0; i < l; i++) arr.push(buff[p + i]);
            return arr;
        },
        readASCIIArray: function(buff, p, l) {
            var s = [];
            for (var i = 0; i < l; i++) s.push(String.fromCharCode(buff[p + i]));
            return s;
        },
        t: function() {
            var ab = new ArrayBuffer(8);
            return {
                buff: ab,
                int8: new Int8Array(ab),
                uint8: new Uint8Array(ab),
                int16: new Int16Array(ab),
                uint16: new Uint16Array(ab),
                int32: new Int32Array(ab),
                uint32: new Uint32Array(ab)
            };
        }()
    };
    Typr["T"].CFF = {
        parseTab: function(data, offset, length) {
            var bin = Typr["B"];
            var CFF = Typr["T"].CFF;
            data = new Uint8Array(data.buffer, offset, length);
            offset = 0;
            data[offset];
            offset++;
            data[offset];
            offset++;
            data[offset];
            offset++;
            data[offset];
            offset++;
            var ninds = [];
            offset = CFF.readIndex(data, offset, ninds);
            var names = [];
            for (var i = 0; i < ninds.length - 1; i++) names.push(bin.readASCII(data, offset + ninds[i], ninds[i + 1] - ninds[i]));
            offset += ninds[ninds.length - 1];
            var tdinds = [];
            offset = CFF.readIndex(data, offset, tdinds);
            var topDicts = [];
            for (var i = 0; i < tdinds.length - 1; i++) topDicts.push(CFF.readDict(data, offset + tdinds[i], offset + tdinds[i + 1]));
            offset += tdinds[tdinds.length - 1];
            var topdict = topDicts[0];
            var sinds = [];
            offset = CFF.readIndex(data, offset, sinds);
            var strings = [];
            for (var i = 0; i < sinds.length - 1; i++) strings.push(bin.readASCII(data, offset + sinds[i], sinds[i + 1] - sinds[i]));
            offset += sinds[sinds.length - 1];
            CFF.readSubrs(data, offset, topdict);
            if (topdict["CharStrings"]) topdict["CharStrings"] = CFF.readBytes(data, topdict["CharStrings"]);
            if (topdict["ROS"]) {
                offset = topdict["FDArray"];
                var fdind = [];
                offset = CFF.readIndex(data, offset, fdind);
                topdict["FDArray"] = [];
                for (var i = 0; i < fdind.length - 1; i++) {
                    var dict = CFF.readDict(data, offset + fdind[i], offset + fdind[i + 1]);
                    CFF._readFDict(data, dict, strings);
                    topdict["FDArray"].push(dict);
                }
                offset += fdind[fdind.length - 1];
                offset = topdict["FDSelect"];
                topdict["FDSelect"] = [];
                var fmt = data[offset];
                offset++;
                if (fmt == 3) {
                    var rns = bin.readUshort(data, offset);
                    offset += 2;
                    for (var i = 0; i < rns + 1; i++) {
                        topdict["FDSelect"].push(bin.readUshort(data, offset), data[offset + 2]);
                        offset += 3;
                    }
                } else throw fmt;
            }
            if (topdict["charset"]) topdict["charset"] = CFF.readCharset(data, topdict["charset"], topdict["CharStrings"].length);
            CFF._readFDict(data, topdict, strings);
            return topdict;
        },
        _readFDict: function(data, dict, ss) {
            var CFF = Typr["T"].CFF;
            var offset;
            if (dict["Private"]) {
                offset = dict["Private"][1];
                dict["Private"] = CFF.readDict(data, offset, offset + dict["Private"][0]);
                if (dict["Private"]["Subrs"]) CFF.readSubrs(data, offset + dict["Private"]["Subrs"], dict["Private"]);
            }
            for (var p in dict) if ([ "FamilyName", "FontName", "FullName", "Notice", "version", "Copyright" ].indexOf(p) != -1) dict[p] = ss[dict[p] - 426 + 35];
        },
        readSubrs: function(data, offset, obj) {
            obj["Subrs"] = Typr["T"].CFF.readBytes(data, offset);
            var bias, nSubrs = obj["Subrs"].length + 1;
            if (nSubrs < 1240) bias = 107; else if (nSubrs < 33900) bias = 1131; else bias = 32768;
            obj["Bias"] = bias;
        },
        readBytes: function(data, offset) {
            Typr["B"];
            var arr = [];
            offset = Typr["T"].CFF.readIndex(data, offset, arr);
            var subrs = [], arl = arr.length - 1, no = data.byteOffset + offset;
            for (var i = 0; i < arl; i++) {
                var ari = arr[i];
                subrs.push(new Uint8Array(data.buffer, no + ari, arr[i + 1] - ari));
            }
            return subrs;
        },
        tableSE: [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 0, 111, 112, 113, 114, 0, 115, 116, 117, 118, 119, 120, 121, 122, 0, 123, 0, 124, 125, 126, 127, 128, 129, 130, 131, 0, 132, 133, 0, 134, 135, 136, 137, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 138, 0, 139, 0, 0, 0, 0, 140, 141, 142, 143, 0, 0, 0, 0, 0, 144, 0, 0, 0, 145, 0, 0, 146, 147, 148, 149, 0, 0, 0, 0 ],
        glyphByUnicode: function(cff, code) {
            for (var i = 0; i < cff["charset"].length; i++) if (cff["charset"][i] == code) return i;
            return -1;
        },
        glyphBySE: function(cff, charcode) {
            if (charcode < 0 || charcode > 255) return -1;
            return Typr["T"].CFF.glyphByUnicode(cff, Typr["T"].CFF.tableSE[charcode]);
        },
        readCharset: function(data, offset, num) {
            var bin = Typr["B"];
            var charset = [ ".notdef" ];
            var format = data[offset];
            offset++;
            if (format == 0) {
                for (var i = 0; i < num; i++) {
                    var first = bin.readUshort(data, offset);
                    offset += 2;
                    charset.push(first);
                }
            } else if (format == 1 || format == 2) {
                while (charset.length < num) {
                    var first = bin.readUshort(data, offset);
                    offset += 2;
                    var nLeft = 0;
                    if (format == 1) {
                        nLeft = data[offset];
                        offset++;
                    } else {
                        nLeft = bin.readUshort(data, offset);
                        offset += 2;
                    }
                    for (var i = 0; i <= nLeft; i++) {
                        charset.push(first);
                        first++;
                    }
                }
            } else throw "error: format: " + format;
            return charset;
        },
        readIndex: function(data, offset, inds) {
            var bin = Typr["B"];
            var count = bin.readUshort(data, offset) + 1;
            offset += 2;
            var offsize = data[offset];
            offset++;
            if (offsize == 1) for (var i = 0; i < count; i++) inds.push(data[offset + i]); else if (offsize == 2) for (var i = 0; i < count; i++) inds.push(bin.readUshort(data, offset + i * 2)); else if (offsize == 3) for (var i = 0; i < count; i++) inds.push(bin.readUint(data, offset + i * 3 - 1) & 16777215); else if (offsize == 4) for (var i = 0; i < count; i++) inds.push(bin.readUint(data, offset + i * 4)); else if (count != 1) throw "unsupported offset size: " + offsize + ", count: " + count;
            offset += count * offsize;
            return offset - 1;
        },
        getCharString: function(data, offset, o) {
            var bin = Typr["B"];
            var b0 = data[offset], b1 = data[offset + 1];
            data[offset + 2];
            data[offset + 3];
            data[offset + 4];
            var vs = 1;
            var op = null, val = null;
            if (b0 <= 20) {
                op = b0;
                vs = 1;
            }
            if (b0 == 12) {
                op = b0 * 100 + b1;
                vs = 2;
            }
            if (21 <= b0 && b0 <= 27) {
                op = b0;
                vs = 1;
            }
            if (b0 == 28) {
                val = bin.readShort(data, offset + 1);
                vs = 3;
            }
            if (29 <= b0 && b0 <= 31) {
                op = b0;
                vs = 1;
            }
            if (32 <= b0 && b0 <= 246) {
                val = b0 - 139;
                vs = 1;
            }
            if (247 <= b0 && b0 <= 250) {
                val = (b0 - 247) * 256 + b1 + 108;
                vs = 2;
            }
            if (251 <= b0 && b0 <= 254) {
                val = -(b0 - 251) * 256 - b1 - 108;
                vs = 2;
            }
            if (b0 == 255) {
                val = bin.readInt(data, offset + 1) / 65535;
                vs = 5;
            }
            o.val = val != null ? val : "o" + op;
            o.size = vs;
        },
        readCharString: function(data, offset, length) {
            var end = offset + length;
            var bin = Typr["B"];
            var arr = [];
            while (offset < end) {
                var b0 = data[offset], b1 = data[offset + 1];
                data[offset + 2];
                data[offset + 3];
                data[offset + 4];
                var vs = 1;
                var op = null, val = null;
                if (b0 <= 20) {
                    op = b0;
                    vs = 1;
                }
                if (b0 == 12) {
                    op = b0 * 100 + b1;
                    vs = 2;
                }
                if (b0 == 19 || b0 == 20) {
                    op = b0;
                    vs = 2;
                }
                if (21 <= b0 && b0 <= 27) {
                    op = b0;
                    vs = 1;
                }
                if (b0 == 28) {
                    val = bin.readShort(data, offset + 1);
                    vs = 3;
                }
                if (29 <= b0 && b0 <= 31) {
                    op = b0;
                    vs = 1;
                }
                if (32 <= b0 && b0 <= 246) {
                    val = b0 - 139;
                    vs = 1;
                }
                if (247 <= b0 && b0 <= 250) {
                    val = (b0 - 247) * 256 + b1 + 108;
                    vs = 2;
                }
                if (251 <= b0 && b0 <= 254) {
                    val = -(b0 - 251) * 256 - b1 - 108;
                    vs = 2;
                }
                if (b0 == 255) {
                    val = bin.readInt(data, offset + 1) / 65535;
                    vs = 5;
                }
                arr.push(val != null ? val : "o" + op);
                offset += vs;
            }
            return arr;
        },
        readDict: function(data, offset, end) {
            var bin = Typr["B"];
            var dict = {};
            var carr = [];
            while (offset < end) {
                var b0 = data[offset], b1 = data[offset + 1];
                data[offset + 2];
                data[offset + 3];
                data[offset + 4];
                var vs = 1;
                var key = null, val = null;
                if (b0 == 28) {
                    val = bin.readShort(data, offset + 1);
                    vs = 3;
                }
                if (b0 == 29) {
                    val = bin.readInt(data, offset + 1);
                    vs = 5;
                }
                if (32 <= b0 && b0 <= 246) {
                    val = b0 - 139;
                    vs = 1;
                }
                if (247 <= b0 && b0 <= 250) {
                    val = (b0 - 247) * 256 + b1 + 108;
                    vs = 2;
                }
                if (251 <= b0 && b0 <= 254) {
                    val = -(b0 - 251) * 256 - b1 - 108;
                    vs = 2;
                }
                if (b0 == 255) {
                    val = bin.readInt(data, offset + 1) / 65535;
                    vs = 5;
                    throw "unknown number";
                }
                if (b0 == 30) {
                    var nibs = [];
                    vs = 1;
                    while (true) {
                        var b = data[offset + vs];
                        vs++;
                        var nib0 = b >> 4, nib1 = b & 15;
                        if (nib0 != 15) nibs.push(nib0);
                        if (nib1 != 15) nibs.push(nib1);
                        if (nib1 == 15) break;
                    }
                    var s = "";
                    var chars = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ".", "e", "e-", "reserved", "-", "endOfNumber" ];
                    for (var i = 0; i < nibs.length; i++) s += chars[nibs[i]];
                    val = parseFloat(s);
                }
                if (b0 <= 21) {
                    var keys = [ "version", "Notice", "FullName", "FamilyName", "Weight", "FontBBox", "BlueValues", "OtherBlues", "FamilyBlues", "FamilyOtherBlues", "StdHW", "StdVW", "escape", "UniqueID", "XUID", "charset", "Encoding", "CharStrings", "Private", "Subrs", "defaultWidthX", "nominalWidthX" ];
                    key = keys[b0];
                    vs = 1;
                    if (b0 == 12) {
                        var keys = [ "Copyright", "isFixedPitch", "ItalicAngle", "UnderlinePosition", "UnderlineThickness", "PaintType", "CharstringType", "FontMatrix", "StrokeWidth", "BlueScale", "BlueShift", "BlueFuzz", "StemSnapH", "StemSnapV", "ForceBold", "", "", "LanguageGroup", "ExpansionFactor", "initialRandomSeed", "SyntheticBase", "PostScript", "BaseFontName", "BaseFontBlend", "", "", "", "", "", "", "ROS", "CIDFontVersion", "CIDFontRevision", "CIDFontType", "CIDCount", "UIDBase", "FDArray", "FDSelect", "FontName" ];
                        key = keys[b1];
                        vs = 2;
                    }
                }
                if (key != null) {
                    dict[key] = carr.length == 1 ? carr[0] : carr;
                    carr = [];
                } else carr.push(val);
                offset += vs;
            }
            return dict;
        }
    };
    Typr["T"].cmap = {
        parseTab: function(data, offset, length) {
            var obj = {
                tables: [],
                ids: {},
                off: offset
            };
            data = new Uint8Array(data.buffer, offset, length);
            offset = 0;
            var bin = Typr["B"], rU = bin.readUshort, cmap = Typr["T"].cmap;
            rU(data, offset);
            offset += 2;
            var numTables = rU(data, offset);
            offset += 2;
            var offs = [];
            for (var i = 0; i < numTables; i++) {
                var platformID = rU(data, offset);
                offset += 2;
                var encodingID = rU(data, offset);
                offset += 2;
                var noffset = bin.readUint(data, offset);
                offset += 4;
                var id = "p" + platformID + "e" + encodingID;
                var tind = offs.indexOf(noffset);
                if (tind == -1) {
                    tind = obj.tables.length;
                    var subt = {};
                    offs.push(noffset);
                    var format = subt.format = rU(data, noffset);
                    if (format == 0) subt = cmap.parse0(data, noffset, subt); else if (format == 4) subt = cmap.parse4(data, noffset, subt); else if (format == 6) subt = cmap.parse6(data, noffset, subt); else if (format == 12) subt = cmap.parse12(data, noffset, subt);
                    obj.tables.push(subt);
                }
                if (obj.ids[id] != null) throw "multiple tables for one platform+encoding";
                obj.ids[id] = tind;
            }
            return obj;
        },
        parse0: function(data, offset, obj) {
            var bin = Typr["B"];
            offset += 2;
            var len = bin.readUshort(data, offset);
            offset += 2;
            bin.readUshort(data, offset);
            offset += 2;
            obj.map = [];
            for (var i = 0; i < len - 6; i++) obj.map.push(data[offset + i]);
            return obj;
        },
        parse4: function(data, offset, obj) {
            var bin = Typr["B"], rU = bin.readUshort, rUs = bin.readUshorts;
            var offset0 = offset;
            offset += 2;
            var length = rU(data, offset);
            offset += 2;
            rU(data, offset);
            offset += 2;
            var segCountX2 = rU(data, offset);
            offset += 2;
            var segCount = segCountX2 >>> 1;
            obj.searchRange = rU(data, offset);
            offset += 2;
            obj.entrySelector = rU(data, offset);
            offset += 2;
            obj.rangeShift = rU(data, offset);
            offset += 2;
            obj.endCount = rUs(data, offset, segCount);
            offset += segCount * 2;
            offset += 2;
            obj.startCount = rUs(data, offset, segCount);
            offset += segCount * 2;
            obj.idDelta = [];
            for (var i = 0; i < segCount; i++) {
                obj.idDelta.push(bin.readShort(data, offset));
                offset += 2;
            }
            obj.idRangeOffset = rUs(data, offset, segCount);
            offset += segCount * 2;
            obj.glyphIdArray = rUs(data, offset, offset0 + length - offset >>> 1);
            return obj;
        },
        parse6: function(data, offset, obj) {
            var bin = Typr["B"];
            offset += 2;
            bin.readUshort(data, offset);
            offset += 2;
            bin.readUshort(data, offset);
            offset += 2;
            obj.firstCode = bin.readUshort(data, offset);
            offset += 2;
            var entryCount = bin.readUshort(data, offset);
            offset += 2;
            obj.glyphIdArray = [];
            for (var i = 0; i < entryCount; i++) {
                obj.glyphIdArray.push(bin.readUshort(data, offset));
                offset += 2;
            }
            return obj;
        },
        parse12: function(data, offset, obj) {
            var bin = Typr["B"], rU = bin.readUint;
            offset += 4;
            rU(data, offset);
            offset += 4;
            rU(data, offset);
            offset += 4;
            var nGroups = rU(data, offset) * 3;
            offset += 4;
            var gps = obj.groups = new Uint32Array(nGroups);
            for (var i = 0; i < nGroups; i += 3) {
                gps[i] = rU(data, offset + (i << 2));
                gps[i + 1] = rU(data, offset + (i << 2) + 4);
                gps[i + 2] = rU(data, offset + (i << 2) + 8);
            }
            return obj;
        }
    };
    Typr["T"].glyf = {
        parseTab: function(data, offset, length, font) {
            var obj = [], ng = font["maxp"]["numGlyphs"];
            for (var g = 0; g < ng; g++) obj.push(null);
            return obj;
        },
        _parseGlyf: function(font, g) {
            var bin = Typr["B"];
            var data = font["_data"], loca = font["loca"];
            if (loca[g] == loca[g + 1]) return null;
            var offset = Typr["findTable"](data, "glyf", font["_offset"])[0] + loca[g];
            var gl = {};
            gl.noc = bin.readShort(data, offset);
            offset += 2;
            gl.xMin = bin.readShort(data, offset);
            offset += 2;
            gl.yMin = bin.readShort(data, offset);
            offset += 2;
            gl.xMax = bin.readShort(data, offset);
            offset += 2;
            gl.yMax = bin.readShort(data, offset);
            offset += 2;
            if (gl.xMin >= gl.xMax || gl.yMin >= gl.yMax) return null;
            if (gl.noc > 0) {
                gl.endPts = [];
                for (var i = 0; i < gl.noc; i++) {
                    gl.endPts.push(bin.readUshort(data, offset));
                    offset += 2;
                }
                var instructionLength = bin.readUshort(data, offset);
                offset += 2;
                if (data.length - offset < instructionLength) return null;
                gl.instructions = bin.readBytes(data, offset, instructionLength);
                offset += instructionLength;
                var crdnum = gl.endPts[gl.noc - 1] + 1;
                gl.flags = [];
                for (var i = 0; i < crdnum; i++) {
                    var flag = data[offset];
                    offset++;
                    gl.flags.push(flag);
                    if ((flag & 8) != 0) {
                        var rep = data[offset];
                        offset++;
                        for (var j = 0; j < rep; j++) {
                            gl.flags.push(flag);
                            i++;
                        }
                    }
                }
                gl.xs = [];
                for (var i = 0; i < crdnum; i++) {
                    var i8 = (gl.flags[i] & 2) != 0, same = (gl.flags[i] & 16) != 0;
                    if (i8) {
                        gl.xs.push(same ? data[offset] : -data[offset]);
                        offset++;
                    } else {
                        if (same) gl.xs.push(0); else {
                            gl.xs.push(bin.readShort(data, offset));
                            offset += 2;
                        }
                    }
                }
                gl.ys = [];
                for (var i = 0; i < crdnum; i++) {
                    var i8 = (gl.flags[i] & 4) != 0, same = (gl.flags[i] & 32) != 0;
                    if (i8) {
                        gl.ys.push(same ? data[offset] : -data[offset]);
                        offset++;
                    } else {
                        if (same) gl.ys.push(0); else {
                            gl.ys.push(bin.readShort(data, offset));
                            offset += 2;
                        }
                    }
                }
                var x = 0, y = 0;
                for (var i = 0; i < crdnum; i++) {
                    x += gl.xs[i];
                    y += gl.ys[i];
                    gl.xs[i] = x;
                    gl.ys[i] = y;
                }
            } else {
                var ARG_1_AND_2_ARE_WORDS = 1 << 0;
                var ARGS_ARE_XY_VALUES = 1 << 1;
                var WE_HAVE_A_SCALE = 1 << 3;
                var MORE_COMPONENTS = 1 << 5;
                var WE_HAVE_AN_X_AND_Y_SCALE = 1 << 6;
                var WE_HAVE_A_TWO_BY_TWO = 1 << 7;
                var WE_HAVE_INSTRUCTIONS = 1 << 8;
                gl.parts = [];
                var flags;
                do {
                    flags = bin.readUshort(data, offset);
                    offset += 2;
                    var part = {
                        m: {
                            a: 1,
                            b: 0,
                            c: 0,
                            d: 1,
                            tx: 0,
                            ty: 0
                        },
                        p1: -1,
                        p2: -1
                    };
                    gl.parts.push(part);
                    part.glyphIndex = bin.readUshort(data, offset);
                    offset += 2;
                    if (flags & ARG_1_AND_2_ARE_WORDS) {
                        var arg1 = bin.readShort(data, offset);
                        offset += 2;
                        var arg2 = bin.readShort(data, offset);
                        offset += 2;
                    } else {
                        var arg1 = bin.readInt8(data, offset);
                        offset++;
                        var arg2 = bin.readInt8(data, offset);
                        offset++;
                    }
                    if (flags & ARGS_ARE_XY_VALUES) {
                        part.m.tx = arg1;
                        part.m.ty = arg2;
                    } else {
                        part.p1 = arg1;
                        part.p2 = arg2;
                    }
                    if (flags & WE_HAVE_A_SCALE) {
                        part.m.a = part.m.d = bin.readF2dot14(data, offset);
                        offset += 2;
                    } else if (flags & WE_HAVE_AN_X_AND_Y_SCALE) {
                        part.m.a = bin.readF2dot14(data, offset);
                        offset += 2;
                        part.m.d = bin.readF2dot14(data, offset);
                        offset += 2;
                    } else if (flags & WE_HAVE_A_TWO_BY_TWO) {
                        part.m.a = bin.readF2dot14(data, offset);
                        offset += 2;
                        part.m.b = bin.readF2dot14(data, offset);
                        offset += 2;
                        part.m.c = bin.readF2dot14(data, offset);
                        offset += 2;
                        part.m.d = bin.readF2dot14(data, offset);
                        offset += 2;
                    }
                } while (flags & MORE_COMPONENTS);
                if (flags & WE_HAVE_INSTRUCTIONS) {
                    var numInstr = bin.readUshort(data, offset);
                    offset += 2;
                    gl.instr = [];
                    for (var i = 0; i < numInstr; i++) {
                        gl.instr.push(data[offset]);
                        offset++;
                    }
                }
            }
            return gl;
        }
    };
    Typr["T"].head = {
        parseTab: function(data, offset, length) {
            var bin = Typr["B"];
            var obj = {};
            bin.readFixed(data, offset);
            offset += 4;
            obj["fontRevision"] = bin.readFixed(data, offset);
            offset += 4;
            bin.readUint(data, offset);
            offset += 4;
            bin.readUint(data, offset);
            offset += 4;
            obj["flags"] = bin.readUshort(data, offset);
            offset += 2;
            obj["unitsPerEm"] = bin.readUshort(data, offset);
            offset += 2;
            obj["created"] = bin.readUint64(data, offset);
            offset += 8;
            obj["modified"] = bin.readUint64(data, offset);
            offset += 8;
            obj["xMin"] = bin.readShort(data, offset);
            offset += 2;
            obj["yMin"] = bin.readShort(data, offset);
            offset += 2;
            obj["xMax"] = bin.readShort(data, offset);
            offset += 2;
            obj["yMax"] = bin.readShort(data, offset);
            offset += 2;
            obj["macStyle"] = bin.readUshort(data, offset);
            offset += 2;
            obj["lowestRecPPEM"] = bin.readUshort(data, offset);
            offset += 2;
            obj["fontDirectionHint"] = bin.readShort(data, offset);
            offset += 2;
            obj["indexToLocFormat"] = bin.readShort(data, offset);
            offset += 2;
            obj["glyphDataFormat"] = bin.readShort(data, offset);
            offset += 2;
            return obj;
        }
    };
    Typr["T"].hhea = {
        parseTab: function(data, offset, length) {
            var bin = Typr["B"];
            var obj = {};
            bin.readFixed(data, offset);
            offset += 4;
            var keys = [ "ascender", "descender", "lineGap", "advanceWidthMax", "minLeftSideBearing", "minRightSideBearing", "xMaxExtent", "caretSlopeRise", "caretSlopeRun", "caretOffset", "res0", "res1", "res2", "res3", "metricDataFormat", "numberOfHMetrics" ];
            for (var i = 0; i < keys.length; i++) {
                var key = keys[i];
                var func = key == "advanceWidthMax" || key == "numberOfHMetrics" ? bin.readUshort : bin.readShort;
                obj[key] = func(data, offset + i * 2);
            }
            return obj;
        }
    };
    Typr["T"].hmtx = {
        parseTab: function(data, offset, length, font) {
            var bin = Typr["B"];
            var aWidth = [];
            var lsBearing = [];
            var nG = font["maxp"]["numGlyphs"], nH = font["hhea"]["numberOfHMetrics"];
            var aw = 0, lsb = 0, i = 0;
            while (i < nH) {
                aw = bin.readUshort(data, offset + (i << 2));
                lsb = bin.readShort(data, offset + (i << 2) + 2);
                aWidth.push(aw);
                lsBearing.push(lsb);
                i++;
            }
            while (i < nG) {
                aWidth.push(aw);
                lsBearing.push(lsb);
                i++;
            }
            return {
                aWidth: aWidth,
                lsBearing: lsBearing
            };
        }
    };
    Typr["T"].kern = {
        parseTab: function(data, offset, length, font) {
            var bin = Typr["B"], kern = Typr["T"].kern;
            var version = bin.readUshort(data, offset);
            if (version == 1) return kern.parseV1(data, offset, length, font);
            var nTables = bin.readUshort(data, offset + 2);
            offset += 4;
            var map = {
                glyph1: [],
                rval: []
            };
            for (var i = 0; i < nTables; i++) {
                offset += 2;
                var length = bin.readUshort(data, offset);
                offset += 2;
                var coverage = bin.readUshort(data, offset);
                offset += 2;
                var format = coverage >>> 8;
                format &= 15;
                if (format == 0) offset = kern.readFormat0(data, offset, map);
            }
            return map;
        },
        parseV1: function(data, offset, length, font) {
            var bin = Typr["B"], kern = Typr["T"].kern;
            bin.readFixed(data, offset);
            var nTables = bin.readUint(data, offset + 4);
            offset += 8;
            var map = {
                glyph1: [],
                rval: []
            };
            for (var i = 0; i < nTables; i++) {
                bin.readUint(data, offset);
                offset += 4;
                var coverage = bin.readUshort(data, offset);
                offset += 2;
                bin.readUshort(data, offset);
                offset += 2;
                var format = coverage & 255;
                if (format == 0) offset = kern.readFormat0(data, offset, map);
            }
            return map;
        },
        readFormat0: function(data, offset, map) {
            var bin = Typr["B"], rUs = bin.readUshort;
            var pleft = -1;
            var nPairs = rUs(data, offset);
            rUs(data, offset + 2);
            rUs(data, offset + 4);
            rUs(data, offset + 6);
            offset += 8;
            for (var j = 0; j < nPairs; j++) {
                var left = rUs(data, offset);
                offset += 2;
                var right = rUs(data, offset);
                offset += 2;
                var value = bin.readShort(data, offset);
                offset += 2;
                if (left != pleft) {
                    map.glyph1.push(left);
                    map.rval.push({
                        glyph2: [],
                        vals: []
                    });
                }
                var rval = map.rval[map.rval.length - 1];
                rval.glyph2.push(right);
                rval.vals.push(value);
                pleft = left;
            }
            return offset;
        }
    };
    Typr["T"].loca = {
        parseTab: function(data, offset, length, font) {
            var bin = Typr["B"];
            var obj = [];
            var ver = font["head"]["indexToLocFormat"];
            var len = font["maxp"]["numGlyphs"] + 1;
            if (ver == 0) for (var i = 0; i < len; i++) obj.push(bin.readUshort(data, offset + (i << 1)) << 1);
            if (ver == 1) for (var i = 0; i < len; i++) obj.push(bin.readUint(data, offset + (i << 2)));
            return obj;
        }
    };
    Typr["T"].maxp = {
        parseTab: function(data, offset, length) {
            var bin = Typr["B"], rU = bin.readUshort;
            var obj = {};
            bin.readUint(data, offset);
            offset += 4;
            obj["numGlyphs"] = rU(data, offset);
            offset += 2;
            return obj;
        }
    };
    Typr["T"].name = {
        parseTab: function(data, offset, length) {
            var bin = Typr["B"];
            var obj = {};
            bin.readUshort(data, offset);
            offset += 2;
            var count = bin.readUshort(data, offset);
            offset += 2;
            bin.readUshort(data, offset);
            offset += 2;
            var names = [ "copyright", "fontFamily", "fontSubfamily", "ID", "fullName", "version", "postScriptName", "trademark", "manufacturer", "designer", "description", "urlVendor", "urlDesigner", "licence", "licenceURL", "---", "typoFamilyName", "typoSubfamilyName", "compatibleFull", "sampleText", "postScriptCID", "wwsFamilyName", "wwsSubfamilyName", "lightPalette", "darkPalette" ];
            var offset0 = offset;
            var rU = bin.readUshort;
            for (var i = 0; i < count; i++) {
                var platformID = rU(data, offset);
                offset += 2;
                var encodingID = rU(data, offset);
                offset += 2;
                var languageID = rU(data, offset);
                offset += 2;
                var nameID = rU(data, offset);
                offset += 2;
                var slen = rU(data, offset);
                offset += 2;
                var noffset = rU(data, offset);
                offset += 2;
                var soff = offset0 + count * 12 + noffset;
                var str;
                if (platformID == 0) str = bin.readUnicode(data, soff, slen / 2); else if (platformID == 3 && encodingID == 0) str = bin.readUnicode(data, soff, slen / 2); else if (encodingID == 0) str = bin.readASCII(data, soff, slen); else if (encodingID == 1) str = bin.readUnicode(data, soff, slen / 2); else if (encodingID == 3) str = bin.readUnicode(data, soff, slen / 2); else if (encodingID == 4) str = bin.readUnicode(data, soff, slen / 2); else if (encodingID == 10) str = bin.readUnicode(data, soff, slen / 2); else if (platformID == 1) {
                    str = bin.readASCII(data, soff, slen);
                    console.log("reading unknown MAC encoding " + encodingID + " as ASCII");
                } else {
                    console.log("unknown encoding " + encodingID + ", platformID: " + platformID);
                    str = bin.readASCII(data, soff, slen);
                }
                var tid = "p" + platformID + "," + languageID.toString(16);
                if (obj[tid] == null) obj[tid] = {};
                obj[tid][names[nameID]] = str;
                obj[tid]["_lang"] = languageID;
            }
            var psn = "postScriptName";
            for (var p in obj) if (obj[p][psn] != null && obj[p]["_lang"] == 1033) return obj[p];
            for (var p in obj) if (obj[p][psn] != null && obj[p]["_lang"] == 0) return obj[p];
            for (var p in obj) if (obj[p][psn] != null && obj[p]["_lang"] == 3084) return obj[p];
            for (var p in obj) if (obj[p][psn] != null) return obj[p];
            var out;
            for (var p in obj) {
                out = obj[p];
                break;
            }
            console.log("returning name table with languageID " + out._lang);
            if (out[psn] == null && out["ID"] != null) out[psn] = out["ID"];
            return out;
        }
    };
    Typr["T"].OS2 = {
        parseTab: function(data, offset, length) {
            var bin = Typr["B"];
            var ver = bin.readUshort(data, offset);
            offset += 2;
            var OS2 = Typr["T"].OS2;
            var obj = {};
            if (ver == 0) OS2.version0(data, offset, obj); else if (ver == 1) OS2.version1(data, offset, obj); else if (ver == 2 || ver == 3 || ver == 4) OS2.version2(data, offset, obj); else if (ver == 5) OS2.version5(data, offset, obj); else throw "unknown OS/2 table version: " + ver;
            return obj;
        },
        version0: function(data, offset, obj) {
            var bin = Typr["B"];
            obj["xAvgCharWidth"] = bin.readShort(data, offset);
            offset += 2;
            obj["usWeightClass"] = bin.readUshort(data, offset);
            offset += 2;
            obj["usWidthClass"] = bin.readUshort(data, offset);
            offset += 2;
            obj["fsType"] = bin.readUshort(data, offset);
            offset += 2;
            obj["ySubscriptXSize"] = bin.readShort(data, offset);
            offset += 2;
            obj["ySubscriptYSize"] = bin.readShort(data, offset);
            offset += 2;
            obj["ySubscriptXOffset"] = bin.readShort(data, offset);
            offset += 2;
            obj["ySubscriptYOffset"] = bin.readShort(data, offset);
            offset += 2;
            obj["ySuperscriptXSize"] = bin.readShort(data, offset);
            offset += 2;
            obj["ySuperscriptYSize"] = bin.readShort(data, offset);
            offset += 2;
            obj["ySuperscriptXOffset"] = bin.readShort(data, offset);
            offset += 2;
            obj["ySuperscriptYOffset"] = bin.readShort(data, offset);
            offset += 2;
            obj["yStrikeoutSize"] = bin.readShort(data, offset);
            offset += 2;
            obj["yStrikeoutPosition"] = bin.readShort(data, offset);
            offset += 2;
            obj["sFamilyClass"] = bin.readShort(data, offset);
            offset += 2;
            obj["panose"] = bin.readBytes(data, offset, 10);
            offset += 10;
            obj["ulUnicodeRange1"] = bin.readUint(data, offset);
            offset += 4;
            obj["ulUnicodeRange2"] = bin.readUint(data, offset);
            offset += 4;
            obj["ulUnicodeRange3"] = bin.readUint(data, offset);
            offset += 4;
            obj["ulUnicodeRange4"] = bin.readUint(data, offset);
            offset += 4;
            obj["achVendID"] = bin.readASCII(data, offset, 4);
            offset += 4;
            obj["fsSelection"] = bin.readUshort(data, offset);
            offset += 2;
            obj["usFirstCharIndex"] = bin.readUshort(data, offset);
            offset += 2;
            obj["usLastCharIndex"] = bin.readUshort(data, offset);
            offset += 2;
            obj["sTypoAscender"] = bin.readShort(data, offset);
            offset += 2;
            obj["sTypoDescender"] = bin.readShort(data, offset);
            offset += 2;
            obj["sTypoLineGap"] = bin.readShort(data, offset);
            offset += 2;
            obj["usWinAscent"] = bin.readUshort(data, offset);
            offset += 2;
            obj["usWinDescent"] = bin.readUshort(data, offset);
            offset += 2;
            return offset;
        },
        version1: function(data, offset, obj) {
            var bin = Typr["B"];
            offset = Typr["T"].OS2.version0(data, offset, obj);
            obj["ulCodePageRange1"] = bin.readUint(data, offset);
            offset += 4;
            obj["ulCodePageRange2"] = bin.readUint(data, offset);
            offset += 4;
            return offset;
        },
        version2: function(data, offset, obj) {
            var bin = Typr["B"], rU = bin.readUshort;
            offset = Typr["T"].OS2.version1(data, offset, obj);
            obj["sxHeight"] = bin.readShort(data, offset);
            offset += 2;
            obj["sCapHeight"] = bin.readShort(data, offset);
            offset += 2;
            obj["usDefault"] = rU(data, offset);
            offset += 2;
            obj["usBreak"] = rU(data, offset);
            offset += 2;
            obj["usMaxContext"] = rU(data, offset);
            offset += 2;
            return offset;
        },
        version5: function(data, offset, obj) {
            var rU = Typr["B"].readUshort;
            offset = Typr["T"].OS2.version2(data, offset, obj);
            obj["usLowerOpticalPointSize"] = rU(data, offset);
            offset += 2;
            obj["usUpperOpticalPointSize"] = rU(data, offset);
            offset += 2;
            return offset;
        }
    };
    Typr["T"].post = {
        parseTab: function(data, offset, length) {
            var bin = Typr["B"];
            var obj = {};
            obj["version"] = bin.readFixed(data, offset);
            offset += 4;
            obj["italicAngle"] = bin.readFixed(data, offset);
            offset += 4;
            obj["underlinePosition"] = bin.readShort(data, offset);
            offset += 2;
            obj["underlineThickness"] = bin.readShort(data, offset);
            offset += 2;
            return obj;
        }
    };
    Typr["T"].SVG = {
        parseTab: function(data, offset, length) {
            var bin = Typr["B"];
            var obj = {
                entries: []
            };
            var offset0 = offset;
            bin.readUshort(data, offset);
            offset += 2;
            var svgDocIndexOffset = bin.readUint(data, offset);
            offset += 4;
            bin.readUint(data, offset);
            offset += 4;
            offset = svgDocIndexOffset + offset0;
            var numEntries = bin.readUshort(data, offset);
            offset += 2;
            for (var i = 0; i < numEntries; i++) {
                var startGlyphID = bin.readUshort(data, offset);
                offset += 2;
                var endGlyphID = bin.readUshort(data, offset);
                offset += 2;
                var svgDocOffset = bin.readUint(data, offset);
                offset += 4;
                var svgDocLength = bin.readUint(data, offset);
                offset += 4;
                var sbuf = new Uint8Array(data.buffer, offset0 + svgDocOffset + svgDocIndexOffset, svgDocLength);
                var svg = bin.readUTF8(sbuf, 0, sbuf.length);
                for (var f = startGlyphID; f <= endGlyphID; f++) {
                    obj.entries[f] = svg;
                }
            }
            return obj;
        }
    };
    Typr["U"] = {
        shape: function(font, str, ltr) {
            var getGlyphPosition = function(font, gls, i1, ltr) {
                var g1 = gls[i1], g2 = gls[i1 + 1], kern = font["kern"];
                if (kern) {
                    var ind1 = kern.glyph1.indexOf(g1);
                    if (ind1 != -1) {
                        var ind2 = kern.rval[ind1].glyph2.indexOf(g2);
                        if (ind2 != -1) return [ 0, 0, kern.rval[ind1].vals[ind2], 0 ];
                    }
                }
                return [ 0, 0, 0, 0 ];
            };
            var gls = [];
            for (var i = 0; i < str.length; i++) {
                var cc = str.codePointAt(i);
                if (cc > 65535) i++;
                gls.push(Typr["U"]["codeToGlyph"](font, cc));
            }
            var shape = [];
            for (var i = 0; i < gls.length; i++) {
                var padj = getGlyphPosition(font, gls, i);
                var gid = gls[i];
                var ax = font["hmtx"].aWidth[gid] + padj[2];
                shape.push({
                    g: gid,
                    cl: i,
                    dx: 0,
                    dy: 0,
                    ax: ax,
                    ay: 0
                });
            }
            return shape;
        },
        shapeToPath: function(font, shape, clr) {
            var tpath = {
                cmds: [],
                crds: []
            };
            var x = 0, y = 0;
            for (var i = 0; i < shape.length; i++) {
                var it = shape[i];
                var path = Typr["U"]["glyphToPath"](font, it["g"]), crds = path["crds"];
                for (var j = 0; j < crds.length; j += 2) {
                    tpath.crds.push(crds[j] + x + it["dx"]);
                    tpath.crds.push(crds[j + 1] + y + it["dy"]);
                }
                if (clr) tpath.cmds.push(clr);
                for (var j = 0; j < path["cmds"].length; j++) tpath.cmds.push(path["cmds"][j]);
                var clen = tpath.cmds.length;
                if (clr) if (clen != 0 && tpath.cmds[clen - 1] != "X") tpath.cmds.push("X");
                x += it["ax"];
                y += it["ay"];
            }
            return {
                cmds: tpath.cmds,
                crds: tpath.crds
            };
        },
        codeToGlyph: function(font, code) {
            var cmap = font["cmap"];
            var tind = -1, pps = [ "p3e10", "p0e4", "p3e1", "p1e0", "p0e3", "p0e1" ];
            for (var i = 0; i < pps.length; i++) if (cmap.ids[pps[i]] != null) {
                tind = cmap.ids[pps[i]];
                break;
            }
            if (tind == -1) throw "no familiar platform and encoding!";
            var arrSearch = function(arr, k, v) {
                var l = 0, r = Math.floor(arr.length / k);
                while (l + 1 != r) {
                    var mid = l + (r - l >>> 1);
                    if (arr[mid * k] <= v) l = mid; else r = mid;
                }
                return l * k;
            };
            var tab = cmap.tables[tind], fmt = tab.format, gid = -1;
            if (fmt == 0) {
                if (code >= tab.map.length) gid = 0; else gid = tab.map[code];
            } else if (fmt == 4) {
                var sind = -1, ec = tab.endCount;
                if (code > ec[ec.length - 1]) sind = -1; else {
                    sind = arrSearch(ec, 1, code);
                    if (ec[sind] < code) sind++;
                }
                if (sind == -1) gid = 0; else if (code < tab.startCount[sind]) gid = 0; else {
                    var gli = 0;
                    if (tab.idRangeOffset[sind] != 0) gli = tab.glyphIdArray[code - tab.startCount[sind] + (tab.idRangeOffset[sind] >> 1) - (tab.idRangeOffset.length - sind)]; else gli = code + tab.idDelta[sind];
                    gid = gli & 65535;
                }
            } else if (fmt == 6) {
                var off = code - tab.firstCode, arr = tab.glyphIdArray;
                if (off < 0 || off >= arr.length) gid = 0; else gid = arr[off];
            } else if (fmt == 12) {
                var grp = tab.groups;
                if (code > grp[grp.length - 2]) gid = 0; else {
                    var i = arrSearch(grp, 3, code);
                    if (grp[i] <= code && code <= grp[i + 1]) {
                        gid = grp[i + 2] + (code - grp[i]);
                    }
                    if (gid == -1) gid = 0;
                }
            } else throw "unknown cmap table format " + tab.format;
            var SVG = font["SVG "], loca = font["loca"];
            if (gid != 0 && font["CFF "] == null && (SVG == null || SVG.entries[gid] == null) && loca[gid] == loca[gid + 1] && [ 9, 10, 11, 12, 13, 32, 133, 160, 5760, 8232, 8233, 8239, 12288, 6158, 8203, 8204, 8205, 8288, 65279 ].indexOf(code) == -1 && !(8192 <= code && code <= 8202)) gid = 0;
            return gid;
        },
        glyphToPath: function(font, gid) {
            var path = {
                cmds: [],
                crds: []
            };
            var SVG = font["SVG "], CFF = font["CFF "];
            var U = Typr["U"];
            if (SVG && SVG.entries[gid]) {
                var p = SVG.entries[gid];
                if (p != null) {
                    if (typeof p == "string") {
                        p = U["SVG"].toPath(p);
                        SVG.entries[gid] = p;
                    }
                    path = p;
                }
            } else if (CFF) {
                var pdct = CFF["Private"];
                var state = {
                    x: 0,
                    y: 0,
                    stack: [],
                    nStems: 0,
                    haveWidth: false,
                    width: pdct ? pdct["defaultWidthX"] : 0,
                    open: false
                };
                if (CFF["ROS"]) {
                    var gi = 0;
                    while (CFF["FDSelect"][gi + 2] <= gid) gi += 2;
                    pdct = CFF["FDArray"][CFF["FDSelect"][gi + 1]]["Private"];
                }
                U["_drawCFF"](CFF["CharStrings"][gid], state, CFF, pdct, path);
            } else if (font["glyf"]) {
                U["_drawGlyf"](gid, font, path);
            }
            return {
                cmds: path.cmds,
                crds: path.crds
            };
        },
        _drawGlyf: function(gid, font, path) {
            var gl = font["glyf"][gid];
            if (gl == null) gl = font["glyf"][gid] = Typr["T"].glyf._parseGlyf(font, gid);
            if (gl != null) {
                if (gl.noc > -1) Typr["U"]["_simpleGlyph"](gl, path); else Typr["U"]["_compoGlyph"](gl, font, path);
            }
        },
        _simpleGlyph: function(gl, p) {
            var P = Typr["U"]["P"];
            for (var c = 0; c < gl.noc; c++) {
                var i0 = c == 0 ? 0 : gl.endPts[c - 1] + 1;
                var il = gl.endPts[c];
                for (var i = i0; i <= il; i++) {
                    var pr = i == i0 ? il : i - 1;
                    var nx = i == il ? i0 : i + 1;
                    var onCurve = gl.flags[i] & 1;
                    var prOnCurve = gl.flags[pr] & 1;
                    var nxOnCurve = gl.flags[nx] & 1;
                    var x = gl.xs[i], y = gl.ys[i];
                    if (i == i0) {
                        if (onCurve) {
                            if (prOnCurve) P.MoveTo(p, gl.xs[pr], gl.ys[pr]); else {
                                P.MoveTo(p, x, y);
                                continue;
                            }
                        } else {
                            if (prOnCurve) P.MoveTo(p, gl.xs[pr], gl.ys[pr]); else P.MoveTo(p, Math.floor((gl.xs[pr] + x) * .5), Math.floor((gl.ys[pr] + y) * .5));
                        }
                    }
                    if (onCurve) {
                        if (prOnCurve) P.LineTo(p, x, y);
                    } else {
                        if (nxOnCurve) P.qCurveTo(p, x, y, gl.xs[nx], gl.ys[nx]); else P.qCurveTo(p, x, y, Math.floor((x + gl.xs[nx]) * .5), Math.floor((y + gl.ys[nx]) * .5));
                    }
                }
                P.ClosePath(p);
            }
        },
        _compoGlyph: function(gl, font, p) {
            for (var j = 0; j < gl.parts.length; j++) {
                var path = {
                    cmds: [],
                    crds: []
                };
                var prt = gl.parts[j];
                Typr["U"]["_drawGlyf"](prt.glyphIndex, font, path);
                var m = prt.m;
                for (var i = 0; i < path.crds.length; i += 2) {
                    var x = path.crds[i], y = path.crds[i + 1];
                    p.crds.push(x * m.a + y * m.b + m.tx);
                    p.crds.push(x * m.c + y * m.d + m.ty);
                }
                for (var i = 0; i < path.cmds.length; i++) p.cmds.push(path.cmds[i]);
            }
        },
        pathToSVG: function(path, prec) {
            var cmds = path["cmds"], crds = path["crds"];
            if (prec == null) prec = 5;
            var out = [], co = 0, lmap = {
                M: 2,
                L: 2,
                Q: 4,
                C: 6
            };
            for (var i = 0; i < cmds.length; i++) {
                var cmd = cmds[i], cn = co + (lmap[cmd] ? lmap[cmd] : 0);
                out.push(cmd);
                while (co < cn) {
                    var c = crds[co++];
                    out.push(parseFloat(c.toFixed(prec)) + (co == cn ? "" : " "));
                }
            }
            return out.join("");
        },
        SVGToPath: function(d) {
            var pth = {
                cmds: [],
                crds: []
            };
            Typr["U"]["SVG"].svgToPath(d, pth);
            return {
                cmds: pth.cmds,
                crds: pth.crds
            };
        },
        pathToContext: function(path, ctx) {
            var c = 0, cmds = path["cmds"], crds = path["crds"];
            for (var j = 0; j < cmds.length; j++) {
                var cmd = cmds[j];
                if (cmd == "M") {
                    ctx.moveTo(crds[c], crds[c + 1]);
                    c += 2;
                } else if (cmd == "L") {
                    ctx.lineTo(crds[c], crds[c + 1]);
                    c += 2;
                } else if (cmd == "C") {
                    ctx.bezierCurveTo(crds[c], crds[c + 1], crds[c + 2], crds[c + 3], crds[c + 4], crds[c + 5]);
                    c += 6;
                } else if (cmd == "Q") {
                    ctx.quadraticCurveTo(crds[c], crds[c + 1], crds[c + 2], crds[c + 3]);
                    c += 4;
                } else if (cmd.charAt(0) == "#") {
                    ctx.beginPath();
                    ctx.fillStyle = cmd;
                } else if (cmd == "Z") {
                    ctx.closePath();
                } else if (cmd == "X") {
                    ctx.fill();
                }
            }
        },
        P: {
            MoveTo: function(p, x, y) {
                p.cmds.push("M");
                p.crds.push(x, y);
            },
            LineTo: function(p, x, y) {
                p.cmds.push("L");
                p.crds.push(x, y);
            },
            CurveTo: function(p, a, b, c, d, e, f) {
                p.cmds.push("C");
                p.crds.push(a, b, c, d, e, f);
            },
            qCurveTo: function(p, a, b, c, d) {
                p.cmds.push("Q");
                p.crds.push(a, b, c, d);
            },
            ClosePath: function(p) {
                p.cmds.push("Z");
            }
        },
        _drawCFF: function(cmds, state, font, pdct, p) {
            var stack = state.stack;
            var nStems = state.nStems, haveWidth = state.haveWidth, width = state.width, open = state.open;
            var i = 0;
            var x = state.x, y = state.y, c1x = 0, c1y = 0, c2x = 0, c2y = 0, c3x = 0, c3y = 0, c4x = 0, c4y = 0, jpx = 0, jpy = 0;
            var CFF = Typr["T"].CFF, P = Typr["U"]["P"];
            var nominalWidthX = pdct["nominalWidthX"];
            var o = {
                val: 0,
                size: 0
            };
            while (i < cmds.length) {
                CFF.getCharString(cmds, i, o);
                var v = o.val;
                i += o.size;
                if (v == "o1" || v == "o18") {
                    var hasWidthArg;
                    hasWidthArg = stack.length % 2 !== 0;
                    if (hasWidthArg && !haveWidth) {
                        width = stack.shift() + nominalWidthX;
                    }
                    nStems += stack.length >> 1;
                    stack.length = 0;
                    haveWidth = true;
                } else if (v == "o3" || v == "o23") {
                    var hasWidthArg;
                    hasWidthArg = stack.length % 2 !== 0;
                    if (hasWidthArg && !haveWidth) {
                        width = stack.shift() + nominalWidthX;
                    }
                    nStems += stack.length >> 1;
                    stack.length = 0;
                    haveWidth = true;
                } else if (v == "o4") {
                    if (stack.length > 1 && !haveWidth) {
                        width = stack.shift() + nominalWidthX;
                        haveWidth = true;
                    }
                    if (open) P.ClosePath(p);
                    y += stack.pop();
                    P.MoveTo(p, x, y);
                    open = true;
                } else if (v == "o5") {
                    while (stack.length > 0) {
                        x += stack.shift();
                        y += stack.shift();
                        P.LineTo(p, x, y);
                    }
                } else if (v == "o6" || v == "o7") {
                    var count = stack.length;
                    var isX = v == "o6";
                    for (var j = 0; j < count; j++) {
                        var sval = stack.shift();
                        if (isX) x += sval; else y += sval;
                        isX = !isX;
                        P.LineTo(p, x, y);
                    }
                } else if (v == "o8" || v == "o24") {
                    var count = stack.length;
                    var index = 0;
                    while (index + 6 <= count) {
                        c1x = x + stack.shift();
                        c1y = y + stack.shift();
                        c2x = c1x + stack.shift();
                        c2y = c1y + stack.shift();
                        x = c2x + stack.shift();
                        y = c2y + stack.shift();
                        P.CurveTo(p, c1x, c1y, c2x, c2y, x, y);
                        index += 6;
                    }
                    if (v == "o24") {
                        x += stack.shift();
                        y += stack.shift();
                        P.LineTo(p, x, y);
                    }
                } else if (v == "o11") break; else if (v == "o1234" || v == "o1235" || v == "o1236" || v == "o1237") {
                    if (v == "o1234") {
                        c1x = x + stack.shift();
                        c1y = y;
                        c2x = c1x + stack.shift();
                        c2y = c1y + stack.shift();
                        jpx = c2x + stack.shift();
                        jpy = c2y;
                        c3x = jpx + stack.shift();
                        c3y = c2y;
                        c4x = c3x + stack.shift();
                        c4y = y;
                        x = c4x + stack.shift();
                        P.CurveTo(p, c1x, c1y, c2x, c2y, jpx, jpy);
                        P.CurveTo(p, c3x, c3y, c4x, c4y, x, y);
                    }
                    if (v == "o1235") {
                        c1x = x + stack.shift();
                        c1y = y + stack.shift();
                        c2x = c1x + stack.shift();
                        c2y = c1y + stack.shift();
                        jpx = c2x + stack.shift();
                        jpy = c2y + stack.shift();
                        c3x = jpx + stack.shift();
                        c3y = jpy + stack.shift();
                        c4x = c3x + stack.shift();
                        c4y = c3y + stack.shift();
                        x = c4x + stack.shift();
                        y = c4y + stack.shift();
                        stack.shift();
                        P.CurveTo(p, c1x, c1y, c2x, c2y, jpx, jpy);
                        P.CurveTo(p, c3x, c3y, c4x, c4y, x, y);
                    }
                    if (v == "o1236") {
                        c1x = x + stack.shift();
                        c1y = y + stack.shift();
                        c2x = c1x + stack.shift();
                        c2y = c1y + stack.shift();
                        jpx = c2x + stack.shift();
                        jpy = c2y;
                        c3x = jpx + stack.shift();
                        c3y = c2y;
                        c4x = c3x + stack.shift();
                        c4y = c3y + stack.shift();
                        x = c4x + stack.shift();
                        P.CurveTo(p, c1x, c1y, c2x, c2y, jpx, jpy);
                        P.CurveTo(p, c3x, c3y, c4x, c4y, x, y);
                    }
                    if (v == "o1237") {
                        c1x = x + stack.shift();
                        c1y = y + stack.shift();
                        c2x = c1x + stack.shift();
                        c2y = c1y + stack.shift();
                        jpx = c2x + stack.shift();
                        jpy = c2y + stack.shift();
                        c3x = jpx + stack.shift();
                        c3y = jpy + stack.shift();
                        c4x = c3x + stack.shift();
                        c4y = c3y + stack.shift();
                        if (Math.abs(c4x - x) > Math.abs(c4y - y)) {
                            x = c4x + stack.shift();
                        } else {
                            y = c4y + stack.shift();
                        }
                        P.CurveTo(p, c1x, c1y, c2x, c2y, jpx, jpy);
                        P.CurveTo(p, c3x, c3y, c4x, c4y, x, y);
                    }
                } else if (v == "o14") {
                    if (stack.length > 0 && !haveWidth) {
                        width = stack.shift() + font["nominalWidthX"];
                        haveWidth = true;
                    }
                    if (stack.length == 4) {
                        var adx = stack.shift();
                        var ady = stack.shift();
                        var bchar = stack.shift();
                        var achar = stack.shift();
                        var bind = CFF.glyphBySE(font, bchar);
                        var aind = CFF.glyphBySE(font, achar);
                        Typr["U"]["_drawCFF"](font["CharStrings"][bind], state, font, pdct, p);
                        state.x = adx;
                        state.y = ady;
                        Typr["U"]["_drawCFF"](font["CharStrings"][aind], state, font, pdct, p);
                    }
                    if (open) {
                        P.ClosePath(p);
                        open = false;
                    }
                } else if (v == "o19" || v == "o20") {
                    var hasWidthArg;
                    hasWidthArg = stack.length % 2 !== 0;
                    if (hasWidthArg && !haveWidth) {
                        width = stack.shift() + nominalWidthX;
                    }
                    nStems += stack.length >> 1;
                    stack.length = 0;
                    haveWidth = true;
                    i += nStems + 7 >> 3;
                } else if (v == "o21") {
                    if (stack.length > 2 && !haveWidth) {
                        width = stack.shift() + nominalWidthX;
                        haveWidth = true;
                    }
                    y += stack.pop();
                    x += stack.pop();
                    if (open) P.ClosePath(p);
                    P.MoveTo(p, x, y);
                    open = true;
                } else if (v == "o22") {
                    if (stack.length > 1 && !haveWidth) {
                        width = stack.shift() + nominalWidthX;
                        haveWidth = true;
                    }
                    x += stack.pop();
                    if (open) P.ClosePath(p);
                    P.MoveTo(p, x, y);
                    open = true;
                } else if (v == "o25") {
                    while (stack.length > 6) {
                        x += stack.shift();
                        y += stack.shift();
                        P.LineTo(p, x, y);
                    }
                    c1x = x + stack.shift();
                    c1y = y + stack.shift();
                    c2x = c1x + stack.shift();
                    c2y = c1y + stack.shift();
                    x = c2x + stack.shift();
                    y = c2y + stack.shift();
                    P.CurveTo(p, c1x, c1y, c2x, c2y, x, y);
                } else if (v == "o26") {
                    if (stack.length % 2) {
                        x += stack.shift();
                    }
                    while (stack.length > 0) {
                        c1x = x;
                        c1y = y + stack.shift();
                        c2x = c1x + stack.shift();
                        c2y = c1y + stack.shift();
                        x = c2x;
                        y = c2y + stack.shift();
                        P.CurveTo(p, c1x, c1y, c2x, c2y, x, y);
                    }
                } else if (v == "o27") {
                    if (stack.length % 2) {
                        y += stack.shift();
                    }
                    while (stack.length > 0) {
                        c1x = x + stack.shift();
                        c1y = y;
                        c2x = c1x + stack.shift();
                        c2y = c1y + stack.shift();
                        x = c2x + stack.shift();
                        y = c2y;
                        P.CurveTo(p, c1x, c1y, c2x, c2y, x, y);
                    }
                } else if (v == "o10" || v == "o29") {
                    var obj = v == "o10" ? pdct : font;
                    if (stack.length == 0) {
                        console.log("error: empty stack");
                    } else {
                        var ind = stack.pop();
                        var subr = obj["Subrs"][ind + obj["Bias"]];
                        state.x = x;
                        state.y = y;
                        state.nStems = nStems;
                        state.haveWidth = haveWidth;
                        state.width = width;
                        state.open = open;
                        Typr["U"]["_drawCFF"](subr, state, font, pdct, p);
                        x = state.x;
                        y = state.y;
                        nStems = state.nStems;
                        haveWidth = state.haveWidth;
                        width = state.width;
                        open = state.open;
                    }
                } else if (v == "o30" || v == "o31") {
                    var count, count1 = stack.length;
                    var index = 0;
                    var alternate = v == "o31";
                    count = count1 & ~2;
                    index += count1 - count;
                    while (index < count) {
                        if (alternate) {
                            c1x = x + stack.shift();
                            c1y = y;
                            c2x = c1x + stack.shift();
                            c2y = c1y + stack.shift();
                            y = c2y + stack.shift();
                            if (count - index == 5) {
                                x = c2x + stack.shift();
                                index++;
                            } else x = c2x;
                            alternate = false;
                        } else {
                            c1x = x;
                            c1y = y + stack.shift();
                            c2x = c1x + stack.shift();
                            c2y = c1y + stack.shift();
                            x = c2x + stack.shift();
                            if (count - index == 5) {
                                y = c2y + stack.shift();
                                index++;
                            } else y = c2y;
                            alternate = true;
                        }
                        P.CurveTo(p, c1x, c1y, c2x, c2y, x, y);
                        index += 4;
                    }
                } else if ((v + "").charAt(0) == "o") {
                    console.log("Unknown operation: " + v, cmds);
                    throw v;
                } else stack.push(v);
            }
            state.x = x;
            state.y = y;
            state.nStems = nStems;
            state.haveWidth = haveWidth;
            state.width = width;
            state.open = open;
        },
        SVG: function() {
            var M = {
                getScale: function(m) {
                    return Math.sqrt(Math.abs(m[0] * m[3] - m[1] * m[2]));
                },
                translate: function(m, x, y) {
                    M.concat(m, [ 1, 0, 0, 1, x, y ]);
                },
                rotate: function(m, a) {
                    M.concat(m, [ Math.cos(a), -Math.sin(a), Math.sin(a), Math.cos(a), 0, 0 ]);
                },
                scale: function(m, x, y) {
                    M.concat(m, [ x, 0, 0, y, 0, 0 ]);
                },
                concat: function(m, w) {
                    var a = m[0], b = m[1], c = m[2], d = m[3], tx = m[4], ty = m[5];
                    m[0] = a * w[0] + b * w[2];
                    m[1] = a * w[1] + b * w[3];
                    m[2] = c * w[0] + d * w[2];
                    m[3] = c * w[1] + d * w[3];
                    m[4] = tx * w[0] + ty * w[2] + w[4];
                    m[5] = tx * w[1] + ty * w[3] + w[5];
                },
                invert: function(m) {
                    var a = m[0], b = m[1], c = m[2], d = m[3], tx = m[4], ty = m[5], adbc = a * d - b * c;
                    m[0] = d / adbc;
                    m[1] = -b / adbc;
                    m[2] = -c / adbc;
                    m[3] = a / adbc;
                    m[4] = (c * ty - d * tx) / adbc;
                    m[5] = (b * tx - a * ty) / adbc;
                },
                multPoint: function(m, p) {
                    var x = p[0], y = p[1];
                    return [ x * m[0] + y * m[2] + m[4], x * m[1] + y * m[3] + m[5] ];
                },
                multArray: function(m, a) {
                    for (var i = 0; i < a.length; i += 2) {
                        var x = a[i], y = a[i + 1];
                        a[i] = x * m[0] + y * m[2] + m[4];
                        a[i + 1] = x * m[1] + y * m[3] + m[5];
                    }
                }
            };
            function _bracketSplit(str, lbr, rbr) {
                var out = [], pos = 0, ci = 0, lvl = 0;
                while (true) {
                    var li = str.indexOf(lbr, ci);
                    var ri = str.indexOf(rbr, ci);
                    if (li == -1 && ri == -1) break;
                    if (ri == -1 || li != -1 && li < ri) {
                        if (lvl == 0) {
                            out.push(str.slice(pos, li).trim());
                            pos = li + 1;
                        }
                        lvl++;
                        ci = li + 1;
                    } else if (li == -1 || ri != -1 && ri < li) {
                        lvl--;
                        if (lvl == 0) {
                            out.push(str.slice(pos, ri).trim());
                            pos = ri + 1;
                        }
                        ci = ri + 1;
                    }
                }
                return out;
            }
            function cssMap(str) {
                var pts = _bracketSplit(str, "{", "}");
                var css = {};
                for (var i = 0; i < pts.length; i += 2) {
                    var cn = pts[i].split(",");
                    for (var j = 0; j < cn.length; j++) {
                        var cnj = cn[j].trim();
                        if (css[cnj] == null) css[cnj] = "";
                        css[cnj] += pts[i + 1];
                    }
                }
                return css;
            }
            function readTrnf(trna) {
                var pts = _bracketSplit(trna, "(", ")");
                var m = [ 1, 0, 0, 1, 0, 0 ];
                for (var i = 0; i < pts.length; i += 2) {
                    var om = m;
                    m = _readTrnsAttr(pts[i], pts[i + 1]);
                    M.concat(m, om);
                }
                return m;
            }
            function _readTrnsAttr(fnc, vls) {
                var m = [ 1, 0, 0, 1, 0, 0 ], gotSep = true;
                for (var i = 0; i < vls.length; i++) {
                    var ch = vls.charAt(i);
                    if (ch == "," || ch == " ") gotSep = true; else if (ch == ".") {
                        if (!gotSep) {
                            vls = vls.slice(0, i) + "," + vls.slice(i);
                            i++;
                        }
                        gotSep = false;
                    } else if (ch == "-" && i > 0 && vls[i - 1] != "e") {
                        vls = vls.slice(0, i) + " " + vls.slice(i);
                        i++;
                        gotSep = true;
                    }
                }
                vls = vls.split(/\s*[\s,]\s*/).map(parseFloat);
                if (fnc == "translate") {
                    if (vls.length == 1) M.translate(m, vls[0], 0); else M.translate(m, vls[0], vls[1]);
                } else if (fnc == "scale") {
                    if (vls.length == 1) M.scale(m, vls[0], vls[0]); else M.scale(m, vls[0], vls[1]);
                } else if (fnc == "rotate") {
                    var tx = 0, ty = 0;
                    if (vls.length != 1) {
                        tx = vls[1];
                        ty = vls[2];
                    }
                    M.translate(m, -tx, -ty);
                    M.rotate(m, -Math.PI * vls[0] / 180);
                    M.translate(m, tx, ty);
                } else if (fnc == "matrix") m = vls; else console.log("unknown transform: ", fnc);
                return m;
            }
            function toPath(str) {
                var pth = {
                    cmds: [],
                    crds: []
                };
                if (str == null) return pth;
                var prsr = new DOMParser();
                var doc = prsr["parseFromString"](str, "image/svg+xml");
                var svg = doc.getElementsByTagName("svg")[0];
                var vb = svg.getAttribute("viewBox");
                if (vb) vb = vb.trim().split(" ").map(parseFloat); else vb = [ 0, 0, 1e3, 1e3 ];
                _toPath(svg.children, pth);
                for (var i = 0; i < pth.crds.length; i += 2) {
                    var x = pth.crds[i], y = pth.crds[i + 1];
                    x -= vb[0];
                    y -= vb[1];
                    y = -y;
                    pth.crds[i] = x;
                    pth.crds[i + 1] = y;
                }
                return pth;
            }
            function _toPath(nds, pth, fill) {
                for (var ni = 0; ni < nds.length; ni++) {
                    var nd = nds[ni], tn = nd.tagName;
                    var cfl = nd.getAttribute("fill");
                    if (cfl == null) cfl = fill;
                    if (tn == "g") {
                        var tp = {
                            crds: [],
                            cmds: []
                        };
                        _toPath(nd.children, tp, cfl);
                        var trf = nd.getAttribute("transform");
                        if (trf) {
                            var m = readTrnf(trf);
                            M.multArray(m, tp.crds);
                        }
                        pth.crds = pth.crds.concat(tp.crds);
                        pth.cmds = pth.cmds.concat(tp.cmds);
                    } else if (tn == "path" || tn == "circle" || tn == "ellipse") {
                        pth.cmds.push(cfl ? cfl : "#000000");
                        var d;
                        if (tn == "path") d = nd.getAttribute("d");
                        if (tn == "circle" || tn == "ellipse") {
                            var vls = [ 0, 0, 0, 0 ], nms = [ "cx", "cy", "rx", "ry", "r" ];
                            for (var i = 0; i < 5; i++) {
                                var V = nd.getAttribute(nms[i]);
                                if (V) {
                                    V = parseFloat(V);
                                    if (i < 4) vls[i] = V; else vls[2] = vls[3] = V;
                                }
                            }
                            var cx = vls[0], cy = vls[1], rx = vls[2], ry = vls[3];
                            d = [ "M", cx - rx, cy, "a", rx, ry, 0, 1, 0, rx * 2, 0, "a", rx, ry, 0, 1, 0, -rx * 2, 0 ].join(" ");
                        }
                        svgToPath(d, pth);
                        pth.cmds.push("X");
                    } else if (tn == "defs"); else console.log(tn, nd);
                }
            }
            function _tokens(d) {
                var ts = [], off = 0, rn = false, cn = "", pc = "";
                while (off < d.length) {
                    var cc = d.charCodeAt(off), ch = d.charAt(off);
                    off++;
                    var isNum = 48 <= cc && cc <= 57 || ch == "." || ch == "-" || ch == "e" || ch == "E";
                    if (rn) {
                        if (ch == "-" && pc != "e" || ch == "." && cn.indexOf(".") != -1) {
                            ts.push(parseFloat(cn));
                            cn = ch;
                        } else if (isNum) cn += ch; else {
                            ts.push(parseFloat(cn));
                            if (ch != "," && ch != " ") ts.push(ch);
                            rn = false;
                        }
                    } else {
                        if (isNum) {
                            cn = ch;
                            rn = true;
                        } else if (ch != "," && ch != " ") ts.push(ch);
                    }
                    pc = ch;
                }
                if (rn) ts.push(parseFloat(cn));
                return ts;
            }
            function _reps(ts, off, ps) {
                var i = off;
                while (i < ts.length) {
                    if (typeof ts[i] == "string") break;
                    i += ps;
                }
                return (i - off) / ps;
            }
            function svgToPath(d, pth) {
                var ts = _tokens(d);
                var i = 0, x = 0, y = 0, ox = 0, oy = 0, oldo = pth.crds.length;
                var pc = {
                    M: 2,
                    L: 2,
                    H: 1,
                    V: 1,
                    T: 2,
                    S: 4,
                    A: 7,
                    Q: 4,
                    C: 6
                };
                var cmds = pth.cmds, crds = pth.crds;
                while (i < ts.length) {
                    var cmd = ts[i];
                    i++;
                    var cmu = cmd.toUpperCase();
                    if (cmu == "Z") {
                        cmds.push("Z");
                        x = ox;
                        y = oy;
                    } else {
                        var ps = pc[cmu], reps = _reps(ts, i, ps);
                        for (var j = 0; j < reps; j++) {
                            if (j == 1 && cmu == "M") {
                                cmd = cmd == cmu ? "L" : "l";
                                cmu = "L";
                            }
                            var xi = 0, yi = 0;
                            if (cmd != cmu) {
                                xi = x;
                                yi = y;
                            }
                            if (cmu == "M") {
                                x = xi + ts[i++];
                                y = yi + ts[i++];
                                cmds.push("M");
                                crds.push(x, y);
                                ox = x;
                                oy = y;
                            } else if (cmu == "L") {
                                x = xi + ts[i++];
                                y = yi + ts[i++];
                                cmds.push("L");
                                crds.push(x, y);
                            } else if (cmu == "H") {
                                x = xi + ts[i++];
                                cmds.push("L");
                                crds.push(x, y);
                            } else if (cmu == "V") {
                                y = yi + ts[i++];
                                cmds.push("L");
                                crds.push(x, y);
                            } else if (cmu == "Q") {
                                var x1 = xi + ts[i++], y1 = yi + ts[i++], x2 = xi + ts[i++], y2 = yi + ts[i++];
                                cmds.push("Q");
                                crds.push(x1, y1, x2, y2);
                                x = x2;
                                y = y2;
                            } else if (cmu == "T") {
                                var co = Math.max(crds.length - 2, oldo);
                                var x1 = x + x - crds[co], y1 = y + y - crds[co + 1];
                                var x2 = xi + ts[i++], y2 = yi + ts[i++];
                                cmds.push("Q");
                                crds.push(x1, y1, x2, y2);
                                x = x2;
                                y = y2;
                            } else if (cmu == "C") {
                                var x1 = xi + ts[i++], y1 = yi + ts[i++], x2 = xi + ts[i++], y2 = yi + ts[i++], x3 = xi + ts[i++], y3 = yi + ts[i++];
                                cmds.push("C");
                                crds.push(x1, y1, x2, y2, x3, y3);
                                x = x3;
                                y = y3;
                            } else if (cmu == "S") {
                                var co = Math.max(crds.length - (cmds[cmds.length - 1] == "C" ? 4 : 2), oldo);
                                var x1 = x + x - crds[co], y1 = y + y - crds[co + 1];
                                var x2 = xi + ts[i++], y2 = yi + ts[i++], x3 = xi + ts[i++], y3 = yi + ts[i++];
                                cmds.push("C");
                                crds.push(x1, y1, x2, y2, x3, y3);
                                x = x3;
                                y = y3;
                            } else if (cmu == "A") {
                                var x1 = x, y1 = y;
                                var rx = ts[i++], ry = ts[i++];
                                var phi = ts[i++] * (Math.PI / 180), fA = ts[i++], fS = ts[i++];
                                var x2 = xi + ts[i++], y2 = yi + ts[i++];
                                if (x2 == x && y2 == y && rx == 0 && ry == 0) continue;
                                var hdx = (x1 - x2) / 2, hdy = (y1 - y2) / 2;
                                var cosP = Math.cos(phi), sinP = Math.sin(phi);
                                var x1A = cosP * hdx + sinP * hdy;
                                var y1A = -sinP * hdx + cosP * hdy;
                                var rxS = rx * rx, ryS = ry * ry;
                                var x1AS = x1A * x1A, y1AS = y1A * y1A;
                                var frc = (rxS * ryS - rxS * y1AS - ryS * x1AS) / (rxS * y1AS + ryS * x1AS);
                                var coef = (fA != fS ? 1 : -1) * Math.sqrt(Math.max(frc, 0));
                                var cxA = coef * (rx * y1A) / ry;
                                var cyA = -coef * (ry * x1A) / rx;
                                var cx = cosP * cxA - sinP * cyA + (x1 + x2) / 2;
                                var cy = sinP * cxA + cosP * cyA + (y1 + y2) / 2;
                                var angl = function(ux, uy, vx, vy) {
                                    var lU = Math.sqrt(ux * ux + uy * uy), lV = Math.sqrt(vx * vx + vy * vy);
                                    var num = (ux * vx + uy * vy) / (lU * lV);
                                    return (ux * vy - uy * vx >= 0 ? 1 : -1) * Math.acos(Math.max(-1, Math.min(1, num)));
                                };
                                var vX = (x1A - cxA) / rx, vY = (y1A - cyA) / ry;
                                var theta1 = angl(1, 0, vX, vY);
                                var dtheta = angl(vX, vY, (-x1A - cxA) / rx, (-y1A - cyA) / ry);
                                dtheta = dtheta % (2 * Math.PI);
                                var arc = function(gst, x, y, r, a0, a1, neg) {
                                    var rotate = function(m, a) {
                                        var si = Math.sin(a), co = Math.cos(a);
                                        var a = m[0], b = m[1], c = m[2], d = m[3];
                                        m[0] = a * co + b * si;
                                        m[1] = -a * si + b * co;
                                        m[2] = c * co + d * si;
                                        m[3] = -c * si + d * co;
                                    };
                                    var multArr = function(m, a) {
                                        for (var j = 0; j < a.length; j += 2) {
                                            var x = a[j], y = a[j + 1];
                                            a[j] = m[0] * x + m[2] * y + m[4];
                                            a[j + 1] = m[1] * x + m[3] * y + m[5];
                                        }
                                    };
                                    var concatA = function(a, b) {
                                        for (var j = 0; j < b.length; j++) a.push(b[j]);
                                    };
                                    var concatP = function(p, r) {
                                        concatA(p.cmds, r.cmds);
                                        concatA(p.crds, r.crds);
                                    };
                                    if (neg) while (a1 > a0) a1 -= 2 * Math.PI; else while (a1 < a0) a1 += 2 * Math.PI;
                                    var th = (a1 - a0) / 4;
                                    var x0 = Math.cos(th / 2), y0 = -Math.sin(th / 2);
                                    var x1 = (4 - x0) / 3, y1 = y0 == 0 ? y0 : (1 - x0) * (3 - x0) / (3 * y0);
                                    var x2 = x1, y2 = -y1;
                                    var x3 = x0, y3 = -y0;
                                    var ps = [ x1, y1, x2, y2, x3, y3 ];
                                    var pth = {
                                        cmds: [ "C", "C", "C", "C" ],
                                        crds: ps.slice(0)
                                    };
                                    var rot = [ 1, 0, 0, 1, 0, 0 ];
                                    rotate(rot, -th);
                                    for (var j = 0; j < 3; j++) {
                                        multArr(rot, ps);
                                        concatA(pth.crds, ps);
                                    }
                                    rotate(rot, -a0 + th / 2);
                                    rot[0] *= r;
                                    rot[1] *= r;
                                    rot[2] *= r;
                                    rot[3] *= r;
                                    rot[4] = x;
                                    rot[5] = y;
                                    multArr(rot, pth.crds);
                                    multArr(gst.ctm, pth.crds);
                                    concatP(gst.pth, pth);
                                };
                                var gst = {
                                    pth: pth,
                                    ctm: [ rx * cosP, rx * sinP, -ry * sinP, ry * cosP, cx, cy ]
                                };
                                arc(gst, 0, 0, 1, theta1, theta1 + dtheta, fS == 0);
                                x = x2;
                                y = y2;
                            } else console.log("Unknown SVG command " + cmd);
                        }
                    }
                }
            }
            return {
                cssMap: cssMap,
                readTrnf: readTrnf,
                svgToPath: svgToPath,
                toPath: toPath
            };
        }(),
        initHB: function(hurl, resp) {
            var codeLength = function(code) {
                var len = 0;
                if ((code & 4294967295 - (1 << 7) + 1) == 0) {
                    len = 1;
                } else if ((code & 4294967295 - (1 << 11) + 1) == 0) {
                    len = 2;
                } else if ((code & 4294967295 - (1 << 16) + 1) == 0) {
                    len = 3;
                } else if ((code & 4294967295 - (1 << 21) + 1) == 0) {
                    len = 4;
                }
                return len;
            };
            var te = new window["TextEncoder"]("utf8");
            fetch(hurl).then(function(x) {
                return x["arrayBuffer"]();
            }).then(function(ab) {
                return WebAssembly["instantiate"](ab);
            }).then(function(res) {
                console.log("HB ready");
                var exp = res["instance"]["exports"], mem = exp["memory"];
                mem["grow"](700);
                var heapu8 = new Uint8Array(mem.buffer);
                var u32 = new Uint32Array(mem.buffer);
                var i32 = new Int32Array(mem.buffer);
                var __lastFnt, blob, blobPtr, face, font;
                Typr["U"]["shapeHB"] = function() {
                    var toJson = function(ptr) {
                        var length = exp["hb_buffer_get_length"](ptr);
                        var result = [];
                        var iPtr32 = exp["hb_buffer_get_glyph_infos"](ptr, 0) >>> 2;
                        var pPtr32 = exp["hb_buffer_get_glyph_positions"](ptr, 0) >>> 2;
                        for (var i = 0; i < length; ++i) {
                            var a = iPtr32 + i * 5, b = pPtr32 + i * 5;
                            result.push({
                                g: u32[a + 0],
                                cl: u32[a + 2],
                                ax: i32[b + 0],
                                ay: i32[b + 1],
                                dx: i32[b + 2],
                                dy: i32[b + 3]
                            });
                        }
                        return result;
                    };
                    return function(fnt, str, ltr) {
                        var fdata = fnt["_data"], fn = fnt["name"]["postScriptName"];
                        if (__lastFnt != fn) {
                            if (blob != null) {
                                exp["hb_blob_destroy"](blob);
                                exp["free"](blobPtr);
                                exp["hb_face_destroy"](face);
                                exp["hb_font_destroy"](font);
                            }
                            blobPtr = exp["malloc"](fdata.byteLength);
                            heapu8.set(fdata, blobPtr);
                            blob = exp["hb_blob_create"](blobPtr, fdata.byteLength, 2, 0, 0);
                            face = exp["hb_face_create"](blob, 0);
                            font = exp["hb_font_create"](face);
                            __lastFnt = fn;
                        }
                        var buffer = exp["hb_buffer_create"]();
                        var bytes = te["encode"](str);
                        var len = bytes.length, strp = exp["malloc"](len);
                        heapu8.set(bytes, strp);
                        exp["hb_buffer_add_utf8"](buffer, strp, len, 0, len);
                        exp["free"](strp);
                        exp["hb_buffer_set_direction"](buffer, ltr ? 4 : 5);
                        exp["hb_buffer_guess_segment_properties"](buffer);
                        exp["hb_shape"](font, buffer, 0, 0);
                        var json = toJson(buffer);
                        exp["hb_buffer_destroy"](buffer);
                        var arr = json.slice(0);
                        if (!ltr) arr.reverse();
                        var ci = 0, bi = 0;
                        for (var i = 1; i < arr.length; i++) {
                            var gl = arr[i], cl = gl["cl"];
                            while (true) {
                                var cpt = str.codePointAt(ci), cln = codeLength(cpt);
                                if (bi + cln <= cl) {
                                    bi += cln;
                                    ci += cpt <= 65535 ? 1 : 2;
                                } else break;
                            }
                            gl["cl"] = ci;
                        }
                        return json;
                    };
                }();
                resp();
            });
        }
    };
    function init() {
        rule = rwl_userData.rules.rule_def;
        hook_eventNames = rule.hook_eventNames.split("|");
        unhook_eventNames = rule.unhook_eventNames.split("|");
        eventNames = hook_eventNames.concat(unhook_eventNames);
        if (rule.dom0) {
            setInterval(clearLoop, 10 * 1e3);
            setTimeout(clearLoop, 1500);
            window.addEventListener("load", clearLoop, true);
            clearLoop();
        }
        if (rule.hook_addEventListener) {
            EventTarget.prototype.addEventListener = addEventListener;
            document.addEventListener = addEventListener;
            if (hasFrame) {
                for (let i = 0; i < hasFrame.length; i++) {
                    hasFrame[i].contentWindow.document.addEventListener = addEventListener;
                }
            }
        }
        if (rule.hook_preventDefault) {
            Event.prototype.preventDefault = function() {
                if (hook_eventNames.indexOf(this.type) < 0) {
                    Event_preventDefault.apply(this, arguments);
                }
            };
            if (hasFrame) {
                for (let i = 0; i < hasFrame.length; i++) {
                    hasFrame[i].contentWindow.Event.prototype.preventDefault = function() {
                        if (hook_eventNames.indexOf(this.type) < 0) {
                            Event_preventDefault.apply(this, arguments);
                        }
                    };
                }
            }
        }
        if (rule.hook_set_returnValue) {
            Event.prototype.__defineSetter__("returnValue", function() {
                if (this.returnValue !== true && hook_eventNames.indexOf(this.type) >= 0) {
                    this.returnValue = true;
                }
            });
        }
    }
    function addEventListener(type, func, useCapture) {
        var _addEventListener = this === document ? document_addEventListener : EventTarget_addEventListener;
        if (hook_eventNames.indexOf(type) >= 0) {
            _addEventListener.apply(this, [ type, returnTrue, useCapture ]);
        } else if (unhook_eventNames.indexOf(type) >= 0) {
            var funcsName = storageName + type + (useCapture ? "t" : "f");
            if (this[funcsName] === undefined) {
                this[funcsName] = [];
                _addEventListener.apply(this, [ type, useCapture ? unhook_t : unhook_f, useCapture ]);
            }
            this[funcsName].push(func);
        } else {
            _addEventListener.apply(this, arguments);
        }
    }
    function clearLoop() {
        var elements = getElements();
        for (var i in elements) {
            for (var j in eventNames) {
                var name = "on" + eventNames[j];
                if (Object.prototype.toString.call(elements[i]) == "[object String]") {
                    continue;
                }
                if (elements[i][name] !== null && elements[i][name] !== onxxx) {
                    if (unhook_eventNames.indexOf(eventNames[j]) >= 0) {
                        elements[i][storageName + name] = elements[i][name];
                        elements[i][name] = onxxx;
                    } else {
                        elements[i][name] = null;
                    }
                }
            }
        }
        document.onmousedown = function() {
            return true;
        };
    }
    function returnTrue(e) {
        return true;
    }
    function unhook_t(e) {
        return unhook(e, this, storageName + e.type + "t");
    }
    function unhook_f(e) {
        return unhook(e, this, storageName + e.type + "f");
    }
    function unhook(e, self, funcsName) {
        var list = self[funcsName];
        for (var i in list) {
            list[i](e);
        }
        e.returnValue = true;
        return true;
    }
    function onxxx(e) {
        var name = storageName + "on" + e.type;
        this[name](e);
        e.returnValue = true;
        return true;
    }
    function getElements() {
        var elements = Array.prototype.slice.call(document.getElementsByTagName("*"));
        elements.push(document);
        var frames = document.querySelectorAll("frame");
        if (frames) {
            hasFrame = frames;
            var frames_element;
            for (let i = 0; i < frames.length; i++) {
                frames_element = Array.prototype.slice.call(frames[i].contentWindow.document.querySelectorAll("*"));
                elements.push(frames[i].contentWindow.document);
                elements = elements.concat(frames_element);
            }
        }
        return elements;
    }
    var settingData = {
        status: 1,
        version: .1,
        message: "",
        positionTop: "0",
        positionLeft: "0",
        positionRight: "auto",
        addBtn: false,
        connectToTheServer: false,
        waitUpload: [],
        currentURL: "null",
        shortcut: 3,
        rules: {},
        data: []
    };
    var rwl_userData = null;
    var rule = null;
    var hasFrame = false;
    var storageName = "storageName";
    var hook_eventNames, unhook_eventNames, eventNames;
    var EventTarget_addEventListener = EventTarget.prototype.addEventListener;
    var document_addEventListener = document.addEventListener;
    var Event_preventDefault = Event.prototype.preventDefault;
    rwl_userData = GM_getValue("rwl_userData");
    if (!rwl_userData) {
        rwl_userData = settingData;
    }
    for (let value in settingData) {
        if (!rwl_userData.hasOwnProperty(value)) {
            rwl_userData[value] = settingData[value];
            GM_setValue("rwl_userData", rwl_userData);
        }
    }
    // 隐藏平台自带的 AI 助手面板
    function hidePlatformAI() {
        // 样式只注入一次；下面的 DOM 兜底每次都得跑（平台的面板常是懒渲染的）。
        // 原来 early return 在函数最上面，样式建好之后整个函数就 no-op 了 ——
        // 于是 500ms 那个循环从第二次起什么都不做，只在页面刚起来时扫过一遍。
        if (!top.document.getElementById('hide-platform-ai-style')) {
            const style = top.document.createElement('style');
            style.id = 'hide-platform-ai-style';
            // 这一整串是一个逗号选择器列表，共用下面那一个 { }。
            // 末尾原来还有两条 `div[class*="ai"]:has(span:contains("AI智能助手"))` ——
            // :contains() 不是 CSS 选择器（CSS3 草案里有过，被删了，只有 jQuery 有）。
            // 顶层选择器列表不容错（只有 :is()/:where() 里才容错），列表里有一个无效，
            // 浏览器就把整条规则丢掉：下面这 30 多个选择器一条都没生效过，
            // 「隐藏平台自带 AI 助手」这个功能从来是空转的。验证过：带那两条时
            // style.sheet.cssRules.length 是 0，去掉后是 1。
            style.textContent = `
            /* 隐藏学习通/超星平台自带的 AI 助手 */
            .ai-assistant-container,
            .ai-assistant-wrapper,
            .study-ai-panel,
            .studyAI,
            .ai-chat-container,
            .ai-robot-container,
            .robot-container,
            .cx-ai-container,
            .cx-ai-panel,
            .cxAiChat,
            .ai-dialogue,
            .ai-dialog-container,
            [class*="studyAi"],
            [class*="StudyAi"],
            [class*="aiAssistant"],
            [class*="AiAssistant"],
            [class*="ai-helper"],
            [class*="robotAi"],
            [class*="cxAi"],
            [class*="CxAi"],
            [class*="ernie"],
            [class*="Ernie"],
            #studyAiContainer,
            #aiAssistant,
            #ai-assistant,
            #cxAiChat,
            #cx-ai,
            /* 隐藏悬浮的 AI 按钮 */
            .ai-float-btn,
            .ai-entry-btn,
            .ai-icon-btn,
            [class*="aiEntry"],
            [class*="ai-btn"],
            [class*="aiIcon"] {
                display: none !important;
                visibility: hidden !important;
                opacity: 0 !important;
                pointer-events: none !important;
            }
        `;
            top.document.head.appendChild(style);
        }

        // DOM 兜底：面板 class 认不出、只能靠文案认的那种。
        // 原来是扫全文档 querySelectorAll('div, section, aside') 再逐个读 textContent
        // —— 每 500ms 跑一次的话代价太大，而且祖先链上每一个都含那段文字，
        // 最外层那个一命中就把半个页面隐藏掉了。改成从"机器人"标记那个元素本身出发，
        // 结果集是个位数，也不会连坐祖先。
        // 顺带删掉 `classList.toLowerCase().includes('ai')` 这个条件 ——
        // "main"、"container"、"detail" 里都有 "ai"，它几乎对所有元素都成立。
        // ponytail: 纯靠"class 里带 robot + 文案含 AI智能助手"认，是个启发式。
        // 平台换了 class 或改了文案就认不出来，那时得回来加特征，而不是把网撒大。
        top.document.querySelectorAll('[class*="robot"],[class*="Robot"]').forEach(el => {
            if (el.closest('#panelNode')) return;              // 我们自己的面板，别自杀
            const text = el.textContent || '';
            if (!text.includes('AI智能助手') && !text.includes('ernie')) return;
            el.style.cssText = 'display: none !important;';
        });
    }
    
    function removeF() {
        var $tip = $("style:contains(font-cxsecret)");
        if (!$tip.length) return;
        var m = $tip.text().match(/base64,([\w\W]+?)'/);
        if (!m) return;
        var font = m[1];
        font = Typr.parse(base64ToUint8Array(font))[0];
        // Table 资源没在头部声明时 GM_getResourceText 返回 undefined，别让它炸掉整个字体解密
        var table;
        try {
            table = JSON.parse(GM_getResourceText("Table"));
        } catch (e) {
            console.log("⚠️ Table 资源加载失败，跳过超星字体解密:", e);
            return;
        }
        var match = {};
        for (var i = 19968; i < 40870; i++) {
            $tip = Typr.U.codeToGlyph(font, i);
            if (!$tip) continue;
            $tip = Typr.U.glyphToPath(font, $tip);
            $tip = MD5(JSON.stringify($tip)).slice(24);
            match[i] = table[$tip];
        }
        $(".font-cxsecret").html(function(index, html) {
            $.each(match, function(key, value) {
                key = String.fromCharCode(key);
                key = new RegExp(key, "g");
                value = String.fromCharCode(value);
                html = html.replace(key, value);
            });
            return html;
        }).removeClass("font-cxsecret");
        function base64ToUint8Array(base64) {
            var data = window.atob(base64);
            var buffer = new Uint8Array(data.length);
            for (var i = 0; i < data.length; ++i) {
                buffer[i] = data.charCodeAt(i);
            }
            return buffer;
        }
    }
    function start() {
        // 立即隐藏平台 AI
        try { hidePlatformAI(); } catch (e) {}
        
        setInterval(() => {
            try {
                hidePlatformAI();  // 持续检查并隐藏
            } catch (e) {}
            try {
                removeF();
            } catch (e) {}
            try {
                init();
            } catch (e) {}
        }, 500);
    }
    if (location.host.includes("chaoxing")) {
        setTimeout(() => {
            start();
        }, 2e3);
    }
    // ══ 超星刷课：参考实现那套架构（第 82 轮起；老接口引擎第 86 轮已删）════════════════
    // 学习通刷课走 参考实现那套：正文帧逐页真做（cxStudyFrame）、PCount.next 翻页、视频真播放、
    // 章节测试就地答。第 82 轮换过来后，老的接口上报引擎（cxRunPage / cxOneVideo / cxDoOneShot /
    // cxDoLive / cxOffload / 后台服务器）就没有入口调它了；第 86 轮把它整块删掉，cxserver /
    // servercheck 一并退役，「刷速课 / 刷直播回放 / 后台服务器」几个只被它读的开关也删了。
    // 下面这几个常量和 cxVideoRate 是真播放那条路（cxPlayMedia）在用的，保留。
    const CX_WATCH_STEP = 5;                   // 真看时每几秒瞄一下播放器走到哪了
    const CX_WATCH_STUCK = 90;                 // 一直不动多少秒就认定卡住了，别在那儿耗着
    const CX_JOB_CONFIRM_WAIT = 15;             // 媒体结束后等学习通确认任务点
    const CX_QUIZ_WAIT = 180;                  // 就地答章节测试时，等题目页答完/交完最多几秒
    // 真播放的倍速上限。定成 2 是安全线不是技术线：超星真播放超过 2 倍容易被判定无效、甚至
    // 清空进度（跟 MOOC / 职教云 / 雨课堂那几个真播放平台一个道理，它们设置上限也都是 2）。
    // 真播放的推荐安全线(第142轮起只是提醒,不再由脚本夹):超星真播放超过 2 倍容易被判定无效、
    // 清空进度(跟 MOOC / 职教云 / 雨课堂那几个真播放平台一个道理)。
    let CX_RATE_LIVE = 2;   // 只是面板/日志里引用到的推荐值,真播放直接按用户设置,不夹
    // 浏览器媒体管线其实能到 ~16,但 playbackRate 那个 IDL 属性不夹(写 100 读回来还是 100),
    // 真跑到几倍只能靠量 currentTime —— 下面那条诊断在实际没跑到目标倍速时会印出实测值。
    // 上界不在这儿再抄一个：cxSet 那边 outOfRange:"def" 已经把越界值挡回默认 1，
    // 抄一份就是两处要同步维护，而那正是"面板上填了不起作用"的来路。
    // (老的接口补报那条 live=false 分支随老引擎删了,如今只有真播放会调 —— 按用户设置直放,不夹。)
    const cxVideoRate = live => {
        const host = String(location.hostname || "").toLowerCase();
        const isChaoxing = ["chaoxing.com", "xueyinonline.com"]
            .some(domain => host === domain || host.endsWith("." + domain));
        const raw = Number(cxSet(isChaoxing ? "cx_rate_preset" : "cx_video_rate"));
        const rate = Math.max(1, Number.isFinite(raw) ? raw : 1);
        return live ? rate : rate;
    };

    // 从页面内联脚本里抠出 mArg —— 那份 JSON 描述了本章所有任务点。
    // 旧版脚本 都是按固定字符串 'try{\n    mArg = ' 切的，超星改个空格就失效。
    // 这里改成找到 mArg 之后做花括号配对，并且跳过字符串里的括号（视频名带 { } 就栽在这）。
    // 从一段文本里抠出 mArg。既用于当前页面的内联脚本，也用于 GM 取回的卡片页 HTML ——
    // 自动跳章那一路是拿 /knowledge/cards 的响应文本来解析的，不经过 DOM。
    // 一段 HTML 里可能出现多处 mArg（多张卡片、或者模板占位的 `mArg = $mArg;`），
    // 所以逐个往下试，直到某个能 JSON.parse 且带 attachments 的为止。
    function cxParseMArg(s) {
        if (!s) return null;
        let from = 0;
        while (true) {
            const k = s.indexOf("mArg", from);
            if (k < 0) return null;
            from = k + 4;
            const start = s.indexOf("{", k);
            if (start < 0) return null;
            let depth = 0, inStr = false, esc = false;
            for (let j = start; j < s.length; j++) {
                const c = s[j];
                if (inStr) {
                    if (esc) esc = false;
                    else if (c === "\\") esc = true;
                    else if (c === '"') inStr = false;
                    continue;
                }
                if (c === '"') inStr = true;
                else if (c === "{") depth++;
                else if (c === "}" && --depth === 0) {
                    try {
                        const o = JSON.parse(s.slice(start, j + 1));
                        if (o && o.attachments) return o;
                    } catch (e) { /* 这段不是 mArg，往下找 */ }
                    break;
                }
            }
        }
    }

    function cxReadMArg() {
        const scripts = document.getElementsByTagName("script");
        for (let i = 0; i < scripts.length; i++) {
            if (scripts[i].innerHTML.indexOf("==UserScript==") >= 0) continue;  // 别把自己解析了
            const o = cxParseMArg(scripts[i].innerHTML);
            if (o) return o;
        }
        return null;
    }

    const cxClock = s => Math.floor(s / 60) + ":" + String(Math.floor(s % 60)).padStart(2, "0");
    // 播放器那个 iframe 是谁的。超星把这个任务点的 JSON 塞在 iframe 元素的 data 属性里
    // （旧版脚本认任务点读的也是它），少了这一样还剩地址里的 jobid= —— 版式换过一次就少一样，
    // 两样都认就不至于因为一次改版整个复习功能变成哑的。
    function cxFrameJob(el) {
        let d = null;
        try { d = JSON.parse(el.getAttribute("data") || "null"); } catch (e) { d = null; }
        const byData = d && cxJobId(d);
        if (byData) return byData;
        const m = /[?&]jobid=([^&]*)/.exec(el.getAttribute("src") || "");
        return m ? decodeURIComponent(m[1]) : "";
    }
    // 从这一页往下走，把这个任务点的 <video> 找出来，顺手把别人的也拢一份。
    // 学习页 → 章节正文(cards) → 播放器(ananas) 是三层 iframe，都在 mooc1 同一个域下，
    // 所以 contentDocument 够得着。万一学校自己套了一层别的域，try 里就是 null，那一层
    // 往下整个放弃 —— 复习那边会退回接口补报，不会在这儿抛出去把整轮刷课带停。
    // ponytail: 只能走同源。跨域播放器要么用 postMessage 跟页面自己的播放器搭话，
    // 要么在 iframe 里也注入一份脚本（得改 @match 和 all_frames），都不是这一轮的事。
    // inherit：播放器有时还要再套一层，内层 iframe 上没有 data，身份从外层带下来。
    // out.seen 记的是"页面上每个播放器各自是谁的"。这功能报废了三轮都卡在同一个地方：
    // 认不出来时只是静默 return null，日志里一个字都没有，下一轮只能接着猜。
    function cxFindMedia(jid, doc, inherit, out) {
        out = out || { media: null, others: [], seen: [], blocked: 0 };
        for (const el of (doc || document).querySelectorAll("iframe")) {
            let sub = null;
            try { sub = el.contentDocument; } catch (e) { sub = null; }
            // 够不着的那一层要记个数：这是"学校的播放器套了另一个域"和"正文没翻到这一页"
            // 唯一能分开的证据。日志里少了它，下一轮还是只能猜（前三轮就是这么过去的）。
            if (!sub) { out.blocked++; continue; }
            const id = cxFrameJob(el) || inherit || "";
            const m = sub.querySelector("video,audio");
            if (m) {
                out.seen.push(id);
                if (id === jid && !out.media) out.media = m;
                else if (out.others.indexOf(m) < 0) out.others.push(m);
            }
            cxFindMedia(jid, sub, id, out);
        }
        return out;
    }
    // 把页面上够得着的播放器全部调到这个倍速，返回调到了几个。
    // 这是 参考实现的 onConfigChange("playbackRate") 那件事，只是它有一份 currentMedia 引用，
    // 我们现找一遍 —— 好处是顺带管到"页面自己在放、脚本没在管"的那个播放器：默认不开
    // 复习模式时走的是接口补报，压根不碰播放器，而用户眼前放着的就是它，
    // 于是他调倍速什么都不会发生。那就是"倍速功能没有用"的另一半。
    // 传一个不可能是 jobid 的字符串：这样页面上每个播放器都落进 others 里。
    // 倍速跨域广播:同源直设(cxApplyRate)之外,把倍速指令发给页面上每个 iframe。
    // contentWindow 跨域只挡 contentDocument,postMessage 发得出去;帧内的 cxRateFrameAgent
    // 收到后把帧里的 <video> 调过去,还会链式转发给更深的子帧。返回发给了几个帧 ——
    // 这是"够不着播放器"那条日志的第二条腿:跨域帧够不着(CXFIND 里 blocked),
    // 但广播发得出去。
    function cxMediaElements(doc = document, out = new Set(), depth = 0) {
        for (const m of Array.from(doc.querySelectorAll("video,audio"))) out.add(m);
        if (depth < 8) for (const frame of Array.from(doc.querySelectorAll("iframe"))) {
            try { if (frame.contentDocument) cxMediaElements(frame.contentDocument, out, depth + 1); } catch (e) {}
        }
        return Array.from(out);
    }
    function cxLockPlaybackRate(media, rate, win) {
        try {
            // Set the native media rate first, then keep page scripts from immediately writing it back.
            try { delete media.playbackRate; } catch (e) {}
            const proto = win && win.HTMLMediaElement && win.HTMLMediaElement.prototype;
            const nativeSetter = proto && Object.getOwnPropertyDescriptor(proto, "playbackRate");
            if (nativeSetter && typeof nativeSetter.set === "function") nativeSetter.set.call(media, rate);
            else media.playbackRate = rate;
            const state = { rate: rate };
            Object.defineProperty(media, "playbackRate", {
                configurable: true,
                get: () => state.rate,
                set: () => {}
            });
            return true;
        } catch (e) { return false; }
    }
    function cxSyncMediaRate(media, rate) {
        if (!media) return false;
        rate = Math.max(1, Number(rate) || 1);
        try {
            const doc = media.ownerDocument;
            const raw = doc && doc.defaultView;
            const win = raw && (raw.wrappedJSObject || raw);
            const host = win && win.location && win.location.hostname || "";
            if (host === "zhihuishu.com" || host.endsWith(".zhihuishu.com")) {
                // 智慧树用网站回调同步计时,不从通用路径点击播放器菜单。
                if (doc === document) return Math.abs(zhsMediaRate(media, rate) - rate) < 0.001;
                return false; // 子帧自身的代理负责其播放器上下文。
            }
            if (host === "chaoxing.com" || host.endsWith(".chaoxing.com")
                || host === "xueyinonline.com" || host.endsWith(".xueyinonline.com")) {
                return cxLockPlaybackRate(media, rate, win);
            }
            const root = media.closest && media.closest(".video-js");
            const candidates = [];
            if (root) {
                const pageRoot = root.wrappedJSObject || root;
                if (pageRoot.player) candidates.push(pageRoot.player);
            }
            const vjs = win && (win.videojs || win.videoJs);
            if (vjs) {
                const players = typeof vjs.getPlayers === "function" ? vjs.getPlayers() : vjs.players;
                if (players) candidates.push(...Object.values(players));
            }
            for (const player of candidates) {
                if (!player || typeof player.playbackRate !== "function" || typeof player.el !== "function") continue;
                if (typeof player.isDisposed === "function" && player.isDisposed()) continue;
                const el = player.el();
                if (!el || !(el === media || (el.contains && el.contains(media)))) continue;
                // 原生 setter 同步播放器状态、菜单和 ratechange 事件,不创建第二个实例。
                if (Number(player.playbackRate()) !== rate || Math.abs(media.playbackRate - rate) > 0.001)
                    player.playbackRate(rate);
                return Math.abs(media.playbackRate - rate) < 0.001;
            }
            // 没有可访问的播放器 API 时,HTML5 ratechange 事件由浏览器自动触发。
            if (Math.abs(media.playbackRate - rate) > 0.001) media.playbackRate = rate;
            return Math.abs(media.playbackRate - rate) < 0.001;
        } catch (e) { return false; }
    }
    function cxRateBroadcast(rate) {
        if (!(rate >= 1)) return 0;
        let sent = 0;
        for (const el of document.querySelectorAll("iframe")) {
            const win = el.contentWindow;
            if (!win) continue;
            try { win.postMessage({ type: "cx_rate", rate: rate }, "*"); sent++; } catch (e) {}
        }
        return sent;
    }
    function cxApplyRate(rate) {
        let n = 0;
        for (const m of cxMediaElements()) if (cxSyncMediaRate(m, rate)) n++;
        return n;
    }

    // 任务点的 jobid。真任务点在顶层 job.jobid；非任务点（只有开了强制学习才会碰到的那些）
    // 超星只在 property._jobid 里给 —— 旧版脚本读的也是 attachment.jobid || property._jobid。
    // 少了后半截，强制学习整条路都在拿 undefined 当 id：上报地址写成 jobid=undefined，超星
    // 永远不给 isPassed，一个 40 分钟的视频要发满 40 分钟才落到「失败」；交给后台服务器的
    // 那些更糟 —— jobId 全是字符串 "undefined"，从第二个起都被当成"这个本来就在跑"扔掉。
    // 播放器那个 iframe 元素的 data 属性里又是第三种形状：_jobid 在顶层，没有 property。
    // 三处都读一下，认任务点和认播放器就是同一个读法 —— 两边认出来的 id 必须对得上，
    // 对不上的话复习那趟会去放别人的视频。
    const cxJobId = job => String((job && (job.jobid || job._jobid
        || (job.property && job.property._jobid))) || "");
    // 面板上那一行的身份。没有 jobid 就退回 property.mid（旧版脚本认任务点也是拿 mid 当身份），
    // 两样都没有就返回空串 —— 这里不能悄悄编一个，编出来的 key 对不上第二次更新。
    const cxTaskKey = job => cxJobId(job)
        || String((job.property && (job.property.mid || job.property.objectid)) || "");

    // job / isPassed 这两个字段超星各版式给不给都不一样，所以"做完没做完"和"卡片有没有标"
    // 只在这两处判，别在调用点各写一遍 —— 第 41、42、43 三轮的病根是同一件事：同一个问题
    // 在两处判得不一样（闸放它过去了，面板那行却说它不算数）。
    const cxJobDone = job => !!(job && job.isPassed);
    // 「卡片没标」不等于「不是任务点」。参考实现的第三分支 not-job 就是这个判断，但那个名字把
    // 结论写进去了：真机上一门 20 章全「已完成」的课，每一页都是"非任务点跳过 2 个"，一个
    // 视频任务点都认不出来。是不是任务点这儿判不了，留到跑起来让超星自己回答
    // （cxOneVideo 里第一条上报就回 isPassed，那就是它本来已完成的证据）。
    const cxJobBare = job => !(job && (job.job || job.isPassed));

    function cxParseJobReport(text) {
        try {
            const data = JSON.parse(text);
            return !!data && (data.status === true || data.status === "true");
        } catch (e) {
            return String(text || "").includes("success");
        }
    }

    function cxWatchJobReport(win) {
        const proto = win && win.XMLHttpRequest && win.XMLHttpRequest.prototype;
        if (!proto) return { confirmed: false, restore: () => {} };
        const originalOpen = proto.open, originalSend = proto.send;
        const state = { confirmed: false };
        proto.open = function(method, url, ...rest) {
            this.__cxTaskReportUrl = typeof url === "string" ? url : "";
            return originalOpen.call(this, method, url, ...rest);
        };
        proto.send = function(...args) {
            if (String(this.__cxTaskReportUrl || "").includes("/ananas/job")) {
                this.addEventListener("load", () => {
                    state.confirmed = cxParseJobReport(this.responseText);
                });
            }
            return originalSend.apply(this, args);
        };
        return {
            get confirmed() { return state.confirmed; },
            restore() {
                proto.open = originalOpen;
                proto.send = originalSend;
            }
        };
    }

    async function cxWaitJobFinished(att, frame, report, timeout = CX_JOB_CONFIRM_WAIT) {
        const deadline = Date.now() + timeout * 1000;
        while (Date.now() < deadline) {
            const parent = frame && frame.parentElement;
            if (cxJobDone(att) || report.confirmed || parent && parent.classList.contains("ans-job-finished")) return true;
            await sleep(0.5);
        }
        return false;
    }

    // 一页卡片里的任务点，按类型分派
    // 往面板「任务点」那一屏推一行。key 用 cxTaskKey，所以同一个任务点从待做走到已完成
    // 是同一行在变，不是叠出好几行。
    // 这一屏是为了回答「有视频任务却说没有」那个问题：日志只滚结论，看不到脚本认到了什么。
    function cxTask(job, state, q) {
        iframeMsg("task", {
            // 连 mid 都没有时才编一个：随机 key 意味着这一行永远等不到第二次更新，
            // 「进行中」和「已完成」会变成并排两行。
            key: cxTaskKey(job) || job.type + Math.random(),
            kind: job.type,
            name: (job.property && (job.property.name || job.property.title)) || cxJobId(job) || "未命名任务点",
            chapter: (q && q.chapterName) || "",
            // 这一趟是什么性质。先写个「复习」，真看那边站住了 cxTaskMark 会把它改成
            // 「复习·真看」，退回接口了改成「复习·补报」—— 不写出来的话，复习（要占掉一整段
            // 视频的时间）跟卡住了长得一样；强制学习拉进来的非任务点跟真任务点长得一样，
            // 而后者刷完了进度条也不会涨，这件事必须在那一行上看得见，不能只在日志里说一次。
            // 「卡片有没有标」和「做完没做完」是两个问题，各归各的判断（cxJobBare/cxJobDone）。
            // 原来这行只看 job 一个字段：做完了把 job 抹掉的那种版式上，正在复习的任务点会被
            // 标成「非任务点」—— 闸放它过去了，行上却说它不算数，自相矛盾。
            mark: cxJobBare(job) ? (cxSet("cx_restudy") ? "复习" : "非任务点")
                : (cxJobDone(job) && cxSet("cx_restudy")) ? "复习" : "",
            state: state
        });
    }
    // 视频每分钟报一次进度。只带 note/pct，不带 state/name/chapter —— 面板那边
    // upsertTask 是按 key 合并的，所以这条落回 cxTask 建的那一行，不叠第二行也不
    // 冲掉名字。算不出稳定 key 的（cxTask 那边给它编了个随机数）对不上那一行，索性不报 ——
    // 在这儿也编一个的话，每分钟都会多出一行新的。
    function cxTaskNote(job, note, pct) {
        const key = cxTaskKey(job);
        if (!key) return;
        iframeMsg("task", { key: key, note: note, pct: pct });
    }
    // 只换那一行的小标，别的字段一个都不动（面板那边 upsertTask 是按字段合并的）。
    // 复习这一趟走的是"真看"还是"补报"必须分得出来：一个是播放器在放、学习时长是真的，
    // 一个是接口补一份上报、能不能算还没在真机上验过。混成一个「复习」等于什么都没说。
    function cxTaskMark(job, mark) {
        const key = cxTaskKey(job);
        if (key) iframeMsg("task", { key: key, mark: mark });
    }

    // 定时停止。挂机刷课最怕"忘了它还在跑"：一门课几十章，跑通宵和跑一小时是两回事。
    // 期限在刷课开工（cxStudyDispatch / cxStudyFrame 调 cxArm）时读一次就定死 —— 中途改设置不影响这一趟，否则"把 30 改成 60"
    // 到底是"总共 60 分钟"还是"再跑 60 分钟"说不清。0 = 不限（默认）。
    let cxStopAt = 0;
    // 期限得跨页面活着。答题模块每做完一页就跳下一页 —— 那是一次真正的页面加载，脚本整个重来。
    // 按 Date.now() 现算的话，"跑 60 分钟"会变成"每页重新给 60 分钟"，等于没设。
    // 所以起点存在 GM 里，两条路（刷课 / 答题）读的是同一个。
    // 起点什么时候该重置？靠心跳：离上次动过超过 10 分钟就算新的一趟。挂机时脚本一直在做事、
    // 心跳一直在刷；走开一晚上再回来就超了。这条判错的代价不对称 —— 判成"新一趟"最多多给
    // 一次时长，判成"同一趟"会让人第二天打开发现脚本一上来就停了，所以宁可偏向重置。
    const CX_RUN_GAP = 6e5;
    function cxArm() {
        const now = Date.now();
        const seen = parseInt(GM_getValue("cx_run_seen")) || 0;
        let started = parseInt(GM_getValue("cx_run_started")) || 0;
        if (!started || now - seen > CX_RUN_GAP) {
            started = now;
            GM_setValue("cx_run_started", started);
        }
        GM_setValue("cx_run_seen", now);
        const limit = cxSet("cx_stop_after");
        cxStopAt = limit > 0 ? started + limit * 6e4 : 0;
        return limit;
    }
    // 到点了只响一次：把这一趟的起点清掉，用户主动再来（点继续 / 重开页面）就是新的一趟，
    // 重新给足时长。不清的话，"继续"按下去下一圈立刻又被判到点、按钮按不动；
    // 刷课那边则是一刷新就又停，看着像脚本坏了。
    function cxDisarm() {
        cxStopAt = 0;
        GM_setValue("cx_run_started", 0);
    }
    // ponytail: 只在任务点/章节的交界处判，不打断正在刷的那个视频。半路停下，那条上报序列
    // 就少了收尾的 isdrag=4，超星不认为看完 —— 任务点没完成，花掉的时间也白费。
    // 上限：所以实际收工最多晚一个视频的时长（超星单个视频常见 10~40 分钟）。
    // 要真的秒停，得在 cxOneVideo 的上报循环里也判一次，并接受那个视频作废。
    function cxTimeUp() {
        // 顺手刷心跳。这个函数就是在"任务点/题目的交界处"调的，也就是"这一趟还在跑"唯一
        // 可靠的信号。拆成单独一个 cxBeat() 要在好几个地方成对调用，漏掉一处的后果是
        // 那条路径上的长时间运行会被误判成"人走开了"，下次加载白送一整个时长。
        GM_setValue("cx_run_seen", Date.now());
        return cxStopAt > 0 && Date.now() >= cxStopAt;
    }

    // 常驻进度。日志是一直往下滚的，"现在到第几章"滚过去就找不回来了；顶栏这一条不会被冲掉。
    function cxProgress(text, pct) {
        iframeMsg("progress", { text: text, pct: pct });
    }

    // 人脸识别。超星在开了这项的任务点上会随机弹摄像头抓拍，attachment 上带 videoFaceCaptureEnc
    // 就是这门课开了。第 82 轮起刷课是真播放（参考实现那套），抓拍框会真的弹出来、视频停住等人 ——
    // 脚本替不了刷脸（cxPlayMedia 那边干等，不算卡住）。挂机的人回来只会看到"一直停着"，
    // 所以碰上就明说一次，让用户自己决定要不要挂机。
    let cxFaceSaid = false;
    function cxFaceWarn(name) {
        if (cxFaceSaid || !cxSet("cx_notify_face")) return;
        cxFaceSaid = true;
        logMsg("⚠ 这门课开了人脸识别（任务点「" + name + "」带 videoFaceCaptureEnc）。"
            + "播放中超星会弹摄像头抓拍，脚本不会替你刷脸 —— 弹出来时视频会一直停着等你，"
            + "建议这门课人守在电脑前，至少别全程挂机", "warn");
    }


    // 让页面跟着跑到的章节走。刷课全走接口上报，页面本来一动不动 —— 右边一直停在打开时
    // 那一章，看着就像脚本没干活（这一轮就是为这个来的）。
    // 不用 location.href 跳：那样整个脚本会重启，这一趟的逐章循环当场断掉。超星侧边栏每个
    // 章节的 onclick 就是 getTeacherAjax(课程,班级,章节)，调它是页面自己的换章方式。
    // doc/win 做成参数是为了能单独切出来跑（跟 cxChapters 一个道理）。
    // ponytail: 只管右边正文。左边那些对勾/未完成计数是整页加载时渲染的，这里换不动它们，
    // 要看真实的对勾还是得按 F5（收工那条日志里说了这件事）。换过去的那一章正文会在页面里
    // 自己加载，视频可能跟着播 —— 费点流量，但这正是"页面跟着走"想要的效果。
    function cxShowChapter(id, q, doc, win) {
        doc = doc || document;
        win = win || unsafeWindow;
        try {
            if (!win || typeof win.getTeacherAjax !== "function") return false;
            const node = doc.getElementById("cur" + id);
            // 已经在这一章了就别再换：换一次右边整块重载，白等一秒
            if (!node || !/posCatalog_active/.test(node.className || "")) {
                win.getTeacherAjax(q.courseId, q.classId, id);
            }
            if (node && node.scrollIntoView) node.scrollIntoView({ block: "center" });
            return true;
        } catch (e) {
            // 这一路纯粹是给人看的。换不动页面绝不许把这一趟刷课带下去。
            return false;
        }
    }


    // ══ 学习通刷课：参考实现那套架构（第 82 轮起）══════════════════════════════════
    // 原来是顶层一个大循环：接口抓每章每页的卡片、接口上报视频，再想办法把页面拽过去给人看。
    // 章节测试在那套里一直坏：它通常在这一章的另一个标签页上，页面拽不过去，超星就不会把题目页
    // 渲染出来，答题模块无从下手（第 79-81 三轮都栽在这上面）。用户拍板：直接换 参考实现那套。
    // 骨架抄 参考脚本的 studyDispatcher + study + searchJob + JobRunner：
    //   · 顶层 studentstudy 只调度（cxStudyDispatch）：挂面板、收正文帧转来的日志、开局跳到
    //     第一个有待完成任务点的章。
    //   · 干活的是正文那一帧 /knowledge/cards（cxStudyFrame）。超星每翻一页、换一章都重载它，
    //     脚本在里面重跑一遍：在自己的子帧里找任务点（iframe 的 data.jobid 对上 window.attachments），
    //     一个个在页面上做完 —— 视频真播放、章节测试由题目帧里注入的答题模块就地答 —— 然后调
    //     超星自己的 PCount.next 翻到下一页 / 下一章。页面换一次脚本重跑一次，不跨页记状态。

    // 页面自己的全局量（PCount、getTeacherAjax、finishJob、attachments）。油猴在 Chrome 上拿到的
    // 就是页面那个 window；Firefox 隔着一层 xray，页面自己挂的属性要走 wrappedJSObject 才看得见。
    const cxPage = w => (w && w.wrappedJSObject) || w;

    // 往上找学习页那一层（参考实现的「环境准备脚本」也是这么找 top 的：最多爬 10 层）。
    // 爬到跨域的那层就算不在学习页里 —— 那种页面脚本本来也碰不到它的侧边栏。
    function cxStudyTop(win) {
        let w = win || window;
        for (let i = 0; i < 10 && w; i++) {
            try {
                if (/\/mycourse\/studentstudy/.test(w.location.pathname)) return w;
            } catch (e) {
                return null;
            }
            if (w.parent === w) return null;
            w = w.parent;
        }
        return null;
    }

    // 侧边栏每一章。参考实现的 getChapterInfos：onclick 里 getTeacherAjax('课程','班级','章节')
    // 第三个参数是章节号；同一格里那个隐藏的 .jobUnfinishCount 是还剩几个任务点没做；
    // 格子本身（onclick 那个元素的父级）带 posCatalog_active 就是右边正显示着的那一章。
    // 名字里超星会拼一截「1个待完成任务点」，日志里那截是噪音，剥掉。
    function cxChapterInfos(doc) {
        const out = [];
        for (const el of (doc || document).querySelectorAll('[onclick^="getTeacherAjax"]')) {
            const m = /\('([^']*)',\s*'([^']*)',\s*'([^']*)'\)/.exec(el.getAttribute("onclick") || "");
            if (!m || !m[3]) continue;
            const box = el.parentElement;
            const cnt = box && box.querySelector(".jobUnfinishCount");
            out.push({
                id: m[3],
                name: String(el.getAttribute("title") || el.textContent || "").replace(/\s+/g, " ").trim()
                    .replace(/\s*\d+\s*个待完成任务点.*$/, "").slice(0, 40),
                unfinished: parseInt(cnt && cnt.value, 10) || 0,
                active: !!(box && /posCatalog_active/.test(box.className || ""))
            });
        }
        return out;
    }

    // 从这一页往下把够得着的 iframe 全摊平（参考实现的 searchIFrame，广度优先）。跨域的那层
    // contentWindow.document 一碰就抛，跳过它、也不往它里面钻。
    function cxFrames(doc) {
        const out = [];
        let list = [].slice.call(doc.querySelectorAll("iframe"));
        while (list.length) {
            const fr = list.shift();
            let sub = null;
            try { sub = fr.contentWindow && fr.contentWindow.document; } catch (e) { sub = null; }
            if (!sub) continue;
            out.push(fr);
            list = list.concat([].slice.call(sub.querySelectorAll("iframe")));
        }
        return out;
    }

    // 在页面上找下一个没碰过的任务点（参考实现的 searchJob）。认法跟 参考实现一样是反着来的：
    // 先看哪一帧里有东西（播放器 / 题目 / 文档 / 链接），再读那一帧 iframe 元素上的 data 认它是谁 ——
    // 章节测试的题目页还要再套一层，data 在外面那层上，所以两层都认。
    // seen 记的是这一页已经交过手的任务点，同一个不做两遍。
    function cxSearchJob(doc, atts, seen) {
        for (const fr of cxFrames(doc)) {
            const d = fr.contentWindow.document;
            const hit = {
                media: d.querySelector("#video,#audio"),
                quiz: d.querySelector(".TiMu"),
                read: d.querySelector("#img.imglook"),
                ppt: d.querySelector(".swiper-container"),
                link: d.querySelector("#hyperlink"),
                timer: d.querySelector('iframe[name="bookifame"][src*="timing"]')
            };
            if (!(hit.media || hit.quiz || hit.read || hit.ppt || hit.link || hit.timer)) continue;
            let up = null;
            try { up = fr.ownerDocument.defaultView.frameElement; } catch (e) { up = null; }
            const ids = [cxFrameJob(fr), up ? cxFrameJob(up) : ""].filter(Boolean);
            if (!ids.length) continue;
            const att = atts.find(a => a && ids.indexOf(cxJobId(a)) >= 0);
            if (!att) continue;
            const key = cxTaskKey(att) || ids[0];
            if (seen.indexOf(key) >= 0) continue;
            seen.push(key);
            return { att: att, frame: fr, doc: d, hit: hit };
        }
        return null;
    }

    const cxJobName = att => {
        const p = (att && att.property) || {};
        return p.name || p.title || (p.bookname ? p.bookname + (p.author || "") : "") || cxJobId(att) || "未命名任务点";
    };
    // 章节测试做没做完，只信题目页自己那块牌子（参考实现也只看它）。卡片 JSON 里的 isPassed
    // 对章节测试不可信：侧边栏标着「待完成」它却回 true（第 81 轮真机）。
    const cxQuizDone = doc => {
        const st = doc && doc.querySelector(".testTit_status");
        return !!(st && /testTit_status_complete/.test(st.className || ""));
    };

    // 人脸识别框弹没弹（参考实现的 hasFaceRecognition / hasNewFaceRecognition 两种版式）。都挂在学习页顶层。
    function cxFaceUp(top) {
        try {
            const d = top.document;
            for (const im of d.querySelectorAll("#fcqrimg")) if (im.getAttribute("src")) return true;
            for (const m of d.querySelectorAll(".chapterVideoFaceMaskDiv")) if (m.style.display !== "none") return true;
        } catch (e) { /* 读不到就当没有，别把播放带停 */ }
        return false;
    }

    // 视频中途弹的小测验。交完 3 秒把那层框拆掉；是否自动答由 cx_video_quiz 控制。
    function cxVideoQuizOpen(doc) {
        if (!doc) return false;
        const visible = el => {
            for (let node = el; node; node = node.parentElement) {
                if (node.hidden || node.getAttribute && node.getAttribute("aria-hidden") === "true") return false;
                let style = node.style || {};
                try {
                    const win = node.ownerDocument && node.ownerDocument.defaultView;
                    if (win && win.getComputedStyle) style = win.getComputedStyle(node);
                } catch (e) {}
                if (style.display === "none" || style.visibility === "hidden") return false;
                if (node === doc.documentElement) break;
            }
            return !!el;
        };
        const box = doc.querySelector("#video .ans-videoquiz, .ans-videoquiz");
        if (box) return visible(box);
        return visible(doc.querySelector("#videoquiz-submit"));
    }
    function cxVideoQuiz(doc) {
        const submit = doc.querySelector("#videoquiz-submit");
        if (!submit || submit.cxDone) return false;
        submit.cxDone = true;
        const opts = doc.querySelectorAll(".ans-videoquiz-opt label");
        if (opts.length) opts[Math.floor(Math.random() * opts.length)].click();
        submit.click();
        setTimeout(() => {
            try {
                const box = doc.querySelector("#video .ans-videoquiz");
                if (box) box.remove();
                doc.querySelectorAll(".x-component-default").forEach(c => { c.style.display = "none"; });
            } catch (e) { /* 拆不掉就算了，下一拍播放器照样会被按回去播 */ }
        }, 3000);
        return true;
    }

    // 切走焦点 / 切标签 / 最小化时,网站播放器会自己 pause()(超星等平台的风控)。只靠每 CX_WATCH_STEP 秒
    // 轮询按回去,前台要顿 5 秒、后台标签的定时器又被浏览器节流到分钟级 —— 等于停住。参考实现是挂
    // media 的 pause 事件重播(事件不走定时器,不受节流)。这里做成一个可复用的工厂:arm() 挂上、
    // unarm() 摘掉、脚本自己要暂停时走 selfPause()(标记一下,别把自己人按的暂停又按回去)。
    // 重播前先看:不是 ended、元素还在、没弹人脸,并且 1 秒内最多重播一次(别和播放器自己打架)。
    // 禁倍速的页面常会「一加就被按回 1 / 立刻 pause」。挂个 ratechange 复播:把被按回去的倍速顶回
    // 目标、播放被暂停了就播回去。ratechange(按回 1)也顺手复播,不必等看门狗那一拍。不节流
    // (ratechange 可能被页面高频触发,节流反而把复播吃掉)。弹题/弹人脸时让开,不跟人等答打架。
    function cxPaceKeep(media, opt) {
        const o = opt || {};
        const target = () => (typeof o.rate === "function" ? o.rate() : o.rate) || 1;
        const blocked = () => (typeof o.hold === "function" ? o.hold() : false)
            || (o.faceTop !== undefined && o.faceTop && cxFaceUp(o.faceTop));
        const fn = () => {
            if (media.ended || !media.isConnected) return;
            if (blocked()) return;
            try { o.apply(target()); } catch (e) {}
            if (media.paused) { try { const p = media.play(); if (p && p.catch) p.catch(() => {}); } catch (e) {} }
        };
        return {
            arm() { try { media.addEventListener("ratechange", fn); } catch (e) {} },
            unarm() { try { media.removeEventListener("ratechange", fn); } catch (e) {} },
            keep() { fn(); }
        };
    }
    function cxResumeOnPause(media, top, hold) {
        const st = { at: 0, self: false };
        const play = () => { try { const q = media.play(); if (q && q.catch) q.catch(() => {}); } catch (e) {} };
        const fn = () => {
            if (st.self) { st.self = false; return; }        // 是脚本自己按的暂停,别抢着按回去
            const now = Date.now();
            if (now - st.at < 1000) return;                  // 节流:1 秒内最多重播一次
            if (media.ended || !media.isConnected) return;
            if (hold && hold()) return;                      // 调用方有自己的"该等着"状态(如弹着测验)
            if (top && cxFaceUp(top)) return;                // 弹人脸了,等真人刷完,别催
            st.at = now;
            play();
        };
        return {
            arm() { try { media.addEventListener("pause", fn); } catch (e) { st.self = false; } },
            unarm() { try { media.removeEventListener("pause", fn); } catch (e) {} },
            selfPause() { st.self = true; try { media.pause(); } catch (e) {} }
        };
    }
    // 最小化 / 切到别的标签时给一句提示。后台标签的 setTimeout 被浏览器节流是硬规则,脚本绕不过;
    // 参考实现也是每 1 秒查一次 visibilityState、提示“别最小化/切屏”。这里同款,隐藏时只说一次。
    let cxBgWarned = false;
    function cxBgCheck(top) {
        try {
            const d = (top && top.document) || (typeof document !== "undefined" ? document : null);
            if (!d) return;
            const hidden = d.visibilityState === "hidden";
            if (hidden && !cxBgWarned) {
                cxBgWarned = true;
                logMsg("检测到浏览器最小化 / 切到了别的标签:视频可能被网站暂停;脚本会尽量按回去,但后台标签的计时会被浏览器放慢 —— 想稳就保持这个页面在前台", "warn");
            } else if (!hidden) { cxBgWarned = false; }
        } catch (e) { /* 读不到就跳过,别把播放带停 */ }
    }

    // 真播放一个视频/音频(参考实现的 JobRunner.media)。静音才让自动播;倍速按面板设置直通(第142轮起不夹)——
    // 超星真播放超过 2 倍容易被判无效、清进度。每 CX_WATCH_STEP 秒看一眼：停了就按回去播
    // （超星切走焦点会暂停，参考实现是挂 pause 事件重播），弹题就答，弹人脸就干等，
    // 一直不动超过 CX_WATCH_STUCK 秒才放弃这一个（参考实现会一直等下去，挂机时那等于停在这儿）。
    async function cxPlayMedia(att, doc, name, top, frame, report) {
        let media = null;
        for (let i = 0; i < 60 && !media; i++) {
            media = doc.querySelector("video,audio");
            if (!media) await sleep(1000);
        }
        if (!media) {
            logMsg("视频「" + name + "」：等了 60 秒播放器也没出来（刷新一下这一页再试），先跳过", "warn");
            return "失败";
        }
        // 复习：本来就完成了的，从头真看一遍；没看完的从上次停的地方接着放
        const again = cxJobDone(att);
        if (again) cxTaskMark(att, "复习");
        else if (cxJobBare(att)) cxTaskMark(att, "非任务点");
        let rate = cxVideoRate(true);
        try {
            media.muted = true;
            media.volume = 0;
            if (again) media.currentTime = 0;
            cxSyncMediaRate(media, rate);
        } catch (e) { /* 属性写不进去不影响播放 */ }
        const total = () => (media.duration > 0 && isFinite(media.duration)) ? media.duration : 0;
        const play = () => {
            try { const p = media.play(); if (p && p.catch) p.catch(() => {}); } catch (e) {}
        };
        let quizPaused = false, rateConfirmed = false;
        const quizMode = () => cxSet("cx_video_quiz") === "pause" ? "pause" : "auto";
        const quizOpen = () => cxVideoQuizOpen(doc);
        const resume = cxResumeOnPause(media, top, quizOpen);
        resume.arm();          // 网站一 pause 就立刻按回去(不受后台定时器节流)
        const pace = cxPaceKeep(media, { rate: () => rate, apply: r => cxSyncMediaRate(media, r),
            hold: quizOpen, faceTop: top });
        pace.arm();            // 页面把倍速按回 1(ratechange)也立刻顶回去 —— 去掉倍速限制的主路
        play();
        rateConfirmed = cxSyncMediaRate(media, rate);
        logMsg("开始播放「" + name + "」：目标 " + rate + " 倍速"
            + (rateConfirmed ? "（已应用到播放器）" : "（播放器尚未确认，继续监测）")
            + (total() ? "，约 " + Math.max(1, Math.ceil((total() - media.currentTime) / rate / 60)) + " 分钟" : "")
            + "（真播放，这一页别关，窗口可以缩小）");
        let last = media.currentTime, lastMeasureAt = Date.now(), stuck = 0, faceSaid = false;
        let rateMismatchSamples = 0, lastRateWarningAt = 0;
        // 页面把倍速按回 1 或按暂停,都由上面 pace.keep() 当场顶回去并复播 ——
        // 只要页面还在放(哪怕慢),currentTime 就会走,stuck 自然不涨;真停住了才算卡住。
        while (!media.ended) {
            await sleep(CX_WATCH_STEP * 1e3);
            cxBgCheck(top);
            if (!media.isConnected) {
                resume.unarm(); pace.unarm();
                logMsg("视频「" + name + "」的播放器被页面换掉了（翻页 / 换章了？），这一个没放完", "warn");
                return "失败";
            }
            // 人脸识别：脚本替不了，等人刷完。这段时间不算卡住（参考实现也是干等）
            if (cxFaceUp(top)) {
                if (!faceSaid) {
                    faceSaid = true;
                    logMsg("⚠ 视频「" + name + "」弹了人脸识别 —— 得你自己对着摄像头刷一下，刷完接着放", "warn");
                }
                last = media.currentTime;
                lastMeasureAt = Date.now();
                stuck = 0;
                continue;
            }
            faceSaid = false;
            if (quizOpen()) {
                if (quizMode() === "pause") {
                    if (!quizPaused) {
                        quizPaused = true;
                        resume.selfPause();
                        logMsg("视频「" + name + "」中途弹了题，已暂停等待你作答", "warn");
                    }
                } else if (cxVideoQuiz(doc)) {
                    logMsg("视频「" + name + "」中途弹题，已自动选择并提交");
                }
            } else {
                if (quizPaused) logMsg("视频「" + name + "」的弹题已关闭，恢复播放");
                quizPaused = false;
            }
            const bad = doc.querySelector(".vjs-modal-dialog-content");
            const why = bad && /视频文件损坏|网络错误导致视频下载中途失败|视频因格式不支持|网络的问题无法加载/
                .exec(bad.textContent || "");
            if (why) {
                resume.unarm(); pace.unarm();
                logMsg("视频「" + name + "」加载失败（" + why[0] + "），跳过这一个", "warn");
                return "失败";
            }
            if (quizPaused) {
                stuck = 0;
                last = media.currentTime;
                lastMeasureAt = Date.now();
                cxTaskNote(att, cxClock(last) + " / " + cxClock(total()), total() ? last / total() * 100 : -1);
                continue;
            }
            // 每一拍现读设置：面板上改了倍速，最多晚 CX_WATCH_STEP 秒跟上
            const want = cxVideoRate(true);
            if (want !== rate) {
                rate = want;
                rateConfirmed = cxSyncMediaRate(media, rate);
                logMsg("视频「" + name + "」倍速目标改为 " + rate + " 倍，"
                    + (rateConfirmed ? "已应用" : "尚未确认应用，继续监测"));
            }
            // 设置没变也要写回去：换线路、切清晰度都会把 playbackRate 按回 1 倍
            const nowConfirmed = cxSyncMediaRate(media, rate);
            if (nowConfirmed !== rateConfirmed) {
                logMsg("视频「" + name + "」倍速 " + rate + " 倍" + (nowConfirmed ? "已恢复应用" : "应用失效，正在重试"),
                    nowConfirmed ? undefined : "warn");
                rateConfirmed = nowConfirmed;
            }
            const t = media.currentTime;
            const measuredAt = Date.now();
            const elapsed = Math.max(0.001, (measuredAt - lastMeasureAt) / 1000);
            const effectiveRate = Math.max(0, (t - last) / elapsed);
            if (rate > 1.25 && effectiveRate < rate * 0.75) {
                rateMismatchSamples++;
                if (rateMismatchSamples >= 3 && measuredAt - lastRateWarningAt >= 30000) {
                    lastRateWarningAt = measuredAt;
                    logMsg("视频「" + name + "」目标 " + rate + " 倍，实测推进约 " + effectiveRate.toFixed(1)
                        + " 倍；播放器没有达到目标速度", "warn");
                    rateMismatchSamples = 0;
                }
            } else {
                rateMismatchSamples = 0;
            }
            if (t > last + 0.2) {
                stuck = 0;
            } else {
                if (media.paused && !media.ended) pace.keep();
                if (++stuck * CX_WATCH_STEP >= CX_WATCH_STUCK) {
                    resume.unarm(); pace.unarm();
                    logMsg("视频「" + name + "」卡在 " + cxClock(t) + " 不走了（" + CX_WATCH_STUCK
                        + " 秒没动，多半是网络或者页面不让放）—— 先跳过，下一趟再来", "warn");
                    return "失败";
                }
            }
            last = t;
            lastMeasureAt = measuredAt;
            cxTaskNote(att, cxClock(t) + " / " + cxClock(total())
                + (rate > 1 ? " · 实测 " + effectiveRate.toFixed(1) + " 倍" : ""),
            total() ? t / total() * 100 : -1);
            // 到点收工也在这儿认一次：一个 40 分钟的视频不能等它放完才停。看过的那段播放器已经报了
            if (cxTimeUp()) {
                resume.unarm(); pace.unarm();         // 先摘监听再暂停,免得把自己按的暂停又按回去
                resume.selfPause();
                logMsg("视频「" + name + "」放到 " + cxClock(t) + " 时到点收工了，就停在这儿", "warn");
                return "跳过";
            }
        }
        resume.unarm(); pace.unarm();
        if (!again && !cxJobBare(att) && !await cxWaitJobFinished(att, frame, report)) {
            logMsg("视频「" + name + "」已播放完，但 " + CX_JOB_CONFIRM_WAIT + " 秒内没有收到学习通任务完成确认；停在当前页，不标记完成", "warn");
            return "未确认";
        }
        logMsg("「" + name + "」放完了" + (!cxJobBare(att) ? "（学习通已确认任务完成）" : "（非任务点）"));
        return "已完成";
    }

    // 章节测试：题目页已经被超星真渲染在页面上了，脚本头 @match *://*/*、没有 @noframes，
    // 油猴往那一帧里也注了一份，「超星章节测验」答题模块自己在里面填、开了「自动提交」还会自己交。
    // 所以这儿不亲自答题（参考实现是自己答的，我们已经有一套答题引擎），只等它答完 / 交完再往下翻 ——
    // 翻早了题目页就没了。等的时长按题数给：一题 30 秒，至少 CX_QUIZ_WAIT 秒。
    async function cxWaitQuiz(att, fr, name) {
        let n = 0;
        try { n = fr.contentWindow.document.querySelectorAll(".TiMu").length; } catch (e) { n = 0; }
        const wait = Math.max(CX_QUIZ_WAIT, n * 30);
        cxTaskMark(att, "就地答");
        const subMode = String(cxSet("submit_mode") || "off");
        if (subMode !== "auto") {
            logMsg("章节测试「" + name + "」:提交方式=" + (subMode === "save" ? "仅保存答案不提交" : "关闭")
                + " —— 题会填上,但不会自己交;等满 " + Math.ceil(wait / 60) + " 分钟就翻走了,要交得自己回来交。想全自动就把「提交方式」调成「自动提交」", "warn");
        }
        logMsg("章节测试「" + name + "」：题目页已在页面上（" + n + " 题），答题模块正在就地答"
            + (subMode === "auto" ? ",正确率达标会自己交卷" : subMode === "save" ? ",答案会存成草稿,不自动交" : "") + ";最多等 " + Math.ceil(wait / 60) + " 分钟");
        let gone = 0;
        for (let i = 0; i < wait; i++) {
            await sleep(1000);
            if (cxTimeUp()) {
                logMsg("章节测试「" + name + "」答到一半到点收工了，就停在这儿", "warn");
                return "跳过";
            }
            let d = null;
            try { d = fr.isConnected ? fr.contentWindow.document : null; } catch (e) { d = null; }
            if (d && cxQuizDone(d)) {
                logMsg("章节测试「" + name + "」显示已完成");
                return "已完成";
            }
            // 交卷后超星会把题目页换掉：帧不在了，或者换成一页没有题目的。重载那一瞬间也是空的，
            // 所以连着两拍都这样才算
            if (!d || !d.querySelector(".TiMu")) {
                if (++gone >= 2) {
                    logMsg("章节测试「" + name + "」的题目页换掉了（多半交完卷了）");
                    return "已完成";
                }
            } else {
                gone = 0;
            }
        }
        logMsg("章节测试「" + name + "」等了 " + Math.ceil(wait / 60) + " 分钟还没显示完成："
            + (subMode === "auto" ? "多半有没搜到答案的题,正确率没到自动提交那道阈值 —— 回这一页看一眼再手交"
                : "提交方式不是自动提交,题填好了要自己交") + "。先往下走", "warn");
        return "填好了待交";
    }

    // 文档 / PPT / 图书 / 链接（参考实现的 JobRunner.read / readPPTWithAudio / timereader / hyperlink）
    async function cxReadJob(f, name) {
        const h = f.hit, win = cxPage(f.frame.contentWindow);
        logMsg("正在学习「" + name + "」");
        if (h.read) {
            // 文档：页面自己带着 finishJob，调一下就算看完
            try { if (typeof win.finishJob === "function") win.finishJob(); } catch (e) {}
            await sleep(3000);
        } else if (h.ppt) {
            // 带音频的 PPT：一页页往后翻，音频静音
            try {
                f.doc.querySelectorAll("audio").forEach(a => a.addEventListener("play", () => { a.muted = true; }));
            } catch (e) {}
            const n = f.doc.querySelectorAll(".swiper-container .swiper-slide").length;
            for (let i = 0; i < n; i++) {
                try { if (typeof win.swiperNext === "function") win.swiperNext(); } catch (e) {}
                await sleep(1000);
            }
            await sleep(3000);
        } else if (h.timer) {
            // 长时阅读（图书）：地址里的 timing 是要停留的秒数，参考实现按 (timing+3)×3 秒等
            let timing = 60;
            try {
                timing = parseInt(new URL(h.timer.getAttribute("src") || "", location.href).searchParams.get("timing"), 10) || 60;
            } catch (e) {}
            const secs = (timing + 3) * 3;
            logMsg("「" + name + "」是长时阅读，要停留约 " + Math.ceil(secs / 60) + " 分钟，这一页别切走");
            for (let i = 0; i < secs; i++) {
                await sleep(1000);
                if (cxTimeUp()) return "跳过";
            }
        } else if (h.link) {
            // 链接：点一下算看过，但别真跳走（先把 onclick 换成 return false）
            const a = h.link, old = a.onclick;
            a.onclick = () => false;
            a.click();
            a.onclick = old;
            await sleep(3000);
        }
        return "已完成";
    }

    // 一个找到了的任务点该不该动、怎么动。返回面板那一栏的状态文字。
    // 跟旧那道闸一个口径：卡片说已完成（isPassed）就不动，复习模式才重做；卡片两样都没标
    // （cxJobBare）要「强制学习」或「复习模式」才动。章节测试例外 —— 只看题目页那块牌子。
    async function cxDoFound(f, top) {
        const att = f.att, h = f.hit, name = cxJobName(att);
        const restudy = cxSet("cx_restudy"), force = cxSet("cx_force_learn");
        const done = cxJobDone(att), bare = cxJobBare(att);
        if (h.quiz && !h.media) {
            if (!cxSet("cx_do_quiz")) {
                logMsg("章节测试「" + name + "」：「就地答章节测试」关着，不等它答完就往下翻");
                return "跳过";
            }
            if (cxQuizDone(f.doc)) {
                logMsg("章节测试「" + name + "」已完成");
                return "已完成";
            }
            if (bare && !force) {
                logMsg("章节测试「" + name + "」卡片上没标任务点，不等它；要做的话开「强制学习」");
                return "非任务点";
            }
            return cxWaitQuiz(att, f.frame, name);
        }
        if (done && !restudy) return "已完成";
        if (bare && !force && !restudy) return "非任务点";
        if (h.media) {
            if (!cxSet("cx_do_video")) return "跳过";
            if (att.videoFaceCaptureEnc) cxFaceWarn(name);
            const report = cxWatchJobReport(cxPage(f.frame.contentWindow));
            try {
                return await cxPlayMedia(att, f.doc, name, top, f.frame, report);
            } finally {
                report.restore();
            }
        }
        const set = h.link ? "cx_do_link" : h.timer ? "cx_do_book" : "cx_do_document";
        if (!cxSet(set)) return "跳过";
        return cxReadJob(f, name);
    }

    // 闯关模式（侧边栏带小旗子）下，章节测试没过超星就不放人进下一章，PCount.next 按了也白按，
    // 页面会一遍遍重进同一章。参考实现的 isStuckInBreakingMode：同一章进到第三回就认定卡住，别再翻了。
    // 计数存 GM（参考实现存在标签页里）—— 所以带个时间戳，隔了 CX_RUN_GAP 就从头数，免得上周的次数
    // 把今天第一次进这一章判成"卡住"。
    function cxStuckBreaking(d) {
        if (!d.querySelector(".catalog_points_sa,.catalog_points_er")) return false;
        const act = d.querySelector(".posCatalog_active");
        const id = act && act.getAttribute("id");
        if (!id) return false;
        let c = null;
        try { c = JSON.parse(GM_getValue("cx_chapter_counter") || "null"); } catch (e) { c = null; }
        if (!c || !c.n || Date.now() - (c.t || 0) > CX_RUN_GAP) c = { n: {} };
        c.t = Date.now();
        c.n[id] = (c.n[id] || 0) + 1;
        let stuck = false;
        if (c.n[id] >= 3) {
            c.n[id] = 1;
            stuck = true;
        }
        GM_setValue("cx_chapter_counter", JSON.stringify(c));
        return stuck;
    }

    // 这一页做完了，往下走。参考实现默认的 mode:"next"：调超星自己的 PCount.next（学习页「下一节」
    // 那个按钮调的就是它）—— 这一章还有下一个标签页就翻标签页，没有就进下一章。章节测试常在同一章
    // 的另一个标签页上，走这条路它才会被超星真渲染出来：旧架构翻不过去的就是这一步。
    async function cxStudyNext(top) {
        const d = top.document;
        const tabs = d.querySelectorAll(".prev_ul li");
        const finalTab = !tabs.length || /(^|\s)active(\s|$)/.test(tabs[tabs.length - 1].className || "");
        const sel = d.querySelectorAll(".posCatalog_select");
        const lastSel = sel.length ? sel[sel.length - 1] : null;
        const finalChapter = !!(lastSel && /posCatalog_active/.test(lastSel.className || ""));
        if (finalTab && cxStuckBreaking(d)) {
            logMsg("闯关模式（侧边栏带小旗子）：同一章已经进了三回还过不去 —— 多半是章节测试没过，"
                + "超星不放人进下一章。把这一章的测试做完（或看一眼为什么没交上去），再手动点下一章", "warn");
            cxProgress("卡在闯关模式：这一章的章节测试没过");
            return;
        }
        if (finalTab && finalChapter) {
            const left = cxChapterInfos(d).filter(c => c.unfinished > 0);
            cxProgress("全部章节处理完毕", 100);
            logMsg(left.length
                ? "已经到最后一章了，但侧边栏上还有 " + left.length + " 章标着待完成（"
                    + left.slice(0, 3).map(c => "「" + c.name + "」").join("") + (left.length > 3 ? "…" : "")
                    + "）—— 多半是那几章的章节测试没交上去、或者视频卡住跳过了。按 F5 刷新会从第一个没完成的章重新开始"
                : "全部任务点已完成！侧边栏的对勾是整页加载时画的，按 F5 刷一下能看到最新的");
            return;
        }
        const cid = d.querySelector("#curChapterId"), crs = d.querySelector("#curCourseId"),
            clz = d.querySelector("#curClazzId");
        const tw = cxPage(top);
        if (cid && crs && clz && tw.PCount && typeof tw.PCount.next === "function") {
            try { tw._preChapterId = cid.value; } catch (e) {}
            const act = d.querySelector(".posCatalog_active");
            if (act && act.scrollIntoView) act.scrollIntoView({ block: "center" });
            await sleep(200);
            tw.PCount.next(String(tabs.length), cid.value, crs.value, clz.value, "");
            return;
        }
        // 版式里没有 PCount（或者那三个隐藏字段）：退回 参考实现的 mode:"job" —— 点侧边栏里的下一章
        const chapters = cxChapterInfos(d);
        const hasPendingCounts = chapters.some(c => c.unfinished > 0);
        const list = hasPendingCounts ? chapters.filter(c => c.unfinished > 0 || c.active) : chapters;
        const nx = list[list.findIndex(c => c.active) + 1];
        const node = nx && d.getElementById("cur" + nx.id);
        const link = node && (node.querySelector(".posCatalog_name") || node.querySelector('[onclick^="getTeacherAjax"]'));
        if (link && typeof link.click === "function") {
            link.click();
            return;
        }
        logMsg("找不到往下翻的办法（页面上没有 PCount.next，侧边栏也点不动）—— 请手动点下一节，"
            + "脚本会在新的一页上接着做", "warn");
    }

    // 正文帧（/knowledge/cards）里的那一趟（参考实现的 study）。每翻一页都是一次新的页面加载，
    // 脚本从头跑这个函数：找任务点 → 一个个做 → 翻页。什么都不跨页记（定时停止除外，见 cxArm）。
    async function cxStudyFrame(top) {
        cxRelayTo = top;
        if (document.readyState === "loading") {
            await new Promise(r => document.addEventListener("DOMContentLoaded", r, { once: true }));
        }
        // 等顶层调度那边定好从哪一章开始（它可能要把正文换到别的章，这一页就白做了），最多等 30 秒
        for (let i = 0; i < 30 && !cxPage(top).cxStudyReady; i++) await sleep(1000);
        // 等页面自己那段内联脚本把 attachments 挂上去、播放器 / 题目页的子帧加载起来（参考实现也是先睡 3 秒）
        await sleep(3000);
        const limit = cxArm();
        const d = top.document;
        const chs = cxChapterInfos(d);
        const ci = chs.findIndex(c => c.active);
        const ch = ci >= 0 ? chs[ci] : null;
        const tabs = d.querySelectorAll(".prev_ul li");
        let ti = -1;
        [].forEach.call(tabs, (t, i) => { if (/(^|\s)active(\s|$)/.test(t.className || "")) ti = i; });
        const where = "章节「" + (ch ? ch.name : "?") + "」" + (tabs.length > 1 ? "第 " + (ti + 1) + "/" + tabs.length + " 页" : "");
        const q = { chapterName: ch ? ch.name : "" };
        if (chs.length && ci >= 0) {
            cxProgress("第 " + (ci + 1) + "/" + chs.length + " 章 · " + ch.name, Math.round(ci / chs.length * 100));
        }
        const pw = cxPage(unsafeWindow);
        const mArg = cxReadMArg();
        const atts = [].slice.call((pw.attachments && pw.attachments.length ? pw.attachments
            : mArg && mArg.attachments) || []).filter(Boolean);
        logMsg((ci >= 0 ? "[" + (ci + 1) + "/" + chs.length + "] " : "") + where + "："
            + (atts.length ? atts.length + " 个任务点，在页面上逐个找" : "这一页没有任务点"));
        for (const a of atts) cxTask(a, "待做", q);
        // 找任务点的节奏照抄 参考实现：找到就做，做完隔 1 秒再找；没找到先按任务点个数多给几次机会
        // （子帧是异步加载的），再给一个 3+2n 秒（最多 10 秒）的总窗口，过了就算这一页找完了。
        const seen = [], got = {};
        let unfinishedTaskFailed = false;
        let left = atts.length;
        const until = Date.now() + Math.min(3 + atts.length * 2, 10) * 1000;
        while (true) {
            if (cxTimeUp()) {
                cxDisarm();
                logMsg("到了设定的停止时间（" + limit + " 分钟），停在这一页，不再往下翻。刷新页面会重新开始计时", "warn");
                cxProgress("已到定时停止");
                return;
            }
            const f = cxSearchJob(document, atts, seen);
            if (f) {
                cxTask(f.att, "进行中", q);
                let st;
                try {
                    st = await cxDoFound(f, top);
                } catch (e) {
                    st = "失败";
                    logMsg("任务点「" + cxJobName(f.att) + "」出错：" + ((e && e.message) || e), "warn");
                }
                got[cxTaskKey(f.att) || cxJobId(f.att)] = st;
                cxTask(f.att, st, q);
                if (!cxJobBare(f.att) && (st === "失败" || st === "未确认")) unfinishedTaskFailed = true;
                await sleep(1000);
            } else if (left > 0) {
                left--;
                await sleep(1000);
            } else if (Date.now() < until) {
                await sleep(1000);
            } else {
                break;
            }
        }
        // 任务卡存在但内容帧没有匹配上时，保留未完成状态并在下方阻止自动翻页。
        const miss = [];
        for (const a of atts) {
            if ((cxTaskKey(a) || cxJobId(a)) in got) continue;
            if (cxJobDone(a) && a.type !== "workid") { cxTask(a, "已完成", q); continue; }
            cxTask(a, cxJobBare(a) ? "非任务点" : "跳过", q);
            if (!cxJobBare(a)) miss.push("「" + cxJobName(a) + "」（" + a.type + "）");
        }
        if (miss.length) {
            logMsg("页面上没找到这几个未完成任务点对应的内容帧：" + miss.join("、") + "；请确认任务是否加载完成", "warn");
        }
        const tally = {};
        Object.keys(got).forEach(k => { tally[got[k]] = (tally[got[k]] || 0) + 1; });
        logMsg("这一页：" + (Object.keys(tally).length
            ? Object.keys(tally).map(k => k + " " + tally[k] + " 个").join("，") : "没有能做的任务点"));
        if (unfinishedTaskFailed || miss.length) {
            logMsg("本页仍有未确认完成或未识别的任务点，已暂停自动翻页；检查当前页面后再继续", "warn");
            cxProgress("任务点未确认，已暂停翻页");
            return;
        }
        try { cxPage(top)._preChapterId = ""; } catch (e) {}
        if (!cxSet("cx_auto_next")) {
            logMsg("这一页做完了。「自动跳章」关着，停在这儿");
            return;
        }
        logMsg("这一页做完了，5 秒后翻到下一页");
        await sleep(5000);
        if (cxTimeUp()) {
            cxDisarm();
            logMsg("到了设定的停止时间（" + limit + " 分钟），不再往下翻", "warn");
            return;
        }
        await cxStudyNext(top);
    }

    // 收掉死了的帧面板（心跳见 showPanel）。只动带心跳的那些 —— 顶层自己那份没有心跳，永远不碰。
    // 门槛放到 150 秒：标签页在后台时 Chrome 会把计时器压到一分钟一次，门槛太紧会把正在答题的
    // 那份当成死的收掉（收掉也只是看不见，那一帧里的答题照样在跑）。
    const CX_PANEL_DEAD = 15e4;
    function cxSweepPanels(doc, now) {
        let n = 0;
        for (const el of (doc || document).querySelectorAll("#panelNode")) {
            const b = parseInt(el.dataset && el.dataset.cxBeat, 10);
            if (b && (now || Date.now()) - b > CX_PANEL_DEAD) { el.remove(); n++; }
        }
        return n;
    }

    // 顶层学习页那一份（参考实现的 studyDispatcher）：挂面板、收正文帧转来的消息、开局跳到
    // 第一个有待完成任务点的章。干活的不是它 —— 它定好起点就举旗（cxStudyReady），正文帧那边才开工。
    async function cxStudyDispatch() {
        const pw = cxPage(unsafeWindow);
        setInterval(() => cxSweepPanels(document), 3e4);
        // 正文帧转来的日志 / 任务行 / 进度。只收同源、只收那三类；tip 只收日志那一半 ——
        // 它的 type 字段在面板那边是副作用指令（jump/stop/hidden），不许跨帧带过来
        window.addEventListener("message", e => {
            const m = e.data;
            if (!m || m.cxRelay !== 1 || e.origin !== location.origin || !CX_RELAY_TYPES[m.type]) return;
            const p = m.message || {};
            iframeMsg(m.type, m.type === "tip" ? { tip: String(p.tip || ""), level: p.level, logOnly: true } : p);
        });
        keepTabAwake();   // 整门课要跑很久，最小化被节流就等于停了（整个标签页算一份，正文帧也跟着受益）
        const limit = cxArm();
        const s = new URLSearchParams(location.search);
        const q = {
            courseId: s.get("courseId") || s.get("courseid") || "",
            classId: s.get("clazzid") || s.get("classId") || s.get("clazzId") || ""
        };
        logMsg("学习通刷课开始（参考实现那套：右边正文这一页自己做完、再让超星翻到下一页；课程 "
            + (q.courseId || "?") + " / 班级 " + (q.classId || "?")
            + (cxStopAt ? " / " + new Date(cxStopAt).toLocaleTimeString() + " 自动收工" : "")
            + "）");
        try {
            if (!cxSet("cx_auto_next")) {
                logMsg("「自动跳章」关着：只做右边眼前这一页，做完停在那儿");
            } else if (cxSet("cx_restudy")) {
                logMsg("复习模式：从右边眼前这一章往下一页页重看，不跳到别的章");
            } else {
                // 侧边栏是异步画的，等它最多 10 秒
                let chs = [];
                for (let i = 0; i < 10 && !chs.length; i++) {
                    chs = cxChapterInfos(document);
                    if (!chs.length) await sleep(1000);
                }
                const todo = chs.filter(c => c.unfinished > 0);
                if (!chs.length) {
                    logMsg("侧边栏读不到章节（版式不认识？）—— 就从右边这一页开始往下做", "warn");
                } else if (!todo.length) {
                    logMsg("侧边栏上每一章都没有待完成的任务点了 —— 这门课多半已经刷完；要重看一遍开「复习模式」");
                } else {
                    logMsg("共 " + chs.length + " 章，其中 " + todo.length + " 章还有待完成任务点，从「" + todo[0].name + "」开始");
                    if (!todo[0].active && !cxShowChapter(todo[0].id, q)) {
                        logMsg("换不到「" + todo[0].name + "」（页面上没有 getTeacherAjax）—— 就从右边这一页开始", "warn");
                    }
                }
            }
        } finally {
            // 不管上面哪一步出了事都得举旗，否则正文帧要白等 30 秒
            pw.cxStudyReady = Date.now();
        }
    }

    // 两处入口，对应 参考实现的两个脚本：顶层学习页只调度，正文帧干活。
    // 顶层那份只在顶层窗口起（不然嵌套的页面各起一个面板）。
    if (location.host.includes("chaoxing")
        && /\/mycourse\/studentstudy/.test(location.pathname)
        && window.top === window.self) {
        setTimeout(() => {
            showPanel("学习通刷课");
            cxStudyDispatch();
        }, 3e3);
    }
    // 正文帧那份只在「学习页里的正文帧」起：单独打开的 /knowledge/cards 没有侧边栏、也翻不了页
    if (location.host.includes("chaoxing")
        && /\/knowledge\/cards/.test(location.pathname)
        && window.top !== window.self) {
        const cxTop = cxStudyTop();
        if (cxTop) cxStudyFrame(cxTop);
    }
    // ══ 智慧树共享课刷课 ══════════════════════════════════════════════════
    // 和上面超星那条旧的接口上报路不是一回事:超星的上报是客户端签名的,盐嵌在它自己的
    // 播放器里,可以不真解码、按 60 秒一条把序列重放出来;智慧树没有这种可伪造的接口,
    // 进度只能靠播放器自己报。所以这里只能:把目录里每个没看完的章节点开,等播放器出来,
    // 驱动它一直放到 ended,再点下一个。它一停,智慧树就认为这一节没看完,时间不累计。
    //
    // 骨架抄 参考实现(,MIT)的 ZHSProject:目录怎么找、打勾怎么认、倍速走播放器自己的菜单
    // 而不是直接设 playbackRate,都是它那儿来的。参考实现靠桌面端 playwright 点,这里直接
    // 在当前页面点,省掉那一整层。
    //
    // 全自动是一厢情愿:视频中途会弹随堂测验(playTopic-dialog)、偶尔蹦验证码、也可能被
    // 人手动暂停。这些都会把进度卡住,所以每一节都判"多久没动":超时就明说卡在哪儿然后
    // 放弃这一节(智慧树没有"假装看完"的接口)。验证码只挂顶栏提醒,绝不自己点 —— 那是
    // 给人输的。随堂测验按 zhs_quiz 设置:pause 停下等你答(等多久都行,不算卡住),
    // close 只点关闭不答题。
    // zhsRows 已拆成"按版式 scope 取行"。scope 由 zhsDetect() 在开工时判定一次并缓存;
    // 引擎其它函数(zhsItems/zhsDone/zhsName)都吃同一个 scope,这样"这一趟"从头到尾
    // 用同一份目录逻辑,不会因为目录长到一半重判一次、把版式判换了。
    // 每个 scope 对应一类页面(参考实现的脚本表一一对过):
    //   child     → 新版共享课学习页(studyplush5 / studywisdomh5):参考实现gxk-study 的 StudyPlusH5,
    //                目录行 .child-main(父级带 .child-time)。点目录行驱动。
    //   gxk       → 旧版共享课目录(studyvideoh5 的 /videoStudy 和 2026 年的 /stuStudy 新路由):
    //                参考实现StudyVideoH5,目录行 li.clearfix.video。目录行处理器 videoClick 查
    //                isTrusted,点不得 —— 走播放器的 playerNext(同 tree,见 zhsRunByNext)。
    //   tree      → 2025-12 智慧慕课(wisdom-mooc/study 或 study/index):参考实现zhs.wisdom.study 的
    //                WishdomH5 = .chapter-content .chapter-content-second 叶子。
    //   ai        → 新形态课程(smartcoursestudent / ai-smart-course-student-pro 的 /learnPage):
    //                参考实现zhs.smart.study,目录折叠 .section-item-collapse-info + 卡片流。
    //   filelist  → 校内课/翻转课(aidedteaching/sourceLearning)和 hike v1(tools-hike):
    //                参考实现xnk-study / hike 都是 .file-item 平铺清单。
    //   hike2     → hike 新目录(polymas agent-course-full 的 /stu/study/resource-detail):
    //                参考实现HikeV2 = .el-tree-node 树,叶子是没子级的 node,已完成 = label.success。
    function zhsRowsFor(scope) {
        const d = document;
        if (scope === "child") {
            // 新版共享课(studyplush5/studywisdomh5)目录行是 .child-main(父级带 .child-time)。
            // 旧版 li.clearfix.video 以前是这里的退路,第 61 轮拆成独立的 gxk:那种页的目录行
            // 点不得(见 zhsRunByNext),而 child 这条路是点目录的,退过去就是撞闸 —— 探针没认出
            // gxk 而兜底成 child 时,宁可"找不到目录,不动"。
            return Array.from(d.querySelectorAll(".child-main"))
                .filter(el => el.parentElement && el.parentElement.querySelector(".child-time"));
        }
        if (scope === "gxk") return Array.from(d.querySelectorAll(".clearfix.video"));
        if (scope === "tree") {
            // 智慧慕课(2025-12,wisdom-mooc/study,参考实现WishdomH5):章节目录 .chapter-item,
            // 叶子是它里面的 .chapter-content-second;没有子级的 item 本身就是行。
            const out = [];
            for (const item of Array.from(d.querySelectorAll(".chapter-content .chapter-item"))) {
                const leaves = item.querySelectorAll(".chapter-content-second");
                if (leaves.length) out.push.apply(out, Array.from(leaves));
                else out.push(item);
            }
            return out;
        }
        if (scope === "ai") {
            // 智慧课程-AI(fusioncourseh5)可能是资源卡片目录,也可能沿用共享课视频行。
            // OCS 的 FusionCourseH5 按 .resources-item 切资源,并在 .clearfix.video 下
            // 识别有 resource-box 的视频章节;旧式页面则仍用 .clearfix.video。
            if (location.hostname === "fusioncourseh5.zhihuishu.com") {
                const resourceMode = !!d.querySelector(".resource-box");
                if (resourceMode) {
                    const resourceCards = Array.from(d.querySelectorAll(".resources-item"));
                    if (resourceCards.length) return resourceCards;
                }
                const videoRows = Array.from(d.querySelectorAll(".clearfix.video"));
                if (videoRows.length) {
                    if (!resourceMode) return videoRows;
                    return videoRows.filter(el => el.querySelector(".resource-box"));
                }
            }
            // 新形态:点开章节后正文是一屏卡片流,卡片就是任务点。
            const cards = Array.from(d.querySelectorAll('[class*="card-container"]'));
            if (cards.length) return cards;
        }
        if (scope === "filelist" || scope === "hike")
            return Array.from(d.querySelectorAll(".file-item"));
        if (scope === "hike2") {
            // 树目录:只取叶子(没有子级容器的 .el-tree-node)
            return Array.from(d.querySelectorAll(".el-tree-node")).filter(el => {
                const kids = el.querySelector(".el-tree-node__children");
                return !kids || kids.children.length === 0;
            });
        }
        return [];
    }
    // 待做列表。restudy=false 时把已经打勾的滤掉(只刷没做完的);复习模式(restudy)全要。
    function zhsItems(restudy, scope) {
        const rows = zhsRowsFor(scope);
        if (restudy) return rows;
        return rows.filter(el => !zhsDone(el, scope));
    }
    // 打勾(已完成)的认法随版式走。共享课(scope=child)认两个记号:time_icofinish(旧版
    // 行内)和 finish-icon(新版 .child-main 常把勾挂在父级,这里两种都认)。其它版式
    // (tree/ai/filelist)都是"已完成"小标:行自己带 finish-icon,或父级带(finish-icon 在
    // 某些版式挂在章节容器上),新形态卡片流的已完成标是 .finished-icon。
    function zhsDone(el, scope) {
        if (!el) return false;
        if (scope === "child") {
            // 共享课全家:新版 .child-main 的打勾挂在父级,旧版 time_icofinish 在行内。
            return !!(el.querySelector(".time_icofinish")
                || el.querySelector(".finish-icon")
                || (el.parentElement && el.parentElement.querySelector(".finish-icon")));
        }
        // gxk(旧版共享课行):打勾是行内 b.time_icofinish;看了一半是 el-progress 圆环 + 百分比,不算完成
        if (scope === "gxk") return !!(el.querySelector(".time_icofinish"));
        // tree 叶子(智慧慕课)只看自己:它的父级是整个章节容器,里面还有别的叶子和小节自己的勾,
        // 看父级会把兄弟的勾当成自己的 → 没看的节被当成已完成跳掉。
        if (scope === "tree") return !!(el.querySelector(".finish-icon"));
        // tree 叶子 / filelist 行:打勾是行内 finish-icon;ai 卡片流是 .finished-icon;
        // hike2 树叶子是 label.success。
        if (scope === "hike2")
            return !!(el.querySelector("label.success"));
        if (scope === "ai" && location.hostname === "fusioncourseh5.zhihuishu.com") {
            if ((el.matches && el.matches(".isFinish, .finish-icon, .finished-icon"))
                || el.querySelector(".isFinish, .finish-icon, .finished-icon")) return true;
            const progress = el.querySelector(".progress-num");
            if (progress && /100\s*%/.test(progress.textContent || "")) return true;
            const text = el.querySelector(".resource-text");
            const match = text && (text.textContent || "").replace("必学", "").match(/(\d+)\s*\/\s*(\d+)/);
            return !!(match && Number(match[2]) > 0 && Number(match[1]) >= Number(match[2]));
        }
        return !!(el.querySelector(".finish-icon")
            || el.querySelector(".finished-icon")
            || (el.parentElement && el.parentElement.querySelector(".finish-icon")));
    }
    function zhsName(el, scope) {
        if (!el) return "";
        let t = "";
        if (scope === "hike2") {
            const cur = el.querySelector(".file-name") || document.querySelector(".el-tree-node.is-current .file-name");
            t = (cur && (cur.textContent || "").trim()) || "";
            if (t) return t;
        }
        const e = el.querySelector(".file-name") || el.querySelector(".catalogue_title");
        if (e) t = e.textContent || "";
        if (!t) t = (el.textContent || "").replace(/^\s+/, "");
        return t.replace(/\.\.\.$/, "").trim();
    }
    // 点开这一节后等播放器出现。默认最多约 12 秒(60 拍);智慧慕课页首屏要先拉目录再建播放器,
    // 调用方可以多等几拍。优先认 #container 里的 <video>(智慧慕课的播放器容器),再退到页面上
    // 任何一个 <video>。文档/PDF/外链这类资源永远等不到,调用方据此跳过。
    function zhsWaitForVideo(maxTicks) {
        const max = maxTicks > 0 ? maxTicks : 60;
        return new Promise(resolve => {
            let i = 0;
            const timer = setInterval(() => {
                const v = document.querySelector("#container video") || document.querySelector("video");
                if (v) { clearInterval(timer); resolve(v); }
                else if (++i >= max) { clearInterval(timer); resolve(null); }
            }, 200);
        });
    }
    // 等一个"站稳了"的播放器:同一个 <video> 元素连着 6 拍(3 秒)都还在。旧版共享课页换节后建播放器
    // 不是一步到位的 —— 先出一个 <video>,拿到播放地址后又换一个;认到第一个的话两秒后它就被拆了,
    // zhsWatchVideo 把"被换掉"当"这一节完了"→ 直接按下一节,整本目录被一路按到底(2026-09-18 真机:
    // 「一直只会下一节」)。元素换了就重新数;一直没有就交给 zhsWaitForVideo 的上限(约 40 秒)。
    async function zhsSettledVideo() {
        let v = await zhsWaitForVideo(200);
        if (!v) return null;
        let source = v.currentSrc || v.src || "", duration = v.duration;
        let same = 0;
        for (let tick = 0; same < 6 && tick < 120; tick++) {
            await sleep(500);
            const nv = document.querySelector("#container video") || document.querySelector("video");
            if (nv === v && v.isConnected && (v.readyState == null || v.readyState >= 1)
                && source === (v.currentSrc || v.src || "") && Object.is(duration, v.duration)) { same++; continue; }
            same = 0;
            v = nv || await zhsWaitForVideo(200);
            if (!v) return null;
            source = v.currentSrc || v.src || ""; duration = v.duration;
        }
        return same >= 6 ? v : null;
    }
    // 倍速:直接写 video.playbackRate,绝不点播放器自己的倍速菜单。
    // 智慧慕课(wisdom-mooc)的页面在播放器容器 #container 上挂了一个捕获阶段的 click 监听:
    // isTrusted=false(脚本 .click() 发出来的都是)就弹"检测到异常脚本"、暂停,3 秒后把人踢回
    // 首页 —— 以前那条"点 .speedList 菜单"的路(参考实现的 switchPlaybackRate,它靠 playwright
    // 发的是可信点击)在这里正好撞闸。页面还在 onTime 里查 playbackRate > 1.8 → 同样踢人,
    // 那道闸的边是 1.8(超过就踢人);第 142 轮起脚本不再自己夹 1.5,想稳就自己填 1.5 以内。
    // 播放速度和网站计时速度必须一致。只写媒体属性会造成 1.5 倍播完只记约 66%。
    function zhsMediaRate(v, rate) {
        rate = Math.max(1, Number(rate) || 1);
        const dir = zhsGxkDirectory();
        try {
            const W = (typeof unsafeWindow === "object" && unsafeWindow) || (typeof window === "object" && window);
            const PS = W && W.PlayerStarter;
            const player = PS && typeof PS.get === "function" ? PS.get("container") : null;
            const cb = player && player.callback;
            // 新旧共享课都依赖独立的计时倍率;回调不可用时按正常速度播放。
            if ((dir || document.querySelector(".clearfix.video, .chapter-content")) && (!cb || typeof cb.playbackRate !== "function")) rate = 1;
            const isVideoJs = !!((v.closest && v.closest(".video-js"))
                || document.querySelector("#vjs_container_html5_api"));
            if (isVideoJs) { try { delete v.playbackRate; } catch (ignore) {} }
            const native = player && player.player;
            if (native && typeof native.playbackRate === "function") native.playbackRate(rate);
            else if (Math.abs(v.playbackRate - rate) > 0.001) v.playbackRate = rate;
            if (isVideoJs) {
                const raw = v.ownerDocument && v.ownerDocument.defaultView;
                cxLockPlaybackRate(v, rate, raw && (raw.wrappedJSObject || raw));
            }
            if (cb && typeof cb.playbackRate === "function") {
                // 传实际媒体速度,不改学习时长、不回填任何历史进度。
                if (!dir || Number(dir.vm.playRate) !== v.playbackRate)
                    cb.playbackRate(v.playbackRate);
            }
            // 与网站 onReady / 原生倍速菜单保持相同状态,不触发合成点击。
            if (player && player.options) player.options.rate = v.playbackRate;
            try {
                const label = document.querySelector("#container .speedBox > span");
                if (label) label.textContent = "X " + (v.playbackRate === 1 ? "1.0" : v.playbackRate);
                for (const tab of document.querySelectorAll("#container .speedList .speedTab"))
                    tab.classList.toggle("active", parseFloat(tab.getAttribute("rate")) === v.playbackRate);
            } catch (ignore) {} // 菜单可能正在随播放器一起重建。
            return v.playbackRate;
        } catch (e) {
            const known = dir && Number(dir.vm.playRate);
            const fallback = known >= 1 ? known : 1;
            try { v.playbackRate = fallback; } catch (ignore) {}
            return v.playbackRate;
        }
    }
    function zhsApplyDirect(rate) {
        const v = document.querySelector("#container video") || document.querySelector("video")
            || document.querySelector("audio");
        if (!v) return false;
        try { return zhsMediaRate(v, rate); } catch (e) { return false; }
    }
    // 智慧树使用独立档位；auto 才读取通用视频倍速，避免智慧树选择覆盖其他平台设置。
    function zhsRate() {
        const num = k => { const r = cxSet(k); const n = typeof r === "number" ? r : parseFloat(r); return isFinite(n) ? n : 0; };
        const selected = cxSet("zhs_video_rate");
        if (selected === "1x") return 1;
        if (selected === "1.25x") return 1.25;
        if (selected === "1.5x") return 1.5;
        if (selected === "2x") return 2;
        if (selected === "3x") return 3;
        if (selected === "4x") return 4;
        if (selected === "6x") return 6;
        return Math.max(1, num("cx_video_rate"));
    }
    // 面板上改倍速当场生效的通路：通用设置和智慧树档位都会经过这里。
    // typed 只是用户填的原值,拿来在日志里提示上限;真正推给播放器的是
    // zhsRate()。不在智慧树学习页时只存不推。绝不点播放器菜单:智慧树的播放器
    // 容器上挂着"非可信点击"检测,合成 click 一碰就弹"检测到异常脚本"踢回首页 —— 只直接写
    // playbackRate;顶层文档够得着就直设,够不着(跨域帧)才广播给帧代理,zhsWatchVideo 每拍还会钉。
    function zhsPushRate(typed) {
        const rate = zhsRate();
        const tip = Number(typed) > 1.5 ? "(智慧树播放器菜单封顶 1.5,超过 1.8 页面判异常踢人)" : "";
        if (!zhsHosts()) {
            logMsg("智慧树倍速改成 " + rate + " 倍,已存 —— 进智慧树学习页后生效" + tip);
            return;
        }
        const direct = zhsApplyDirect(rate);              // 顶层文档里的播放器,直设
        const sent = direct ? 0 : cxRateBroadcast(rate);   // 跨域帧兜底(下一拍生效)
        const zhead = direct ? "已直设页面上的播放器(刷课时每拍还会钉一次)"
            : sent ? "播放器在跨域框架里,已向 " + sent + " 个帧发倍速广播(跨域,下一拍生效)"
            : "页面上还没有播放器,下一节开始时生效";
        logMsg("智慧树倍速改成 " + rate + " 倍," + zhead + tip
            + (direct && Math.abs(direct - rate) > 0.001 ? ";网站计时暂不能同步,实际按 " + direct + " 倍播放" : ""));
    }
    // 关掉可能挡着播放器的弹层(学前必读 / 公告 / 习惯分提示之类)。旧版 element-ui 是
    // .el-dialog__wrapper;智慧慕课(element-plus)是 .el-overlay —— 只碰带关闭按钮的,随堂测验
    // 那个弹窗(.ai-class-exercise-dialog,交给答题器)和"检测到异常脚本"那个不碰。点的是弹层自己的
    // 关闭按钮,不在播放器容器里,不会撞那道点击检测。
    function zhsDismiss() {
        const wrap = document.querySelector(".el-dialog__wrapper");
        if (wrap) {
            const x = wrap.querySelector(".el-dialog__headerbtn")
                || wrap.querySelector(".el-dialog__close");
            if (x) { try { x.click(); } catch (e) {} return true; }
        }
        for (const ov of Array.from(document.querySelectorAll(".el-overlay"))) {
            if (ov.style && ov.style.display === "none") continue;
            if (ov.querySelector(".ai-class-exercise-dialog")) continue;
            if (/异常脚本/.test(ov.textContent || "")) continue;
            const x = ov.querySelector(".el-dialog__headerbtn") || ov.querySelector(".el-dialog__header img");
            if (x) { try { x.click(); } catch (e) {} return true; }
        }
        return false;
    }
    // 随堂测验弹窗。旧版是 #playTopic-dialog;智慧慕课是 .ai-class-exercise-dialog(element-plus
    // 对话框,关着时整个 .el-overlay 是 display:none,所以要看它的遮罩显不显)。返回弹窗元素或 null。
    function zhsQuizOpen() {
        const visible = el => {
            for (let node = el; node; node = node.parentElement) {
                if (node.hidden || node.getAttribute && node.getAttribute("aria-hidden") === "true") return false;
                let style = node.style || {};
                try {
                    const win = node.ownerDocument && node.ownerDocument.defaultView;
                    if (win && win.getComputedStyle) style = win.getComputedStyle(node);
                } catch (e) {}
                if (style.display === "none" || style.visibility === "hidden") return false;
                if (node === document.documentElement) break;
            }
            return !!el;
        };
        const old = document.querySelector("#playTopic-dialog");
        if (old) {
            const overlay = old.closest && old.closest(".el-overlay, .el-dialog__wrapper");
            return visible(old) && (!overlay || visible(overlay)) ? old : null;
        }
        const q = document.querySelector(".ai-class-exercise-dialog");
        const overlay = q && q.closest && q.closest(".el-overlay");
        return q && visible(q) && (!overlay || visible(overlay)) ? q : null;
    }
    const zhsQuizIsAi = q => !!(q && q.classList && q.classList.contains("ai-class-exercise-dialog"));
    // 关随堂测验。返回 true = 已经不在了;false = 还在 —— 点过关闭也可能点不掉(有的课要求必须答),
    // 调用方按返回去数"多少次都关不掉"然后放弃这一节。智慧慕课那个弹窗的叉号在没答题时只会
    // 报"请先答题",压根关不掉 —— 那就不点了,直接算"关不掉",调用方会停下等人。
    function zhsQuizClose() {
        const q = zhsQuizOpen();
        if (!q) return true;
        if (zhsQuizIsAi(q)) return false;
        const btn = q.querySelector(".close-btn") || q.querySelector(".btn");
        if (btn) { try { btn.click(); } catch (e) {} }
        return false;
    }
    // ── 旧版共享课页(gxk)的随堂测验自动答 ──
    // 不点 DOM:选项的 topicClick(option, e) 对 isTrusted=false 的点击是直接忽略,关闭的 closeTest(e)
    // 对 isTrusted=false 弹"异常脚本"。但两处都只认"事件对象":topicClick 的第二个参数里没有
    // isTrusted 字段就走 topicClickQot(option, 2)(正常选中 + 存档那条路,页面自己的「下一节」按钮
    // 也这么调);closeTest 的参数 isTrusted 不是 false 就正常关。所以直接调学习页组件的方法,参数给 {}。
    // 正确答案页面自己带着:弹题接口回来的每个选项有 result(1 = 正确),页面据此算 answerRight、
    // 关窗后显示"正确答案"。单选(questionType.inputType = radio)点正确那个;多选(checkbox)逐个点
    // 正确的 —— topicClickQot 对多选是切换,只点还没点的。closeTest 在没答完时弹"未做答的弹题不能
    // 关闭",所以全部 isCheck 之后才关。
    // 组件实例:Vue 2 把实例挂在组件根元素的 __vue__ 上,学习页组件的根是 .video-study。页面 mounted
    // 时想把一批元素的 __vue__ 屏蔽掉,但清单里 '.video-study' / '.el-dialog__wrapper' 带着点号去
    // getElementById,屏蔽落空;弹窗 #playTopic-dialog 本来也不在清单里。退路:从弹窗的 __vue__
    // (el-dialog 实例)沿 $parent 往上找。
    function zhsQuizVm() {
        const has = vm => !!(vm && typeof vm.topicClick === "function" && typeof vm.closeTest === "function"
            && typeof vm.pageeClick === "function" && vm.topicInfo);
        // 根元素上挂的可能是套在外面的壳(路由视图之类,和学习页组件共用一个根元素时后 mount 的赢),往 $children 找几层
        const dig = (vm, depth) => {
            if (!vm || depth > 3) return null;
            if (has(vm)) return vm;
            const kids = Array.isArray(vm.$children) ? vm.$children : [];
            for (const k of kids) { const r = dig(k, depth + 1); if (r) return r; }
            return null;
        };
        try {
            const root = document.querySelector(".video-study");
            const r = root ? dig(root.__vue__, 0) : null;
            if (r) return r;
            const dlg = document.querySelector("#playTopic-dialog");
            let vm = dlg ? dlg.__vue__ : null;
            for (let i = 0; vm && i < 8; i++, vm = vm.$parent) if (has(vm)) return vm;
        } catch (e) {}
        return null;
    }
    function uploadZhsQuizAnswer(question) {
        const tq = question && question.testQuestion || {};
        const inputType = tq.questionType && tq.questionType.inputType;
        const type = inputType === "radio" ? 0 : inputType === "checkbox" ? 1 : undefined;
        const options = Array.isArray(tq.questionOptions) ? tq.questionOptions : [];
        const right = options.filter(option => option && Number(option.result) === 1);
        if (type === undefined || !tq.name || !right.length || !options.length || (type === 0 && right.length !== 1)) return;
        uploadQuestionBankCandidate({
            question: zhsQuizText(tq.name),
            options: options.map(option => zhsQuizText(option.content)),
            type: type
        }, right.map(option => zhsQuizText(option.content)), "智慧树随堂题标准答案");
    }
    // 返回 true = 答完并关上了;false = 答不了(调用方退成停下等人)。全程不碰任何 DOM 元素。
    async function zhsQuizAutoGxk(quiz, log) {
        const vm = zhsQuizVm();
        if (!vm) { log("找不到学习页的组件实例(页面改了 __vue__ 的挂法?),这道测验答不了,停下等你答", "warn"); return false; }
        const list = vm.topicInfo && vm.topicInfo.lessonTestQuestionUseInterfaceDtos;
        if (!Array.isArray(list) || !list.length) { log("测验数据是空的,答不了,停下等你答", "warn"); return false; }
        let mine = 0;
        for (let i = 0; i < list.length; i++) {
            const q = list[i];
            uploadZhsQuizAnswer(q);
            if (q.isCheck) continue;      // 页面从存档恢复的(zAnswer)或已答的
            const tq = q.testQuestion || {};
            const opts = Array.isArray(tq.questionOptions) ? tq.questionOptions : [];
            const right = opts.filter(x => x && Number(x.result) === 1);
            if (!right.length) {
                log("第 " + (i + 1) + " 题页面没带正确答案(选项里没有 result=1),答不了,停下等你答", "warn");
                return false;
            }
            try { vm.pageeClick(i + 1); } catch (e) {}     // 翻到这一题(topicClickQot 只答 pageList 那题)
            await sleep(rand(300, 700));
            const multi = !!(tq.questionType && tq.questionType.inputType === "checkbox");
            for (const opt of (multi ? right : right.slice(0, 1))) {
                if (multi && opt.isClick) continue;
                vm.topicClick(opt, {});
                await sleep(rand(400, 900));
            }
            mine++;
            await sleep(rand(600, 1400));
        }
        if (list.some(q => !q.isCheck)) { log("有题没答上(页面没记下选择),停下等你答", "warn"); return false; }
        await sleep(rand(800, 1600));
        vm.closeTest({});
        await sleep(300);
        if (vm.testDialog !== false) { log("答完了但弹窗没关上,停下等你", "warn"); return false; }
        log("随堂测验 " + list.length + " 题已自动答完并关闭" + (mine < list.length ? "(其中 " + (list.length - mine) + " 题页面已记有答案)" : ""));
        return true;
    }
    // 新版 Vue 3 生产页面不保留元素上的 __vue__。从已挂载的 VNode 树取弹窗和它的事件,
    // 只调用选项/提交/关闭自己的处理器,不发送播放器容器会拦截的合成点击。
    function zhsTreeNodes(root) {
        const out = [], seen = new Set(), stack = [root];
        while (stack.length && seen.size < 10000) {
            const node = stack.pop();
            if (!node || typeof node !== "object" || seen.has(node)) continue;
            seen.add(node); out.push(node);
            if (node.component) stack.push(node.component.subTree);
            if (node.suspense) stack.push(node.suspense.activeBranch);
            if (Array.isArray(node.children)) stack.push.apply(stack, node.children);
        }
        return out;
    }
    function zhsTreeQuizVm(quiz) {
        const root = document.querySelector("#app");
        for (const node of zhsTreeNodes(root && root._vnode)) {
            const vm = node.component;
            if (!vm || vm.isUnmounted || !vm.type || vm.type.__name !== "AiClassExerciseDialog") continue;
            if (!vm.props || !vm.props.dialog || !vm.props.dialog.visible || !vm.props.args) continue;
            if (zhsTreeNodes(vm.subTree).some(n => n.el === quiz)) return vm;
        }
        return null;
    }
    function zhsQuizIdentity(quiz) {
        if (!zhsQuizIsAi(quiz)) return "";
        const vm = zhsTreeQuizVm(quiz);
        return vm ? JSON.stringify(vm.props.args) : (quiz.textContent || "");
    }
    async function zhsTreeQuizClick(vm, element, useDom = false) {
        if (!element || element.disabled) return false;
        if (useDom) {
            try { element.click(); return true; } catch (e) { return false; }
        }
        const node = zhsTreeNodes(vm.subTree).find(n => n.el === element && n.props && n.props.onClick);
        if (node) {
            const handlers = Array.isArray(node.props.onClick) ? node.props.onClick : [node.props.onClick];
            try {
                for (const fn of handlers) {
                    if (typeof fn !== "function") throw new Error("invalid handler");
                    await fn();
                }
                return true;
            } catch (e) {}
        }
        try { element.click(); return true; } catch (e) { return false; }
    }
    async function zhsTreeQuizData(vm, args) {
        const W = (typeof unsafeWindow === "object" && unsafeWindow) || window;
        if (typeof W.y9x8y7z !== "function") throw new Error("页面题目接口尚未就绪");
        const pinia = vm.appContext && vm.appContext.config && vm.appContext.config.globalProperties.$pinia;
        const keyStore = pinia && pinia._s && pinia._s.get("key");
        let key = keyStore && keyStore.key && keyStore.key[11];
        if (!key) {
            if (typeof W.l0a1b2c !== "function") throw new Error("页面题目接口尚未就绪");
            key = await waitWithTimeout(Promise.resolve().then(() => W.l0a1b2c(11)), 10000, "题目接口初始化超时");
        }
        // 和页面 lessonPopupExam 相同的请求参数与加密入口;只读当前弹窗题目,提交仍走页面按钮。
        const secret = W.y9x8y7z(Object.assign({}, args, { dateFormate: Date.now() }), key);
        return new Promise((resolve, reject) => GM_xmlhttpRequest({
            method: "POST",
            url: "https://studyservice-api.zhihuishu.com/gateway/t/v1/popupAnswer/lessonPopupExam",
            headers: { "Content-Type": "application/x-www-form-urlencoded" },
            data: "secretStr=" + encodeURIComponent(secret) + "&dateFormate=" + Date.now(),
            timeout: 15000,
            onload: res => {
                try {
                    if (res.status < 200 || res.status >= 300) throw new Error("读取随堂题目失败: HTTP " + res.status);
                    const data = JSON.parse(res.responseText);
                    if (Number(data.code) !== 0 || !data.data || !Array.isArray(data.data.lessonTestQuestionUseInterfaceDtos))
                        throw new Error("页面未返回随堂题目,请检查登录状态或页面提示");
                    resolve(data.data.lessonTestQuestionUseInterfaceDtos);
                } catch (e) { reject(e); }
            },
            onerror: () => reject(new Error("读取随堂题目网络失败")),
            ontimeout: () => reject(new Error("读取随堂题目超时"))
        }));
    }
    function zhsQuizText(text) {
        const doc = new DOMParser().parseFromString(String(text || ""), "text/html");
        return (doc.body.textContent || "").replace(/[\s\u200b\ufeff]+/g, " ").trim();
    }
    function zhsQuizPlain(text) {
        return zhsQuizText(text).replace(/\s+/g, "");
    }
    async function zhsQuizAutoTree(quiz, log) {
        const vm = zhsTreeQuizVm(quiz);
        if (!vm) { log("未找到新版随堂检测组件,请手动答题", "warn"); return false; }
        const stamp = JSON.stringify(vm.props.args);
        const active = () => zhsQuizOpen() === quiz && !vm.isUnmounted
            && vm.props.dialog.visible && JSON.stringify(vm.props.args) === stamp && !cxTimeUp();
        const finish = async () => {
            let lastCloseAt = -8;
            for (let i = 0; i < 40; i++) {
                if (cxTimeUp() || JSON.stringify(vm.props.args) !== stamp) return false;
                if (zhsQuizOpen() !== quiz) return true;
                const ready = !!quiz.querySelector(".el-dialog__footer .btn.is-finish");
                const close = quiz.querySelector(".header-icon");
                if (close && (ready || i >= 4) && i - lastCloseAt >= 8) {
                    lastCloseAt = i;
                    await zhsTreeQuizClick(vm, close, true);
                }
                await sleep(250);
            }
            return false;
        };
        try {
            if (quiz.querySelector(".el-dialog__footer .btn.is-finish")) return await finish();
            let items = [];
            for (let i = 0; i < 40 && active(); i++) {
                items = Array.from(quiz.querySelectorAll(".ques-list .item"));
                if (items.length) break;
                await sleep(250);
            }
            if (!active() || !items.length) throw new Error("随堂检测题目尚未加载完成");
            const list = await zhsTreeQuizData(vm, JSON.parse(stamp));
            if (!active()) return false;
            if (list.length !== items.length) throw new Error("题目数量与当前弹窗不一致");
            const used = new Set(), plans = [], nodes = zhsTreeNodes(vm.subTree);
            for (const item of items) {
                const heading = item.querySelector(".question-info");
                const vnode = nodes.find(n => n.el === heading && n.props && n.props.info != null);
                const title = zhsQuizPlain(vnode ? vnode.props.info : heading && heading.textContent);
                const matches = list.filter(q => !used.has(q) && q.testQuestion && zhsQuizPlain(q.testQuestion.name) === title);
                if (!title || matches.length !== 1) throw new Error("无法准确对应当前随堂题目");
                const question = matches[0]; used.add(question);
                const tq = question.testQuestion, type = tq.questionType && tq.questionType.inputType;
                if (type !== "radio" && type !== "checkbox") throw new Error("此随堂题型暂不支持自动作答");
                const options = Array.isArray(tq.questionOptions) ? tq.questionOptions : [];
                const right = options.filter(o => Number(o.result) === 1);
                if (!right.length || (type === "radio" && right.length !== 1)) throw new Error("页面没有提供可用的随堂答案");
                uploadZhsQuizAnswer(question);
                const elements = Array.from(item.querySelectorAll(".option")), mapped = new Set();
                if (elements.length !== options.length) throw new Error("随堂选项尚未完整加载");
                const selections = elements.map(element => {
                    const marker = element.querySelector(".class-question-select");
                    const answer = element.querySelector(".answer");
                    const found = options.filter(o => !mapped.has(o) && marker && answer
                        && (String.fromCharCode(64 + Number(o.sort)) === marker.textContent.trim() || String(o.sort) === marker.textContent.trim())
                        && zhsQuizPlain(o.content) === zhsQuizPlain(answer.innerHTML));
                    if (found.length !== 1) throw new Error("无法准确对应随堂选项");
                    mapped.add(found[0]);
                    return { element: element, marker: marker, want: Number(found[0].result) === 1 };
                });
                plans.push({ type: type, selections: selections });
            }
            // 全部题目都对应无误才开始填;多选先纠正已选项,避免第二次调用把正确选项取消。
            for (const plan of plans) {
                for (const s of plan.selections) {
                    if (!active()) return false;
                    const selected = s.marker.classList.contains("isSelect");
                    if (selected !== s.want && (plan.type === "checkbox" || s.want)) {
                        if (!await zhsTreeQuizClick(vm, s.element, true)) throw new Error("随堂选项点击失败");
                        await sleep(250);
                    }
                }
            }
            if (!active()) return false;
            if (plans.some(p => p.selections.some(s => s.marker.classList.contains("isSelect") !== s.want)))
                throw new Error("页面未记下完整选择,未提交");
            const submit = quiz.querySelector(".el-dialog__footer .el-button.btn");
            if (!await waitWithTimeout(zhsTreeQuizClick(vm, submit, true), 20000, "随堂检测提交超时"))
                throw new Error("随堂检测提交按钮不可用");
            if (!await finish()) throw new Error("随堂检测提交后未关闭,请检查页面提示");
            log("新版随堂检测 " + plans.length + " 题已作答并关闭");
            return true;
        } catch (e) {
            log("新版随堂检测:" + (e.message || String(e) || "自动作答失败") + ",停下等你处理", "warn");
            return false;
        }
    }
    function zhsClock(sec) {
        const s = Math.max(0, Math.floor(sec));
        return Math.floor(s / 60) + ":" + String(s % 60).padStart(2, "0");
    }
    function zhsProgress(text, pct) {
        iframeMsg("progress", { text: text, pct: pct });
    }
    // 验证码:顶栏提醒一次就够,别假装在刷。zhsWatchVideo 每拍都看一眼。
    let zhsCaptchaSaid = false;
    function zhsNoticeCaptcha() {
        if (zhsCaptchaSaid || !document.querySelector(".yidun_popup")) return;
        zhsCaptchaSaid = true;
        logMsg("智慧树弹了验证码,自己输一下再回来 —— 输之前这一节刷不动", "warn");
        zhsProgress("验证码:请手动处理", 99);
    }
    // 一节的主循环:<video> 出来后驱动它直到:放完(ended)/ 播放器被页面换掉(isConnected
    // = false)/ 卡住超时 / 到点收工。全程只碰 v 和 document,守卫能喂假对象真跑。
    // o.rate > 1 时每拍把 playbackRate 钉回去:直设过的值会被页面按回 1(换清晰度、重建播放器),
    // 钉一次只慢 2 秒 —— 这是智慧树倍速唯一的一条腿,不点菜单(见 zhsApplyDirect 的注释)。
    // 返回为什么停:"ended" 放完 / "replaced" 播放器被页面换掉(调用方据此决定是换节了还是同一节
    // 重建了播放器)/ "timeup" 到点 / "stuck" 卡住 / "quiz" 测验关不掉。
    // 随堂测验按 o.quizMode:auto 且这个版式给了答题器(o.quizAuto)就自动答(同一个弹窗只试一次,
    // 答不了退成等人);pause 或没答题器 → 停下等人;close → 点关闭(能点的版式)。
    async function zhsWatchVideo(v, o) {
        let last = -1, still = 0, tick = 0, quizSaid = false, closeTries = 0, autoTried = null;
        let lastMeasureAt = Date.now(), lastMeasureTime = Number(v.currentTime) || 0;
        let rateMismatchSamples = 0, lastRateWarningAt = 0;
        const source = v.currentSrc || v.src || "";
        const log = o.log;
        // 切走焦点 / 最小化时网站播放器会自己 pause()。除了每拍催播(下面 t===last 那支),再挂一个
        // pause 事件复播 —— 事件不走定时器,后台标签被节流时也能及时按回去。弹着测验时那支 hold()
        // 会拦住,别跟"等真人答题"打架(那一拍流程自己会 pause)。
        const resume = cxResumeOnPause(v, null, () => !!zhsQuizOpen());
        resume.arm();
        const pace = cxPaceKeep(v, {
            rate: () => (typeof o.readRate === "function" ? (o.readRate() || 1) : (o.rate || 1)),
            apply: r => zhsMediaRate(v, r), hold: () => !!zhsQuizOpen() });
        pace.arm();
        while (true) {
            await sleep(2e3);
            if (cxTimeUp()) {                            // 顺带刷心跳,同 cxWatchReal
                log("到点收工,这一节看到 " + zhsClock(v.currentTime)
                    + " 就停(真看的时长智慧树已记下,剩下的下次再刷)");
                resume.unarm(); pace.unarm();
                return "timeup";
            }
            zhsNoticeCaptcha();
            cxBgCheck(null);
            if (!v.isConnected || (source && (v.currentSrc || v.src) && source !== (v.currentSrc || v.src))) {
                log("播放器被页面换掉了(看到 " + zhsClock(v.currentTime)
                    + (v.duration > 0 ? " / " + zhsClock(v.duration) : "") + ")");
                resume.unarm(); pace.unarm();
                return "replaced";
            }
            const rate = typeof o.readRate === "function" ? o.readRate() : o.rate;
            zhsMediaRate(v, rate >= 1 ? rate : 1);
            const t = v.currentTime;
            const quiz = zhsQuizOpen();
            if (quiz) {
                lastMeasureAt = Date.now(); lastMeasureTime = t; rateMismatchSamples = 0;
                if (!v.paused && !v.ended && typeof v.pause === "function") { resume.selfPause(); }
                const identity = zhsQuizIdentity(quiz);
                if (o.quizMode === "auto" && typeof o.quizAuto === "function"
                    && (!autoTried || autoTried.element !== quiz || autoTried.identity !== identity)) {
                    autoTried = { element: quiz, identity: identity };
                    log("弹了随堂测验,自动答");
                    let okQ = false;
                    try { okQ = await o.quizAuto(quiz, log); } catch (e) { log("自动答出错:" + e, "warn"); }
                    if (okQ) {
                        autoTried = null; quizSaid = false; still = 0; last = t;
                        if (v.isConnected && !v.ended && v.paused) { const p = v.play(); if (p && p.catch) p.catch(() => {}); }
                        continue;
                    }
                }
                // pause 模式等人答;智慧慕课那个弹窗不答关不掉,close 模式也只能等;auto 在不会答的版式上也等
                if (o.quizMode !== "close" || zhsQuizIsAi(quiz)) {
                    if (!quizSaid) {
                        quizSaid = true;
                        log(o.quizMode === "pause"
                            ? "弹了随堂测验,按设置在等你答 —— 答完它会自己往下走"
                            : o.quizMode === "auto"
                            ? (typeof o.quizAuto === "function"
                                ? "弹了随堂测验,自动答没成,在等你答 —— 答完它会自己往下走"
                                : "弹了随堂测验,这个版式还不会自动答,在等你答 —— 答完它会自己往下走")
                            : "弹了随堂测验,这个版式的弹窗不答题关不掉,在等你答 —— 答完它会自己往下走", "warn");
                    }
                    still = 0; last = t;                 // 等一个真人,不算卡住也不算没动
                    continue;
                }
                if (!quizSaid) { quizSaid = true; log("弹了随堂测验,按设置只点关闭,不答题", "warn"); }
                if (zhsQuizClose()) closeTries = 0;
                else if (++closeTries >= 20) {           // 40 秒都点不掉
                    log("随堂测验的关闭点不掉(这课可能要求必须答),这一节刷不动,先跳过", "warn");
                    resume.unarm(); pace.unarm();
                    return "quiz";
                }
                still = 0; last = t;
                continue;
            }
            autoTried = null; quizSaid = false;
            if (v.ended) {
                log("放完了(" + zhsClock(v.currentTime) + ")");
                resume.unarm(); pace.unarm();
                return "ended";
            }
            const measuredAt = Date.now();
            if (v.paused || v.seeking) {
                lastMeasureAt = measuredAt; lastMeasureTime = t; rateMismatchSamples = 0;
            } else {
                const elapsed = Math.max(0.001, (measuredAt - lastMeasureAt) / 1000);
                const effectiveRate = Math.max(0, (t - lastMeasureTime) / elapsed);
                const targetRate = typeof o.readRate === "function" ? Number(o.readRate()) : Number(o.rate);
                if (targetRate > 1.25 && effectiveRate < targetRate * 0.75) {
                    rateMismatchSamples++;
                    if (rateMismatchSamples >= 3 && measuredAt - lastRateWarningAt >= 30000) {
                        lastRateWarningAt = measuredAt; rateMismatchSamples = 0;
                        log("视频目标 " + targetRate + " 倍，按视频时间实测推进约 "
                            + effectiveRate.toFixed(1) + " 倍；播放器没有达到目标速度", "warn");
                    }
                } else rateMismatchSamples = 0;
                lastMeasureAt = measuredAt; lastMeasureTime = t;
            }
            if (t === last) {
                if (v.paused) { const p = v.play(); if (p && p.catch) p.catch(() => {}); }
                if (++still >= 30) {                     // 60 秒没动(不是测验)
                    log("这一节 60 秒没动(不是测验),跳过 —— 多半是要验证码,或播放器出错", "warn");
                    resume.unarm(); pace.unarm();
                    return "stuck";
                }
            } else {
                still = 0;
            }
            // 进度每 20 秒报一次,别把日志刷成流水(一个 40 分钟的视频 2 秒一拍是 1200 行);
            // 面板「任务」页那一行的分钟数(o.note)跟同一个节奏
            if (t !== last && ++tick % 10 === 0) {
                const clock = zhsClock(t) + (v.duration > 0 ? " / " + zhsClock(v.duration) : "");
                log("@" + clock);
                if (typeof o.note === "function") o.note(clock, v.duration > 0 ? Math.round(t / v.duration * 100) : -1);
            }
            last = t;
        }
    }
    // ── 目录切节与播放器「下一节」(tree 智慧慕课 / gxk 旧版共享课目录)──
    // tree(wisdom-mooc/study/index):目录行的点击处理器(gn)查"最后一个参数是不是 isTrusted=false
    // 的 PointerEvent"(脚本 el.click() 发出来的正是,Edge/Chrome 实测),播放器容器 #container 上
    // 还有一个捕获阶段的 click 监听查 isTrusted —— 两处任一命中都弹"检测到异常脚本"、暂停、
    // 3 秒后踢回智慧树首页。第 57 轮之前 zhsRun 在这一页点目录行、点 .playButton、点 .speedList,
    // 三处全是撞闸。
    // gxk(studyvideoh5 的 /videoStudy 和 /stuStudy,2026-09-18 真机):同一套闸 —— 目录行处理器
    // videoClick(章,i,节,j,小节,k,event) 查 event instanceof PointerEvent && isTrusted===false →
    // notTrustScript;#container 捕获阶段查 isTrusted;测验弹窗的 closeTest 也查 isTrusted(所以
    // 「只关不答」在这一页按「停下等你答」办);每 60 秒还查 XMLHttpRequest / XMLHttpRequest.prototype
    // .open / Element.prototype.addEventListener 是不是原生函数 + window.参考实现在不在(本脚本在这一页
    // 一样不碰)。第 61 轮之前 zhsRun 在这一页 el.click() 目录行 —— 面板一出来就弹"异常脚本"。
    // 两种页面的播放器都是 ableVideoPlayer 6.0:SPA 把回调对象交给它存在 PlayerStarter.get("container")
    // .callback 上,playerNext 就是控制栏「下一节」按下去跑的函数(tree 是 Ls → gn;gxk 是 videoNext →
    // videoClick 不带事件参数),都不过那道检测 —— 页面自己算下一节、自己存这一节的进度、自己在同一个
    // 容器上重建播放器。视频放完页面不会自己往下走(onComplete 是空的),所以要我们按。
    // 进页面时页面会自己装上次看到的那一节(tree 自动播,gxk 是 autostart=false,要我们 play),
    // 我们从它开始:已完成(且不复习)就直接按下一节。
    // 页面当前在放的那一行:tree 是 .current;gxk 是 videoId === lastViewVideoId 的那行带 current_play。
    function zhsCurrent(scope) {
        if (scope === "gxk") return document.querySelector(".clearfix.video.current_play");
        return document.querySelector(".chapter-content .chapter-content-second.current")
            || document.querySelector(".chapter-content .chapter-item.current");
    }
    // 一行的身份:序号 + 名字的文本。换节前后比一下就知道页面有没有真的换过去。
    // gxk 的行文本里带着"看到 72%"那种进度,看着看着就变了 —— 身份只认序号(b.hour)+ 名字,不认整行。
    function zhsRowKey(el, scope) {
        if (!el) return "";
        if (scope === "tree") {
            const num = el.querySelector(".item-num"), name = el.querySelector(".item-name");
            if (num && name) return (num.textContent + " " + name.textContent).replace(/\s+/g, " ").trim();
        }
        if (scope === "gxk") {
            const num = el.querySelector(".hour");
            return ((num ? num.textContent : "") + " " + zhsName(el, scope)).replace(/\s+/g, " ").trim();
        }
        return (el.textContent || "").replace(/\s+/g, " ").trim();
    }
    // ── 面板「任务」页 ──
    // 超星那一路靠 cxTask 往面板推每个任务点(待做 → 进行中 → 已完成),智慧树这一路以前一条都没推,
    // 「任务」页在智慧树页面上永远是"还没扫到任务点",首页那张「当前任务」卡也空着。这里按目录行推:
    // 开工把整本目录推一遍(打勾的算已完成),每节开始标进行中、看的过程中带"分钟数 / 时长"和百分比,
    // 结束按原因标已完成 / 跳过 / 待做。key 用目录序号 + 行身份,同一行从待做走到已完成是同一行在变。
    // 章节名:gxk 的行在 ul.list 里,同一个 ul 开头那个 li.chapter 的 .catalogue_title 就是章名;
    // 别的版式不知道章在哪,空着(面板那边空章节不画那一行小字)。
    function zhsChapter(el, scope) {
        if (!el || scope !== "gxk" || typeof el.closest !== "function") return "";
        const ul = el.closest(".list");
        const c = ul && ul.querySelector(".chapter .catalogue_title");
        return c ? (c.textContent || "").replace(/\s+/g, " ").trim() : "";
    }
    function zhsTaskKey(i, el, scope) {
        return "zhs" + i + ":" + zhsRowKey(el, scope);
    }
    function zhsTaskSet(key, p) {
        iframeMsg("task", Object.assign({ key: key }, p));
    }
    function zhsTaskPushAll(rows, scope, restudy) {
        rows.forEach((el, i) => zhsTaskSet(zhsTaskKey(i, el, scope), {
            kind: "video",
            name: (scope === "gxk" ? zhsRowKey(el, scope) : zhsName(el, scope)) || ("第 " + (i + 1) + " 节"),
            chapter: zhsChapter(el, scope),
            mark: (restudy && zhsDone(el, scope)) ? "复习" : "",
            state: zhsDone(el, scope) ? "已完成" : "待做"
        }));
    }
    // zhsWatchVideo 回来的原因 → 那一行该标成什么。replaced 由调用方自己定(同一节重建播放器还是换节了)。
    const ZHS_TASK_END = { ended: "待确认", stuck: "跳过", quiz: "跳过", timeup: "待做" };
    // 按页面自己的「下一节」。这里只表示调用成功,是否换节还要看目录和媒体状态。
    // PlayerStarter 是播放器脚本挂在页面 window 上的 var,沙箱里得走 unsafeWindow 才看得见。
    function zhsNext() {
        try {
            const W = (typeof unsafeWindow === "object" && unsafeWindow) || (typeof window === "object" && window);
            const PS = W && W.PlayerStarter;
            const p = PS && typeof PS.get === "function" ? PS.get("container") : null;
            const cb = p && p.callback;
            if (!cb || typeof cb.playerNext !== "function") return false;
            const result = cb.playerNext();
            if (result && typeof result.catch === "function") result.catch(() => {});
            return true;
        } catch (e) { return false; }
    }
    // 旧版优先从页面自己的课程目录定位紧邻的下一段视频。保留真实章/节索引,
    // 不把章标题、平时测试当视频;videoClick 仍负责保存进度和检查课程的学习限制。
    function zhsGxkDirectory() {
        const has = vm => vm && typeof vm.videoClick === "function" && Array.isArray(vm.videoList);
        const seen = new Set();
        const find = (vm, depth) => {
            if (!vm || depth > 5 || seen.has(vm)) return null;
            seen.add(vm);
            if (has(vm)) return vm;
            for (const child of (Array.isArray(vm.$children) ? vm.$children : [])) {
                const found = find(child, depth + 1);
                if (found) return found;
            }
            return null;
        };
        try {
            const root = document.querySelector(".video-study");
            let vm = root && find((root.wrappedJSObject || root).__vue__, 0);
            if (!vm) return null;
            const list = [], visibleVideoNames = new Set(zhsGxkVideoRows()
                .map(row => zhsName(row, "gxk").replace(/\s+/g, "").toLowerCase()).filter(Boolean));
            const isPlayable = video => {
                if (!video || video.videoId == null) return false;
                const seconds = Number(video.videoSec || video.videoDuration || video.duration || 0);
                const name = String(video.name || video.videoName || "").replace(/\s+/g, "").toLowerCase();
                return Number.isFinite(seconds) && seconds > 0 || !!name && visibleVideoNames.has(name);
            };
            vm.videoList.forEach((chapter, i) => {
                (Array.isArray(chapter.videoLessons) ? chapter.videoLessons : []).forEach((lesson, j) => {
                    const smalls = Array.isArray(lesson.videoSmallLessons) ? lesson.videoSmallLessons : [];
                    if (smalls.length) {
                        smalls.forEach((small, k) => {
                            if (isPlayable(small)) list.push({ video: small, args: [chapter, i, lesson, j, small, k] });
                        });
                    } else if (isPlayable(lesson)) {
                        list.push({ video: lesson, args: [chapter, i, lesson, j, null, null] });
                    }
                });
            });
            const id = vm.lastViewVideoId;
            if (id == null) return null;
            const current = list.findIndex(item => String(item.video.videoId) === String(id));
            if (current < 0) return null;
            return { vm: vm, from: String(id), list: list, current: current };
        } catch (e) { return null; }
    }
    function zhsGxkNextTarget() {
        const dir = zhsGxkDirectory();
        return dir && dir.list[dir.current + 1]
            ? { vm: dir.vm, from: dir.from, item: dir.list[dir.current + 1] } : null;
    }
    function zhsGxkEarlierTarget() {
        const dir = zhsGxkDirectory();
        if (!dir) return null;
        const rows = zhsGxkVideoRows();
        const index = dir.list.findIndex((item, i) => item.video.isStudiedLesson != null
            ? Number(item.video.isStudiedLesson) !== 1 : !!rows[i] && !zhsDone(rows[i], "gxk"));
        return index >= 0 && index < dir.current
            ? { vm: dir.vm, from: dir.from, item: dir.list[index] } : null;
    }
    function zhsGxkRecord() {
        const dir = zhsGxkDirectory();
        return dir && { vm: dir.vm, id: dir.from, video: dir.list[dir.current].video,
            saved: Number(dir.list[dir.current].video.studyTotalTime) || 0 };
    }
    function zhsTreeRecord() {
        try {
            const el = document.querySelector("#app"), root = el && (el.wrappedJSObject || el);
            for (const node of zhsTreeNodes(root && root._vnode)) {
                const vm = node.component;
                if (!vm || vm.isUnmounted || !vm.type || vm.type.__name !== "VideoCom") continue;
                const pinia = vm.appContext && vm.appContext.config.globalProperties.$pinia;
                const course = pinia && pinia._s.get("courseInfo");
                if (!course || course.lastViewVideoId == null || !Array.isArray(course.videoList)) continue;
                const list = [];
                for (const chapter of course.videoList) for (const lesson of chapter.videoLessons || []) {
                    const smalls = lesson.videoSmallLessons || [];
                    if (smalls.length) for (const small of smalls) list.push({ video: small, lesson: lesson, small: true });
                    else if (lesson.videoId != null) list.push({ video: lesson, lesson: lesson, small: false });
                }
                const id = String(course.lastViewVideoId);
                const item = list.find(x => String(x.video.videoId) === id);
                if (item) return { vm: vm, pinia: pinia, course: course, id: id, recruitId: course.recruitId, video: item.video,
                    lesson: item.lesson, small: item.small, list: list, saved: Number(item.video.studyTotalTime) || 0 };
            }
        } catch (e) {}
        return null;
    }
    async function zhsTreeSaved(record) {
        const W = (typeof unsafeWindow === "object" && unsafeWindow) || window;
        const keys = record.pinia._s.get("key");
        let key = keys && keys.key && keys.key[11];
        if (!key && typeof W.l0a1b2c === "function")
            key = await waitWithTimeout(Promise.resolve().then(() => W.l0a1b2c(11)), 10000, "进度查询初始化超时");
        if (!key || typeof W.y9x8y7z !== "function") throw new Error("进度查询尚未就绪");
        const args = { recruitId: record.recruitId, lessonIds: [record.lesson.id], dateFormate: Date.now() };
        if (record.small) args.lessonVideoIds = [record.video.id];
        const secret = W.y9x8y7z(args, key);
        return new Promise((resolve, reject) => GM_xmlhttpRequest({
            method: "POST", url: "https://studyservice-api.zhihuishu.com/gateway/t/v1/learning/queryStuyInfo",
            headers: { "Content-Type": "application/x-www-form-urlencoded" },
            data: "secretStr=" + encodeURIComponent(secret) + "&dateFormate=" + Date.now(), timeout: 15000,
            onload: res => {
                try {
                    if (res.status < 200 || res.status >= 300) throw new Error("进度查询 HTTP " + res.status);
                    const data = JSON.parse(res.responseText);
                    const bucket = data.data && data.data[record.small ? "lv" : "lesson"];
                    const item = bucket && bucket[String(record.video.id)];
                    if (Number(data.code) !== 0 || !item || ![0, 1, 2].includes(Number(item.watchState))
                        || !Number.isFinite(Number(item.studyTotalTime))) throw new Error("网站未返回本节进度");
                    resolve({ state: Number(item.watchState), saved: Number(item.studyTotalTime) });
                } catch (e) { reject(e); }
            },
            onerror: () => reject(new Error("进度查询网络失败")),
            ontimeout: () => reject(new Error("进度查询超时"))
        }));
    }
    async function zhsConfirmTree(cur, before, log) {
        const key = zhsRowKey(cur, "tree");
        const active = () => !before.vm.isUnmounted && String(before.course.lastViewVideoId) === before.id
            && String(before.course.recruitId) === String(before.recruitId)
            && zhsRowKey(zhsCurrent("tree"), "tree") === key;
        if (!active()) return "moved";
        // onPause 是页面自己的保存入口,只提交它已累计的真实播放记录。
        try {
            const W = (typeof unsafeWindow === "object" && unsafeWindow) || window;
            const player = W.PlayerStarter && W.PlayerStarter.get("container");
            if (player && player.callback && typeof player.callback.onPause === "function") player.callback.onPause();
        } catch (e) {}
        log("视频已播完,正在核对新版网站已保存的进度");
        let saved = null, errorSaid = false;
        for (let i = 0; i < 12; i++) {
            if (cxTimeUp()) return "timeup";
            if (!active()) return "moved";
            if (before.course.isBlackStatus) return "blocked";
            await sleep(5000);
            if (cxTimeUp()) return "timeup";
            if (!active()) return "moved";
            try { saved = await zhsTreeSaved(before); }
            catch (e) {
                if (!errorSaid) { log("暂未读到服务器进度: " + e.message, "warn"); errorSaid = true; }
                continue;
            }
            if (!active()) return "moved";
            if (cxTimeUp()) return "timeup";
            // 完成标与百分比只取服务器响应,不用本地计时提前打的勾。
            before.video.studyTotalTime = saved.saved;
            before.video.isStudiedLesson = saved.state;
            before.video.percentage = saved.state === 1 ? 100 : Math.min(100,
                Math.floor(saved.saved / (Number(before.video.videoSec) || Infinity) * 100));
            if (saved.state === 1) return "confirmed";
            // 保存可能在途,至少给页面 20 秒;每轮查询必须是同一课的同一节。
            if (i >= 3 && saved.saved > before.saved) return "incomplete";
        }
        return saved ? "incomplete" : "unconfirmed";
    }
    // 播放结束只说明媒体走到末尾。先让网站保存真实记录,再读它更新的学习状态。
    async function zhsConfirmRecord(cur, scope, before, log) {
        if (scope === "tree" && before) return zhsConfirmTree(cur, before, log);
        const key = zhsRowKey(cur, scope);
        const same = () => zhsRowKey(zhsCurrent(scope), scope) === key;
        if (scope !== "gxk" || !before) {
            for (let i = 0; i < 20; i++) {
                if (cxTimeUp()) return "timeup";
                if (!same()) return "moved";
                if (zhsDone(zhsCurrent(scope), scope)) return "confirmed";
                await sleep(500);
            }
            return "unconfirmed";
        }
        const vm = before.vm;
        const blocked = () => vm.tipsDialog || vm.backDialog || vm.aberrantDialog || vm.aberrantTimeDialog;
        const busy = () => vm.isSaving === true || vm.saveDataFilish === true;
        const active = () => same() && String(vm.lastViewVideoId) === before.id;
        for (let i = 0; busy() && i < 720; i++) {
            if (cxTimeUp()) return "timeup";
            if (!active()) return "moved";
            if (blocked()) return "blocked";
            await sleep(250);
        }
        if (busy()) return "saving";
        if (!active()) return "moved";
        if (blocked()) return "blocked";
        if (typeof vm.saveDdsjkTimeInWhileFn !== "function" || typeof vm.queryStuyInfo !== "function")
            return zhsDone(zhsCurrent(scope), scope) ? "confirmed" : "unconfirmed";
        log("视频已播完,正在保存并核对网站进度");
        try {
            // 参数同网站换节保存。只提交页面已经累计的记录,不构造上报值。
            const p = vm.saveDdsjkTimeInWhileFn(null, null, null, 4, true);
            if (p && p.catch) p.catch(() => {});
        } catch (e) { return "unconfirmed"; }
        for (let i = 0; busy() && i < 720; i++) {
            if (cxTimeUp()) return "timeup";
            if (!active()) return "moved";
            if (blocked()) return "blocked";
            await sleep(250);
        }
        if (busy()) return "saving";
        for (let i = 0; i < 60; i++) {
            if (cxTimeUp()) return "timeup";
            if (!active()) return "moved";
            if (blocked()) return "blocked";
            if (i % 20 === 0) {
                try { const p = vm.queryStuyInfo(); if (p && p.catch) p.catch(() => {}); } catch (e) {}
            }
            await sleep(500);
            if (cxTimeUp()) return "timeup";
            if (!active()) return "moved";
            if (blocked()) return "blocked";
            // studyTotalTime 是查询响应写回的字段;本地播放计时只改 totalStudyTime。
            // 必须看到保存时长增加,不接受 computeProgree 提前打出的本地勾。
            const current = zhsGxkRecord();
            if (current && current.saved > before.saved) {
                if (Number(current.video.isStudiedLesson) === 1) return "confirmed";
                if (Number(current.video.isStudiedLesson) === 2) return "incomplete";
            }
        }
        const current = zhsGxkRecord();
        return current && current.id === before.id && Number(current.video.isStudiedLesson) === 2
            && current.saved > 0 ? "incomplete" : "unconfirmed";
    }
    function zhsGxkOpenTarget(target) {
        if (!target || String(target.vm.lastViewVideoId) !== target.from) return false;
        try {
            const result = target.vm.videoClick.apply(target.vm, target.item.args);
            if (result && typeof result.catch === "function") result.catch(() => {});
            return true;
        } catch (e) { return false; }
    }
    // 改版后的 studyvideoh5(Vue 生产版)不再把组件实例挂到 DOM 节点上,因此旧版 videoClick
    // 不可用时从目录节点触发页面自己的点击处理器。事件必须由目标文档的 Window 构造。
    function zhsGxkClickRow(row, log) {
        if (!row) {
            if (log) log("目录目标节点为空", "warn");
            return false;
        }
        const el = row.querySelector(".catalogue_title") || row;
        if (!el.isConnected) {
            if (log) log("目录目标节点已脱离页面", "warn");
            return false;
        }
        try {
            const pageWindow = el.ownerDocument && el.ownerDocument.defaultView;
            const MouseEventCtor = pageWindow && pageWindow.MouseEvent;
            if (typeof MouseEventCtor !== "function") throw new Error("页面 MouseEvent 不可用");
            el.dispatchEvent(new MouseEventCtor("click", {
                bubbles: true, cancelable: true, view: pageWindow
            }));
            return true;
        }
        catch (e) {
            if (log) log("目录点击事件派发失败: " + (e && e.message ? e.message : String(e)), "warn");
            return false;
        }
    }
    // 智慧慕课目录不一定在任务行上显示视频时长。按 OCS 的 WishdomH5 结构取叶子;
    // 切换时仍由 zhsTreeAdvanceToVideo 确认目录选中状态和播放器源都已更新。
    function zhsTreeVideoRows() {
        return zhsRowsFor("tree");
    }
    function zhsTreeRowsAfter(current, rows, restudy) {
        if (!current) return rows.filter(row => restudy || !zhsDone(row, "tree"));
        const pos = rows.indexOf(current);
        const after = row => {
            if (pos >= 0) return rows.indexOf(row) > pos;
            try { return !!(current.compareDocumentPosition(row) & 4); }
            catch (e) { return false; }
        };
        return rows.filter(row => after(row) && (restudy || !zhsDone(row, "tree")));
    }
    // 智慧慕课页面的目录点击不在播放器容器内。沿用 ABC 的鼠标事件序列，避免直接调用
    // PlayerStarter.playerNext() 把导航落到目录里的非视频引言/章节项。
    function zhsTreeClickRow(row) {
        if (!row || !row.isConnected) return false;
        try {
            row.scrollIntoView({ behavior: "auto", block: "center" });
            const rect = row.getBoundingClientRect();
            if (!(rect.width > 0 && rect.height > 0)) return false;
            const x = rect.left + rect.width / 2, y = rect.top + rect.height / 2;
            const hit = document.elementFromPoint(x, y);
            const target = hit && row.contains(hit) ? hit : row;
            const base = { bubbles: true, cancelable: true, view: window, clientX: x, clientY: y, button: 0, buttons: 1 };
            target.dispatchEvent(new MouseEvent("mousemove", base));
            target.dispatchEvent(new MouseEvent("mousedown", base));
            target.dispatchEvent(new MouseEvent("mouseup", Object.assign({}, base, { buttons: 0 })));
            target.dispatchEvent(new MouseEvent("click", Object.assign({}, base, { buttons: 0 })));
            return true;
        } catch (e) { return false; }
    }
    async function zhsTreeAdvanceToVideo(current, video, rows, o) {
        const log = o.log;
        const oldIndex = rows.indexOf(current);
        let freshRows = zhsTreeVideoRows();
        for (let i = 0; i < 10 && !freshRows.length; i++) {
            await sleep(200);
            freshRows = zhsTreeVideoRows();
        }
        if (freshRows.length) rows = freshRows;
        const active = zhsCurrent("tree");
        if (active) current = active;
        else if (current && !current.isConnected) {
            const key = zhsRowKey(current, "tree");
            current = rows.find(row => zhsRowKey(row, "tree") === key)
                || (oldIndex >= 0 ? rows[Math.min(oldIndex, rows.length - 1)] : null);
        }
        const quiz = zhsQuizOpen();
        if (quiz) {
            if (o.quizMode === "auto" && typeof o.quizAuto === "function") {
                try { if (await o.quizAuto(quiz, log) && !zhsQuizOpen()) return "retry"; }
                catch (e) { log("切节前自动答出错:" + e, "warn"); }
            }
            log("切节时页面弹了测验,请处理后刷新页面重试", "warn");
            return "blocked";
        }
        const candidates = zhsTreeRowsAfter(current, rows, o.restudy);
        if (!candidates.length) return "end";
        let oldSource = video && (video.currentSrc || video.src || "");
        let tried = 0;
        for (const row of candidates) {
            if (cxTimeUp()) return "timeup";
            tried++;
            const name = zhsName(row, "tree") || "下一条视频";
            if (!zhsTreeClickRow(row)) {
                log("无法切换到视频任务「" + name + "」,已暂停", "warn");
                return "unavailable";
            }
            for (let i = 0; i < 80; i++) {
                if (cxTimeUp()) return "timeup";
                const active = zhsCurrent("tree");
                const selected = active === row || zhsRowKey(active, "tree") === zhsRowKey(row, "tree");
                const nextVideo = document.querySelector("#container video") || document.querySelector("video");
                const source = nextVideo && (nextVideo.currentSrc || nextVideo.src || "");
                if (selected && nextVideo && nextVideo.isConnected && nextVideo.readyState >= 1
                    && source && (nextVideo !== video || source !== oldSource)) return "moved";
                await sleep(250);
            }
            log("目標「" + name + "」未加载出新视频,继续检查后续视频项", "warn");
            current = row;
            video = document.querySelector("#container video") || document.querySelector("video") || video;
            oldSource = video && (video.currentSrc || video.src || "");
        }
        return tried ? "loading" : "end";
    }
    // 真视频行:带时长(mm:ss 的 .time)的 .clearfix.video。章节/引言标题节点(如「2.1 消费者认识产生」)
    // 带 × 没时长,点开也没视频可放会卡死 —— 这里过滤掉,切节只落到真视频上。
    function zhsGxkVideoRows() {
        return zhsRowsFor("gxk").filter(r => {
            const t = r.querySelector(".time");
            const text = (t && t.textContent) || r.textContent || "";
            return /\d{1,2}:\d{2}/.test(text);
        });
    }
    function zhsPlayerCb() {
        try {
            const W = (typeof unsafeWindow === "object" && unsafeWindow) || (typeof window === "object" && window);
            const p = W && W.PlayerStarter && typeof W.PlayerStarter.get === "function" ? W.PlayerStarter.get("container") : null;
            return (p && p.callback) || null;
        } catch (e) { return null; }
    }
    function zhsMoveSnapshot(v, scope) {
        return { video: v, key: zhsRowKey(zhsCurrent(scope), scope),
            src: v.currentSrc || v.src || "", time: Number(v.currentTime) || 0 };
    }
    // 目录行和媒体必须一起变:有些旧版复用 <video> 只换 src,另一些先换行再重建播放器。
    // 行变了但旧视频还在 / 同一节只重建播放器都属于 loading,不能再按下一节跳过未看的视频。
    function zhsMoveState(before, scope) {
        const v = document.querySelector("#container video") || document.querySelector("video");
        const key = zhsRowKey(zhsCurrent(scope), scope);
        const rowChanged = !!(key && before.key && key !== before.key);
        const replaced = !!(v && v !== before.video);
        const src = v && (v.currentSrc || v.src || "");
        const sourceChanged = !!(src && before.src && src !== before.src);
        const reset = !!(v && !v.ended && before.time > 1 && v.currentTime < before.time - 1);
        const ready = !!(v && v.isConnected && (v.readyState == null || v.readyState >= 1));
        if (ready && (rowChanged || !before.key) && (replaced || sourceChanged || (rowChanged && reset))) return "moved";
        if (rowChanged || !before.video.isConnected || replaced || sourceChanged) return "loading";
        return "still";
    }
    // 旧版 videoClick 会先保存进度,保存回调成功后才换目录和视频。这两个状态只读,
    // 不能强行清除,否则可能打断页面正在保存的进度。
    function zhsGxkBusy(target) {
        return !!(target && (target.vm.saveDataFilish === true || target.vm.repeatClick === false));
    }
    async function zhsWaitMoved(before, scope, target, log) {
        let lastPending = -1;
        for (let i = 0; i <= 720; i++) {
            if (cxTimeUp()) return "timeup";
            let state = zhsMoveState(before, scope);
            if (state === "moved") return state;
            const saving = zhsGxkBusy(target);
            if (state === "still" && target && String(target.vm.lastViewVideoId) !== target.from) state = "loading";
            if (saving || state === "loading") lastPending = i;
            // 没有开始切节才按 30 秒重试;已在保存或加载则最多等 3 分钟。
            // 保存结束但没有换节时再留 5 秒让页面完成后续更新,随后才重新发起切节。
            if (i >= 120 && (lastPending < 0 || i - lastPending >= 20)) return "still";
            if (i === 120 && typeof log === "function")
                log(saving ? "页面仍在保存学习进度,等待保存完成后继续切节" : "页面已开始换节,继续等待播放器加载");
            if (i === 720) return saving ? "saving" : state;
            await sleep(250);
        }
    }
    async function zhsAdvance(v, scope, o, selected = null) {
        const before = zhsMoveSnapshot(v, scope);
        const target = selected || (scope === "gxk" ? zhsGxkNextTarget() : null);
        const sameTarget = () => !target || String(target.vm.lastViewVideoId) === target.from;
        let called = false;
        for (let attempt = 0; attempt < 3;) {
            if (cxTimeUp()) return "timeup";
            // 重试始终指向同一目标;页面已经开始换节时只等加载,不再发下一节请求。
            if (zhsMoveState(before, scope) === "still" && sameTarget() && !zhsGxkBusy(target)) {
                const quiz = zhsQuizOpen();
                if (quiz) {
                    if (o.quizMode === "auto" && typeof o.quizAuto === "function") {
                        try {
                            if (await o.quizAuto(quiz, o.log) && !zhsQuizOpen()) continue;
                        } catch (e) { o.log("切节前自动答出错:" + e, "warn"); }
                    }
                    if (cxTimeUp()) return "timeup";
                    o.log("切节时页面弹了测验,请处理后刷新页面重试", "warn");
                    return "blocked";
                }
                if (attempt) o.log("下一节暂未切换,正在重试(" + (attempt + 1) + "/3)"
                    + (target ? ":" + (target.item.video.name || "下一段视频") : ""), "warn");
                // 旧版先按目录定位;若页面没响应,第二次换用播放器回调,第三次仍重试原目录目标。
                const byDirectory = !!target && attempt !== 1;
                if (!attempt && byDirectory) o.log("按目录切换到: " + (target.item.video.name || "下一段视频"));
                let sent = byDirectory ? zhsGxkOpenTarget(target) : zhsNext();
                if (!sent && sameTarget() && zhsMoveState(before, scope) === "still")
                    sent = byDirectory ? zhsNext() : zhsGxkOpenTarget(target);
                called = called || sent;
                if (!sent && !called) return "unavailable";
                attempt++;
            }
            const state = await zhsWaitMoved(before, scope, target, o.log);
            if (state === "moved" || state === "timeup") return state;
            if (state === "loading" || state === "saving") return state;
        }
        return "stalled";
    }
    async function zhsRunByNext(o, scope) {
        const log = o.log;
        const label = scope === "gxk" ? "共享课旧版目录" : "智慧慕课";
        if (scope === "tree") o.quizAuto = zhsQuizAutoTree;
        if (scope === "gxk") {
            // 这一页的弹题用页面自带的正确答案自动答(zhsQuizAutoGxk)。「只点关闭」在这里走不通:关闭按钮
            // 走 closeTest,一样查 isTrusted,而且没答完它根本不让关 —— 所以 close 也按 auto 办。只改这一趟,不动存档。
            o.quizAuto = zhsQuizAutoGxk;
            if (o.quizMode === "close") {
                o.quizMode = "auto";
                log("这一页的测验没答完关不掉、关闭按钮也查 isTrusted —— 「只关不答」按「自动答并关闭」办(答案是页面自己带的)", "warn");
            }
        }
        let rows = scope === "gxk" ? zhsGxkVideoRows()
            : scope === "tree" ? zhsTreeVideoRows() : zhsRowsFor(scope);
        if (scope === "tree") {
            for (let i = 0; i < 40 && !rows.length; i++) { await sleep(500); rows = zhsTreeVideoRows(); }
            if (!rows.length) {
                log("智慧慕课目录已出现,但没有识别到任务叶子;已暂停", "warn");
                return;
            }
        }
        zhsTaskPushAll(rows, scope, o.restudy);
        log("开工(v" + ((typeof GM_info !== "undefined" && GM_info.script && GM_info.script.version) || "?") + "·vm路):" + label + " 目录共 " + rows.length + " 节," + (o.restudy ? "复习模式(已完成也重看)"
            : "待做 " + zhsItems(o.restudy, scope).length + " 节") + ",倍速 " + o.rate
            + ",遇到测验" + (o.quizMode === "close" ? "只关不答(这个版式的测验弹窗关不掉,会停下等你)"
                : o.quizMode === "auto" ? (o.quizAuto ? "自动答并关闭" : "自动答(这个版式还不会,会停下等你)")
                : "停下等你答")
            + (o.limit ? ",约 " + o.limit + " 分钟后收工" : "")
            + (scope === "gxk" ? "。按课程目录顺序切换视频,加载后自动播放"
                : scope === "tree" ? "。按目录叶子识别任务,跨章节切换后确认新播放器再继续"
                : "。这一页走页面自己的「下一节」,从页面当前这一节起顺着往下")
            + (scope === "gxk" ? "(想从别的一节开始就自己点一下目录再开)" : ""));
        let done = 0, reachedEnd = false;
        if (scope === "gxk" && !o.restudy) {
            const earlier = zhsGxkEarlierTarget();
            if (earlier) {
                log("目录前面还有未完成视频,先补学: " + (earlier.item.video.name || "未完成章节"));
                const v = await zhsSettledVideo();
                if (!v || await zhsAdvance(v, scope, o, earlier) !== "moved") {
                    log("返回未完成章节失败,请从目录打开该节后刷新", "warn");
                    return;
                }
            }
        }
        const ZHS_REPLAY_MAX = 2;            // 没被网站确认完成时,最多从头补播几次(每次降到 1 倍补足学习时长),补完还不认才停
        const replayCount = new Map(), slowKeys = new Set();
        const bound = rows.length * (ZHS_REPLAY_MAX + 1) + 2;   // 给每节的补播留足外层迭代,保存异常也不至于无限重播
        for (let n = 0; n < bound; n++) {
            if (cxTimeUp()) {
                cxDisarm();   // 理由同学习通刷课:到点只响一次,重开页面就是新的一趟
                log("到了设定的停止时间,收工。刷新页面会重新计时", "warn");
                zhsProgress("已到定时停止", 100);
                return;
            }
            if (scope === "tree") {
                let selected = zhsCurrent("tree");
                for (let i = 0; i < 40 && !selected; i++) { await sleep(500); selected = zhsCurrent("tree"); }
                if (!selected) {
                    log("智慧慕课当前目录项无法识别,为避免沿用旧播放器误处理,已暂停", "warn");
                    return;
                }
                if (selected && !rows.includes(selected)) {
                    log("当前目录项不是视频任务,跳到后续视频项: " + (zhsName(selected, "tree") || "非视频项"));
                    const move = await zhsTreeAdvanceToVideo(selected, null, rows, o);
                    if (move === "moved" || move === "retry") continue;
                    if (move === "end") { reachedEnd = true; break; }
                    log(move === "timeup" ? "到了设定的停止时间,停止切节"
                        : "未能加载后续视频任务(" + move + "),已暂停;请检查目录或页面后刷新重试", "warn");
                    return;
                }
            }
            // 首屏要先拉目录、再建播放器,多等一会儿(约 40 秒);而且要等它站稳(见 zhsSettledVideo)
            let v = await zhsSettledVideo();
            if (!v) {
                log("等不到播放器(这一页没自动装上视频,或者版式又改了),不动", "warn");
                return;
            }
            rows = scope === "gxk" ? zhsGxkVideoRows()
                : scope === "tree" ? zhsTreeVideoRows() : zhsRowsFor(scope);
            const cur = zhsCurrent(scope);
            const idx = cur ? rows.indexOf(cur) : -1;
            const name = (cur && zhsName(cur, scope)) || "(当前这一节)";
            const finished = !!(cur && zhsDone(cur, scope));
            const record = scope === "gxk" ? zhsGxkRecord() : zhsTreeRecord();
            const tkey = cur ? zhsTaskKey(idx, cur, scope) : "";
            let moved = false;      // 看的过程中页面自己换了节(人点了目录)
            if (finished && !o.restudy) {
                log("「" + name + "」已完成,按下一节");
            } else {
                zhsProgress((idx >= 0 ? "第 " + (idx + 1) + "/" + rows.length + " 节 · " : "") + name,
                    idx >= 0 ? Math.round(idx / rows.length * 100) : 0);
                log("[" + (idx >= 0 ? (idx + 1) + "/" + rows.length : "?") + "] " + name + (finished ? "(复习)" : "")
                    + (v.duration > 0 ? " · 时长 " + zhsClock(v.duration) : " · 播放器还没拿到时长"));
                if (tkey) zhsTaskSet(tkey, { state: "进行中", mark: finished ? "复习·真看" : "" });
                o.note = tkey ? (note, pct) => zhsTaskSet(tkey, { note: note, pct: pct }) : null;
                zhsDismiss();
                // 看这一节。播放器被页面换掉而目录行没变(同一节重建了播放器:换清晰度、切线路、建播放器
                // 分两步)就重新认一个接着看;目录行变了才是真换节(人点了目录),那就从那一节接着来。
                const key = zhsRowKey(cur, scope);
                // 每节重读面板倍速;但被网站判"没看够"而补播过的节降到 1 倍——1.5 倍常是网站没给满学习时长的根。
                o.rate = slowKeys.has(key) ? 1 : zhsRate();
                let why = "";
                for (let k = 0; k < 30; k++) {
                    // 只碰媒体 API:静音后 play() 不受自动播放策略拦;倍速直设,zhsWatchVideo 每拍再钉
                    try { v.muted = true; } catch (e) {}
                    if (v.paused) { const p = v.play(); if (p && p.catch) p.catch(() => {}); }
                    const appliedRate = zhsMediaRate(v, o.rate);
                    if (appliedRate !== o.rate) {
                        log("倍速未能与网站计时同步,本节使用 " + appliedRate + " 倍播放", "warn");
                        o.rate = appliedRate;
                    }
                    const watchedSource = v.currentSrc || v.src || "";
                    why = await zhsWatchVideo(v, o);
                    if (why !== "replaced") break;
                    if (zhsRowKey(zhsCurrent(scope), scope) !== key) {
                        moved = true;
                        log("页面换到了别的节(你点了目录?),从那一节接着来");
                        break;
                    }
                    const nv = await zhsSettledVideo();
                    if (!nv || (nv === v && (nv.currentSrc || nv.src || "") === watchedSource)) {
                        log("播放器被页面换掉后没再出来,这一节先放下", "warn"); why = "stuck"; break;
                    }
                    log("还是这一节,页面重建了播放器,重新认一个接着看");
                    v = nv;
                }
                o.note = null;
                let confirmed = finished;
                if (!moved && why === "ended") {
                    if (tkey) zhsTaskSet(tkey, { state: "待确认", note: "视频已播完 · 等待网站保存" });
                    const result = finished ? "confirmed" : await zhsConfirmRecord(cur, scope, record, log);
                    confirmed = result === "confirmed";
                    if (result === "moved") moved = true;
                    else if (!confirmed) {
                        const actual = scope === "gxk" ? zhsGxkRecord() : zhsTreeRecord();
                        const pct = actual && Number(actual.video.videoSec) > 0
                            ? Math.min(100, Math.floor(actual.saved / actual.video.videoSec * 100)) : null;
                        const note = pct == null ? "网站尚未确认完成" : "网站已记录 " + pct + "%";
                        if (tkey) zhsTaskSet(tkey, { state: "待做", note: note, pct: pct == null ? 0 : pct });
                        // 网站没确认完成(incomplete/unconfirmed):从头补播、并把这一节降到 1 倍重看,反复补足
                        // 学习时长,直到网站认或补够 ZHS_REPLAY_MAX 次 —— 用户要的是"重刷这一节"而不是一上来就暂停。
                        const retryable = (result === "incomplete" || result === "unconfirmed") && !cxTimeUp();
                        const tried = replayCount.get(key) || 0;
                        if (retryable && tried < ZHS_REPLAY_MAX) {
                            replayCount.set(key, tried + 1); slowKeys.add(key);
                            log(note + ",本节从头补播第 " + (tried + 1) + "/" + ZHS_REPLAY_MAX + " 次(降到 1 倍补足学习时长)", "warn");
                            try { v.currentTime = 0; } catch (e) { return; }
                            continue;
                        }
                        log(note + (result === "blocked" ? ",请先处理网页上的提示"
                            : result === "saving" ? ",保存超过 3 分钟,请检查网络后刷新"
                            : result === "timeup" ? ",已到停止时间"
                            : retryable ? ",已补播 " + tried + " 次仍未被网站确认,已暂停;多半是网站要求人工(如刷脸)或当前线路计时异常,处理后刷新重试"
                            : ",已暂停切节;请检查页面进度后刷新重试"), "warn");
                        return;
                    }
                }
                if (tkey) zhsTaskSet(tkey, { state: moved ? "待做" : confirmed ? "已完成" : (ZHS_TASK_END[why] || "跳过"),
                    note: confirmed ? "网站已确认完成" : "", pct: confirmed ? 100 : 0 });
                if (why === "timeup") return;
                if (!moved && confirmed && why === "ended") done++;
            }
            if (moved) continue;
            if (idx >= 0 && idx === rows.length - 1) {
                log("这是目录里最后一节");
                reachedEnd = true;
                break;
            }
            const advance = scope === "tree"
                ? await zhsTreeAdvanceToVideo(cur, v, rows, o)
                : await zhsAdvance(v, scope, o);
            if (advance === "retry") continue;
            if (advance === "end") {
                log("后续没有未完成的视频任务");
                reachedEnd = true;
                break;
            }
            if (advance !== "moved") {
                if (advance === "timeup") {
                    cxDisarm();
                    log("到了设定的停止时间,停止切节", "warn");
                    zhsProgress("已到定时停止", idx >= 0 ? Math.round((idx + 1) / rows.length * 100) : 0);
                    return;
                }
                log(advance === "unavailable" ? "页面没露出可用的切节方法,按不了「下一节」,请手动切换后刷新页面重试"
                    : advance === "saving" ? "页面保存进度超过 3 分钟仍未结束,已暂停;请检查页面或网络状态后刷新重试"
                    : advance === "loading" ? "目录或播放器已变化,但下一节未加载完成,已暂停;请检查页面提示后刷新页面重试"
                    : advance === "blocked" ? "切节已暂停,还有后续视频未处理"
                    : "重试 3 次仍没换节,已暂停;请检查页面的学习限制或错误提示,处理后刷新页面重试", "warn");
                zhsProgress("切节暂停 · 还有后续视频未处理", idx >= 0 ? Math.round((idx + 1) / rows.length * 100) : 0);
                return;
            }
        }
        zhsProgress(reachedEnd ? "已处理到目录末尾" : "目录重复变化,本次已暂停", reachedEnd ? 100 : 0);
        log((reachedEnd ? "已处理到目录末尾" : "目录重复变化,请检查页面后刷新重试") + ",这一趟共看了 " + done + " 节");
    }
    // 没有 vm 读不到服务器进度:视频放完触发页面保存回调,不等待目录完成标记。
    function zhsGxkDomSaveAndContinue(log) {
        try { const cb = zhsPlayerCb(); if (cb && typeof cb.onPause === "function") cb.onPause(); } catch (e) {}
        log("视频已播完,已触发页面保存并继续下一节;完成状态以网站标记为准");
    }
    async function zhsGxkOpenVideoRow(row, name, log) {
        const targetKey = zhsRowKey(row, "gxk");
        let video = null;
        for (let clickAttempt = 0; clickAttempt < 2 && !video; clickAttempt++) {
            if (!row.isConnected) break;
            const beforeVideo = document.querySelector("#container video") || document.querySelector("video");
            const beforeSource = beforeVideo && (beforeVideo.currentSrc || beforeVideo.src || "");
            const wasCurrent = zhsCurrent("gxk") === row;
            if (!zhsGxkClickRow(row, log)) {
                log("目录项「" + name + "」第 " + (clickAttempt + 1) + " 次点击未派发", "warn");
            } else {
                for (let i = 0; i < 60 && !video; i++) {
                    const active = zhsCurrent("gxk");
                    const selected = active === row
                        || (!!targetKey && zhsRowKey(active, "gxk") === targetKey);
                    const candidate = document.querySelector("#container video") || document.querySelector("video");
                    const source = candidate && (candidate.currentSrc || candidate.src || "");
                    const changed = !!(candidate && (candidate !== beforeVideo || source !== beforeSource));
                    const ready = !!(candidate && candidate.isConnected && candidate.readyState >= 1 && source);
                    if (selected && ready && (wasCurrent || changed)) {
                        const settled = await zhsSettledVideo();
                        const stillSelected = zhsCurrent("gxk") === row
                            || (!!targetKey && zhsRowKey(zhsCurrent("gxk"), "gxk") === targetKey);
                        if (settled && stillSelected) video = settled;
                    }
                    if (!video) await sleep(200);
                }
                if (!video) log("目录项「" + name + "」点击后未检测到稳定播放器" + (clickAttempt ? "（重试后仍失败）" : ""), "warn");
            }
            if (!video && clickAttempt === 0) await sleep(700);
        }
        if (!video) log("目录项「" + name + "」在点击及一次重试后仍无播放器", "warn");
        return video;
    }
    // 改版 studyvideoh5(抓不到 vm)专用:全程 DOM —— 目录只认真视频行,挨个点开(合成 MouseEvent,
    // 自动跳过章节标题节点),media API 播放,放完触发页面保存并直接处理下一节,不等待目录完成标记。
    // 只有限循环、不刷新页面,所以也不会把连续
    // 刷新当"异常学习行为"锁课。vm 还在的页面/版式不走这里(见 zhsRun 的分流)。切节失败绝不冒充全部完成。
    async function zhsRunGxkDom(o) {
        const scope = "gxk", log = o.log;
        o.quizAuto = zhsQuizAutoGxk;
        if (o.quizMode === "close") {
            o.quizMode = "auto";
            log("这一页的测验没答完关不掉、关闭按钮也查 isTrusted —— 「只关不答」按「自动答并关闭」办(答案是页面自己带的)", "warn");
        }
        let rows = zhsGxkVideoRows();
        zhsTaskPushAll(rows, scope, o.restudy);
        const vids0 = rows;
        log("开工(v" + ((typeof GM_info !== "undefined" && GM_info.script && GM_info.script.version) || "?") + "·DOM直点):共享课旧版目录 目录共 " + rows.length + " 节(可播视频 " + vids0.length + "),"
            + (o.restudy ? "复习模式(已完成也重看)" : "待做 " + vids0.filter(r => !zhsDone(r, scope)).length + " 个视频")
            + ",倍速 " + o.rate
            + ",遇到测验" + (o.quizMode === "auto" ? "自动答并关闭" : o.quizMode === "close" ? "只关不答" : "停下等你答")
            + (o.limit ? ",约 " + o.limit + " 分钟后收工" : "")
            + "。按目录顺序点开每个未完成视频(自动跳过章节标题),放完直接点下一个");
        const gaveUp = new Set();
        let done = 0, lastKey = "";
        const bound = vids0.length + 4;
        for (let n = 0; n < bound; n++) {
            if (cxTimeUp()) {
                cxDisarm();
                log("到了设定的停止时间,收工。刷新页面会重新计时", "warn");
                zhsProgress("已到定时停止", 100);
                return;
            }
            rows = zhsGxkVideoRows();
            const vids = rows;
            if (!vids.length) { log("目录里没有可播视频行(版式又改了?),不动", "warn"); return; }
            const target = o.restudy
                ? vids.find(r => zhsRowKey(r, scope) !== lastKey && !gaveUp.has(zhsRowKey(r, scope)))
                : vids.find(r => !zhsDone(r, scope) && !gaveUp.has(zhsRowKey(r, scope)));
            if (!target) {
                const pct = vids.length ? Math.round(done / vids.length * 100) : 100;
                if (gaveUp.size) { zhsProgress("目录过完 · 还有 " + gaveUp.size + " 节未确认", pct); log("共看了 " + done + " 节,还有 " + gaveUp.size + " 节没被网站确认(可手动点开重看)", "warn"); }
                else { zhsProgress("已处理到目录末尾", 100); log((o.restudy ? "复习模式这趟目录过完了" : "没有待看的视频了") + ",共看了 " + done + " 节"); }
                return;
            }
            const idx = rows.indexOf(target), vidIdx = vids.indexOf(target);
            const name = zhsName(target, scope) || "(视频)";
            const key = zhsRowKey(target, scope);
            const tkey = zhsTaskKey(idx, target, scope);
            const finished = zhsDone(target, scope);
            zhsProgress("第 " + (vidIdx + 1) + "/" + vids.length + " 个视频 · " + name, Math.round(vidIdx / vids.length * 100));
            log("[" + (vidIdx + 1) + "/" + vids.length + "] 点开: " + name + (finished ? "(复习)" : ""));
            zhsTaskSet(tkey, { state: "进行中", mark: finished ? "复习·真看" : "" });
            const v = await zhsGxkOpenVideoRow(target, name, log);
            if (!v) {
                zhsTaskSet(tkey, { state: "待做" });
                zhsProgress("目录项无法打开 · 已停止", Math.round(vidIdx / vids.length * 100));
                log("「" + name + "」未能打开并确认播放器,已停止目录处理,其余任务保留待做。请检查页面状态并手动打开目标项", "warn");
                return;
            }
            o.rate = zhsRate();
            o.note = (note, pct) => zhsTaskSet(tkey, { note: note, pct: pct });
            zhsDismiss();
            let why = "";
            for (let k = 0; k < 30; k++) {
                try { v.muted = true; } catch (e) {}
                if (v.paused) { const p = v.play(); if (p && p.catch) p.catch(() => {}); }
                const applied = zhsMediaRate(v, o.rate);
                if (applied !== o.rate) { log("倍速未能与网站计时同步,本节使用 " + applied + " 倍播放", "warn"); o.rate = applied; }
                const src = v.currentSrc || v.src || "";
                why = await zhsWatchVideo(v, o);
                if (why !== "replaced") break;
                const nv = await zhsSettledVideo();
                if (!nv || (nv === v && (nv.currentSrc || nv.src || "") === src)) { log("播放器被页面换掉后没再出来,这一节先放下", "warn"); why = "stuck"; break; }
                log("页面重建了播放器,重新认一个接着看");
                v = nv;
            }
            o.note = null;
            if (why === "timeup") { zhsTaskSet(tkey, { state: "待做" }); return; }
            if (why !== "ended") {
                zhsTaskSet(tkey, { state: ZHS_TASK_END[why] || "跳过" });
                log("「" + name + "」" + (why === "quiz" ? "弹了测验没答完,先跳过这节" : "没看到结尾,先跳过这节"), "warn");
                gaveUp.add(key); lastKey = key; continue;
            }
            zhsTaskSet(tkey, { state: "待确认", note: "视频已播完 · 网站标记待更新" });
            zhsGxkDomSaveAndContinue(log);
            gaveUp.add(key);
            done++; lastKey = key;
            continue;
        }
        zhsProgress("目录反复变化,本次先停", 0);
        log("目录反复变化或补播次数用尽,本次先停,共看了 " + done + " 节,请检查页面后刷新重试", "warn");
    }
    async function zhsRun(scope) {
        const restudy = !!cxSet("zhs_restudy");
        const quizMode = cxSet("zhs_quiz") || "pause";
        let rate = zhsRate();
        const limit = cxArm();
        const log = (t, lv) => logMsg("智慧树: " + t, lv);
        keepTabAwake();
        // 目录是 SPA 后渲染的,可能比脚本晚。先等它出来 —— 等的是"行",不是"待做行",
        // 否则一门全做完了的课会被当成"目录没加载出来"。
        let rows = zhsRowsFor(scope);
        for (let i = 0; i < 150 && !rows.length; i++) { await sleep(200); rows = zhsRowsFor(scope); }
        if (!rows.length) {
            log("这一页不像共享课学习页(找不到章节目录),不动。若确定是学习页,多半是版式又改了", "warn");
            return;
        }
        const o = { restudy: restudy, quizMode: quizMode, rate: rate, readRate: zhsRate, limit: limit, log: log };
        if (scope === "gxk" && !zhsGxkDirectory()) return zhsRunGxkDom(o);
        if (scope === "tree" || scope === "gxk") return zhsRunByNext(o, scope);
        const items = zhsItems(restudy, scope);
        zhsTaskPushAll(rows, scope, restudy);
        log("开工:目录共 " + rows.length + " 节," + (restudy ? "复习模式(已完成也重看)"
            : "待做 " + items.length + " 节") + ",倍速 " + rate
            + ",遇到测验" + (quizMode === "close" ? "只关不答" : quizMode === "auto" ? "自动答(这个版式还不会,会停下等你)" : "停下等你答")
            + (limit ? ",约 " + limit + " 分钟后收工" : ""));
        let done = 0, unresolved = 0;
        for (let i = 0; i < items.length; i++) {
            if (cxTimeUp()) {
                cxDisarm();   // 理由同学习通刷课:到点只响一次,重开页面就是新的一趟
                log("到了设定的停止时间,剩 " + (items.length - i) + " 节没刷。刷新页面会重新计时", "warn");
                zhsProgress("已到定时停止(还剩 " + (items.length - i) + " 节)", Math.round(i / items.length * 100));
                return;
            }
            const el = items[i];
            if (!restudy && zhsDone(el, scope)) { done++; continue; } // 排队时被别处标成完成了
            rate = zhsRate();   // 每节重读:面板中途改了倍速,下一节就跟上
            const name = zhsName(el, scope) || ("第 " + (i + 1) + " 节");
            const tkey = zhsTaskKey(rows.indexOf(el), el, scope);
            zhsProgress("第 " + (i + 1) + "/" + items.length + " 节 · " + name, Math.round(i / items.length * 100));
            log("[" + (i + 1) + "/" + items.length + "] " + name + (zhsDone(el, scope) ? "(复习)" : ""));
            try { el.click(); } catch (e) {}
            await sleep(600);
            zhsDismiss();
            const v = await zhsWaitForVideo();
            if (!v) {
                zhsDismiss();
                log("这一节点开没等到 <video>(多半是文档/PDF/外链),跳过", "warn");
                zhsTaskSet(tkey, { state: "跳过" });
                unresolved++;
                continue;
            }
            zhsTaskSet(tkey, { state: "进行中", mark: zhsDone(el, scope) ? "复习·真看" : "" });
            o.note = (note, pct) => zhsTaskSet(tkey, { note: note, pct: pct });
            // 只碰媒体 API,不点播放器上的任何按钮(播放键在播放器容器里,合成点击会撞检测):
            // 静音后 play() 不受自动播放策略拦;倍速直设,zhsWatchVideo 每拍再钉一次
            try { v.muted = true; v.currentTime = 1; } catch (e) {}
            if (v.paused) { const p = v.play(); if (p && p.catch) p.catch(() => {}); }
            zhsMediaRate(v, rate);
            const why = await zhsWatchVideo(v, o);
            o.note = null;
            // 播放器更换或视频结束不能代替网站的完成标记。
            zhsTaskSet(tkey, { state: zhsDone(el, scope) ? "已完成" : why === "replaced" ? "待做" : (ZHS_TASK_END[why] || "跳过") });
            if (why === "timeup") return;
            if (zhsDone(el, scope)) done++;
            else unresolved++;
        }
        const percent = items.length ? Math.round(done / items.length * 100) : 100;
        if (unresolved) {
            zhsProgress("本次处理结束 · " + unresolved + " 节未完成", percent);
            log("本次网站确认完成 " + done + "/" + items.length + " 节,另有 " + unresolved + " 节未完成或未确认;目录对勾以网站状态为准,可刷新后重试", "warn");
        } else {
            zhsProgress("智慧树刷课完成", 100);
            log("全部任务均已由网站确认完成,这一趟共完成 " + done + " 节");
        }
    }
    // 入口平台:共享课那三个旧域名,外加智慧树全家(zhihuishu.com / polymas.com 下所有
    // 学习子域)。拿"在不在学习页"交给 zhsDetect 判,这里只管放行哪些 host。
    // polymas.com 是 hike 的域(参考实现zhs.hike),也收进来。
    function zhsHosts() {
        const h = location.hostname;
        return ["studyvideoh5", "studyplush5", "studywisdomh5"].some(x => h.indexOf(x) >= 0)
            || (h === "fusioncourseh5.zhihuishu.com" && /\/stuStudy(?:\.html)?(?:\/|$)/i.test(location.pathname))
            || (h.endsWith("zhihuishu.com") && /\/aidedteaching\/sourceLearning(?:\/|$)/i.test(location.pathname))
            || ((h.endsWith("zhihuishu.com") || h.endsWith("polymas.com"))
                && (h.startsWith("smartcoursestudent") || h.startsWith("ai-smart-course-student-pro")
                    || h.startsWith("wisdom-mooc") || h.startsWith("tools-hike")
                    || h.startsWith("hike-teaching-center")));
    }
    // 开工时判一次,缓存到模块级 —— zhsRun 全程(可能几小时)都认这一份,目录不会长到一半
    // 把版式判换。按"容器族"判而不是按 host 细判:哪个版式的骨架 DOM 在,就按哪个刷。
    // 顺序是命中的权重:新版智慧树(2025-12,wisdom-mooc/study)的页面上 ".child-main"
    // 充当页面骨架(不是目录行),若 child 判在 tree 前面,整页会被当成共享课目录行 →
    // 目录空 → 还没开工 / 还没扫到任务点。所以 tree(章节目录树)必须排在 child 前面:
    // 章节目录树比共享课行更"是一个目录",而共享课行只在该版式页面里存在。
    // zhsProbe 只认、不兜底:目录是接口回来才渲染的,进页面 3 秒时很可能什么都还没有,
    // 这时候就定成 child 会把智慧慕课页判死(第 57 轮用户实况:「共享课 · 还没扫到任务点」)。
    // 所以入口先轮询 zhsProbe 等骨架出现,等不到才由 zhsDetect 兜底成 child。
    function zhsProbe() {
        const d = document;
        if (d.querySelector(".chapter-content .chapter-content-second")
            || d.querySelector(".chapter-content .chapter-item")) return "tree";
        // fusioncourseh5 的智慧课程-AI与旧共享课共用 .clearfix.video,但其资源卡片
        // 由 FusionCourseH5 按 .resources-item 驱动;必须在通用 gxk 探针前识别。
        if (location.hostname === "fusioncourseh5.zhihuishu.com"
            && (d.querySelector(".resource-box, .resources-item, .clearfix.video"))) return "ai";
        const childMain = d.querySelector(".child-main");
        if (childMain && childMain.parentElement
            && childMain.parentElement.querySelector(".child-time")) return "child";
        // 旧共享课目录 li.clearfix.video(scope=gxk)—— studyvideoh5 的 /videoStudy 和 2026 年新路由
        // /stuStudy 都还是它(2026-09-18 真机 78 行)。少了这条,这种页面探针什么都认不出,要空转满
        // 40 秒才由 zhsDetect 兜底,面板 43 秒后才出来,用户当成"没面板"。选择器和 zhsRowsFor 的 gxk
        // 分支用同一个,探针认出了引擎就一定取得到行。必须排在 ai 那条前面:这页自带的 AI 助教会
        // 渲染 knowledge-video-card-container,card-container 那条会把整页抢成"新形态课程",引擎就
        // 去点 AI 卡片而不是目录。
        if (d.querySelector(".clearfix.video")) return "gxk";
        if (d.querySelector(".section-item-collapse-info")
            || d.querySelector('[class*="card-container"]')) return "ai";
        if (d.querySelector(".el-tree-node")) return "hike2";
        if (d.querySelector(".file-item")) return "filelist";
        return "";
    }
    let zhsScope = "";
    function zhsDetect() {
        if (zhsScope) return zhsScope;
        // 都不在:老共享课里目录有时折叠在深一点的容器里,兜底用最通用的旧版行集
        zhsScope = zhsProbe() || "child";
        return zhsScope;
    }
    // 等版式骨架出现,最多约 40 秒(80 拍 × 500ms);到点还没有就交给 zhsDetect 兜底
    async function zhsWaitScope() {
        for (let i = 0; i < 80 && !zhsProbe(); i++) await sleep(500);
        return zhsDetect();
    }
    // 只放顶层,理由同超星(正文是 iframe,脚本会再跑一遍,不放顶层会双开面板)。
    // 版式判定放在 setTimeout 里、且先等骨架:目录是接口回来才渲染的。面板名随版式给,
    // 不然用户分不清刷的是哪一页(共享课/智慧慕课/新形态/校内课长得完全不一样)。
    if (zhsHosts() && window.top === window.self && cxSet("zhs_do_video")) {
        setTimeout(async () => {
            const scope = await zhsWaitScope();
            showPanel("智慧树刷课 · "
                + (scope === "child" ? "共享课"
                    : scope === "gxk" ? "共享课(旧版目录)"
                    : scope === "tree" ? "智慧慕课"
                    : scope === "ai" ? (location.hostname === "fusioncourseh5.zhihuishu.com" ? "智慧课程-AI" : "新形态课程")
                    : scope === "filelist" ? "校内课"
                    : scope === "hike2" ? "hike"
                    : "学习页"));
            zhsRun(scope);
        }, 3e3);
    }

    // ══ 中国大学MOOC 刷课(icourse163)══════════════════════════════════
    // 照 参考实现ICourseProject.study 抄,砍掉它对桌面端的依赖:
    //   · 视频:waitForMedia 在顶层文档找 video,直接驱动 —— 不跨 iframe,不需要 playwright;
    //   · 目录:任务行是 .unitslist(或 .j-unitslist)里的 li,当前行带 .current,名字在 .unit-name;
    //   · 下一页:点当前行下一个兄弟的 .unit-name —— SPA 内部跳,页面不重载;
    //   · 到小节/章节尾:照 参考实现next2 逐级找(小节 .j-lesson .j-list .list,章 .j-chapter),
    //     点开下一个再继续;
    //   · 文档:等 .ux-pdf-reader,读页脚"第 x / 共 n 页",点下一页 n-1 次;
    //   · 讨论:按 study_discuss 抄一条或跳过。
    // 参考实现用 remotePage.click 点这些是因为它在自动化浏览器里;这里直点,真机验证时如果
    // 点不动(要可信事件)再回来改。
    function moocCurrent() {
        return document.querySelector(".unitslist li.current, .j-unitslist li.current");
    }
    // 认任务类型:行内图标类名带 u-icon-video / u-icon-doc / u-icon-discuss / u-icon-test /
    // u-icon-text(参考实现就是按 [class*=u-icon-xxx] 认的)。
    function moocKind(li) {
        if (!li) return "";
        for (const k of ["video", "doc", "discuss", "test", "text"])
            if (li.querySelector("[class*=u-icon-" + k + "]")) return k;
        return "";
    }
    function moocName(li) {
        if (!li) return "";
        const u = li.querySelector(".unit-name");
        return (u && (u.textContent || "").trim()) || "";
    }
    // 等视频出来(最多 12 秒)。文档/讨论不会有 video,返回 null。
    function moocWaitVideo() {
        return new Promise(res => {
            let i = 0; const t = setInterval(() => {
                const v = document.querySelector("video");
                if (v) { clearInterval(t); res(v); }
                else if (++i >= 60) { clearInterval(t); res(null); }
            }, 200);
        });
    }
    // 等文档阅读器。返回 "pdf"(ux-pdf-reader)或 "other"(docBox 之类兜底)或 ""。
    function moocWaitDoc() {
        return new Promise(res => {
            let i = 0; const t = setInterval(() => {
                if (document.querySelector(".ux-pdf-reader")) { clearInterval(t); res("pdf"); }
                else if (document.querySelector(".ux-doc-reader, .j-doc, .ux-ppt-player")) { clearInterval(t); res("other"); }
                else if (++i >= 60) { clearInterval(t); res(""); }
            }, 200);
        });
    }
    // 视频看到 ended。卡住(60 秒不动)就放弃这一节。
    async function moocWatchVideo(v, rate, log) {
        let last = -1, still = 0;
        cxSyncMediaRate(v, cxVideoRate(true));
        while (true) {
            await sleep(2e3);
            if (cxTimeUp()) { log("到点收工,这一节看到 " + Math.floor(v.currentTime) + "s 就停", "warn"); return; }
            if (!v.isConnected || v.ended) return;
            if (v.paused) { const p = v.play(); if (p && p.catch) p.catch(() => {}); }
            cxSyncMediaRate(v, cxVideoRate(true));
            if (v.currentTime === last) {
                if (++still >= 30) { log("视频 60 秒没动,跳过这一节", "warn"); return; }
            } else still = 0;
            last = v.currentTime;
        }
    }
    // 文档:读"当前页/总页数",从当前页翻到最后。翻页按钮/总页数的类名抄 参考实现。
    async function moocReadDoc(log) {
        const secs = Math.max(1, Math.floor(cxSet("study_ppt_sec") || 1));
        const totalEl = document.querySelector(
            ".ux-h5pdfreader_container_footer_pages_total");
        const curEl = document.querySelector(".ux-h5pdfreader_container_footer_pages_in");
        const total = totalEl ? parseInt((totalEl.textContent || "").replace(/\s/g, "")) || 0 : 0;
        const cur = curEl ? parseInt(curEl.value || "1") || 1 : 1;
        if (!total) { log("文档阅读器没读出总页数,这一节先跳过", "warn"); return; }
        for (let p = cur; p < total; p++) {
            if (cxTimeUp()) { log("到点收工(文档看到第 " + p + "/" + total + " 页)", "warn"); return; }
            const nextBtn = document.querySelector(
                ".ux-h5pdfreader_container_footer_pages_next, .ux-pdfreader_container_footer_pages_next");
            if (!nextBtn) { log("找不到 PPT 下一页按钮,停在第 " + p + " 页", "warn"); return; }
            try { nextBtn.click(); } catch (e) { return; }
            await sleep(secs * 1e3);
        }
    }
    // 讨论:study_discuss=none 就跳过;否则抄一条填进去提交(选择器抄 参考实现)。
    async function moocDiscuss(log) {
        const mode = cxSet("study_discuss") || "none";
        if (mode === "none") { log("讨论任务:study_discuss 是「不回复」,跳过"); return; }
        const list = Array.from(document.querySelectorAll(".j-reply-all .f-pr .j-content"));
        if (!list.length) { log("讨论区没内容可抄,跳过"); return; }
        const pick = mode === "random"
            ? list[Math.floor(Math.random() * list.length)].textContent
            : list[0].textContent;
        const box = document.querySelector(".j-reply-add div.ql-editor.ql-blank p, .j-reply-add .ql-editor p");
        if (!box) { log("找不到讨论输入框,跳过"); return; }
        box.textContent = pick || "";
        await sleep(1e3);
        const btn = document.querySelector(".j-reply-add .editbtn");
        if (btn) { try { btn.click(); } catch (e) {} log("讨论已抄一条提交"); }
        else log("找不到讨论提交按钮(内容已填,没提交)", "warn");
    }
    // 这一节做完后点"下一个任务"。参考实现的 next2 是三层:小节内下一个 unit → 下一小节 → 下一章。
    // 都点 .unit-name / 那一级的标题让它展开。返回 true 表示点到了什么。
    function moocNext(log) {
        const cur = moocCurrent();
        if (cur) {
            const sib = cur.nextElementSibling;
            if (sib) {
                const u = sib.querySelector(".unit-name");
                if (u) { try { u.click(); } catch (e) {} return true; }
            }
        }
        // 当前小节到头了:点下一小节(.j-lesson .j-list .list 的下一个兄弟的标题)
        const lessonUp = document.querySelector(".j-lesson .j-up");
        const lessonName = lessonUp ? (lessonUp.textContent || "").replace(/\s/g, "") : "";
        if (lessonName) {
            const items = Array.from(document.querySelectorAll(".j-lesson .j-list .list"));
            for (let i = 0; i < items.length; i++) {
                const nm = (items[i].textContent || "").replace(/\s/g, "");
                if (nm.indexOf(lessonName) >= 0 && items[i + 1]) {
                    const jup = items[i + 1].querySelector(".j-up");
                    if (jup) { try { jup.click(); } catch (e) {} return true; }
                }
            }
        }
        // 章到头:点下一章
        const chapUp = document.querySelector(".j-chapter .j-up");
        const chapName = chapUp ? (chapUp.textContent || "").replace(/\s/g, "") : "";
        if (chapName) {
            const items = Array.from(document.querySelectorAll(".j-chapter .j-list .list"));
            for (let i = 0; i < items.length; i++) {
                const nm = (items[i].textContent || "").replace(/\s/g, "");
                if (nm.indexOf(chapName) >= 0 && items[i + 1]) {
                    const jup = items[i + 1].querySelector(".j-up");
                    if (jup) { try { jup.click(); } catch (e) {} return true; }
                }
            }
        }
        log("到目录尾了,整门课刷完", "warn");
        return false;
    }
    async function moocRun() {
        // 第 84 轮把五个「视频倍速」并成一个:统一读共享的 cx_video_rate。第 142 轮起各平台不再夹
        // 上限(原来 MOOC/超星 2 倍、智慧树 1.5) —— 填多少放多少,风险自负。原来那栏 study_rate 已删。
        const rate = (() => { const r = cxSet("cx_video_rate"); const n = typeof r === "number" ? r : parseFloat(r);
            return (isFinite(n) && n >= 1) ? n : 1; })();
        cxArm();   // 定时停止,见 cxArm 说明
        const log = (m, lv) => logMsg("MOOC刷课: " + m, lv);
        keepTabAwake();
        // 目录可能晚于脚本加载。等"当前任务行"出现。
        let cur = moocCurrent();
        for (let i = 0; i < 150 && !cur; i++) { await sleep(200); cur = moocCurrent(); }
        if (!cur) { log("这页不像 MOOC 学习页(找不到 .unitslist li.current),不动", "warn"); return; }
        log("开工(倍速 " + rate + ")。页面要一直开着,MOOC 是 SPA,点下一节不重载");
        // 从当前行开始逐节往下。做完一节点下一个任务,等 SPA 把 current 挪过去再处理新的;
        // 用"当前行的名字"判重,防止同一节被处理两遍。
        let doneName = "", doneN = 0;
        while (true) {
            if (cxTimeUp()) { cxDisarm(); log("到点收工", "warn"); return; }
            cur = moocCurrent();
            if (!cur) { log("目录不见了(可能被切走),停", "warn"); return; }
            const name = moocName(cur) || "?";
            if (name === doneName) {
                // 等 SPA 把 current 挪到下一节(点了 moocNext 之后最多等 8 秒)
                let waited = 0;
                while (waited < 40 && moocName(moocCurrent()) === name) { await sleep(200); waited++; }
                if (moocName(moocCurrent()) === name) { log("点下一节后目录没动,可能是最后一节", "warn"); return; }
                continue;
            }
            doneName = name;
            const kind = moocKind(cur);
            log("[" + (doneN + 1) + "] " + name + (kind ? "(" + kind + ")" : ""));
            if (kind === "video") {
                const v = await moocWaitVideo();
                if (!v) { log("视频没出来,跳过这一节", "warn"); moocNext(log); await sleep(2e3); continue; }
                try { v.muted = true; v.currentTime = 1; } catch (e) {}
                await moocWatchVideo(v, rate, log);
                doneN++;
            } else if (kind === "doc") {
                const got = await moocWaitDoc();
                if (!got) { log("文档阅读器没出来,跳过", "warn"); moocNext(log); await sleep(2e3); continue; }
                if (got === "pdf") await moocReadDoc(log);
                else await sleep(3e3);   // 别的阅读器读不出页数,停 3 秒当看过
                doneN++;
            } else if (kind === "discuss") {
                await moocDiscuss(log);
                doneN++;
            } else if (kind === "text") {
                await sleep(3e3);
                doneN++;
            } else {
                // test(随堂测验)或认不出的:不自动答(题库在作业页),跳过
                log(kind === "test" ? "随堂测验:不自动答,跳到下一节" : "认不出这一节类型,跳过", "warn");
            }
            if (cxTimeUp()) { cxDisarm(); log("到点收工", "warn"); return; }
            const hasNext = moocNext(log);
            if (!hasNext) { log("整门课刷完(共处理 " + doneN + " 节)", "warn"); return; }
            await sleep(2e3);
        }
    }
    // 入口:host + 开关 + 只放顶层。MOOC 的 /learn 是 SPA,hash 路由(参考实现用 /learn/content?type=detail
    // 触发),这里不挑 hash —— 在 /learn 下就会跑,反正没有目录时会自己停下来说。
    if (cxSet("study_do")
        && window.top === window.self
        && (location.hostname === "www.icourse163.org" || location.hostname === "icourse163.org")
        && (location.pathname.indexOf("/learn") === 0 || location.pathname.indexOf("/spoc/learn") === 0)) {
        setTimeout(() => {
            showPanel("刷课 · 中国大学MOOC");
            moocRun();
        }, 3e3);
    }
    // ══ 职教云刷课(icve.com.cn)══════════════════════════════════════
    // 照 参考实现ZJYProject 抄,砍掉 __vue__/桌面端依赖。职教云机制和 MOOC 完全不同:
    //   每个任务点是独立 URL(?id=),没有"下一页"按钮 —— 参考实现先到课程目录页把整门课的
    //   任务列表读进内存,然后按 ?id= 找当前、看完了 location 翻下一个(页面整跳)。
    // 这里列表存 GM:目录页点开「课件目录」把 .items 里那些任务行读出来(名字 + id),
    // 存成 zjy_tasks;学习页从 GM 取列表、按 ?id= 对当前。
    // 视频/音频真放到 ended;PPT/文档翻页;图片任务停几秒;测验/讨论跳过。
    // 当前页是什么任务靠元素猜(video / PPT 阅读器 / 图),翻 PPT 优先走 __vue__.next。
    function icveHost() {
        const h = location.hostname;
        return h === "zjy2.icve.com.cn" || h === "zyk.icve.com.cn" || h === "www.icve.com.cn"
            || h === "learn-cs.icve.com.cn";
    }
    // 目录页:把整门课任务读出来(名字 + id)。任务行 .items 里的 .fIteml/.iChild。
    function icveReadTasks() {
        const rows = Array.from(document.querySelectorAll(".items .fIteml,.items .iChild"))
            .filter(el => (el.textContent || "").trim());
        const out = [], seen = new Set();
        for (const el of rows) {
            const name = (el.textContent || "").replace(/\s+/g, " ").trim();
            const a = el.querySelector("a") || el;
            const m = ((a && a.href) || "").match(/[?&]id=([^&#]+)/);
            const id = m ? m[1] : "";
            if (!id || seen.has(id)) continue;
            seen.add(id);
            out.push({ name: name, id: id });
        }
        return out;
    }
    function icveCurId() {
        return new URL(location.href).searchParams.get("id") || "";
    }
    function icveType() {
        if (document.querySelector("video,audio")) return "video";
        if (document.querySelector(".FilePreview,.preview .page,.pdfViewer,.ux-pdf-reader")) return "ppt";
        if (document.querySelector(".previewImg,.preview img")) return "image";
        return "other";
    }
    async function icveWatchVideo(rate, log) {
        const v = document.querySelector("video,audio");
        if (!v) return;
        let last = -1, still = 0;
        try { v.muted = true; cxSyncMediaRate(v, cxVideoRate(true)); } catch (e) {}
        try { const p = v.play(); if (p && p.catch) p.catch(() => {}); } catch (e) {}
        while (true) {
            await sleep(2e3);
            if (cxTimeUp()) { log("到点收工,这一节看到 " + Math.floor(v.currentTime) + "s", "warn"); return; }
            if (!v.isConnected || v.ended) return;
            if (v.paused) { const p = v.play(); if (p && p.catch) p.catch(() => {}); }
            cxSyncMediaRate(v, cxVideoRate(true));
            if (v.currentTime === last) {
                if (++still >= 30) { log("视频 60 秒没动,当看过跳过", "warn"); return; }
            } else still = 0;
            last = v.currentTime;
        }
    }
    async function icveReadPpt(log) {
        const secs = Math.max(1, Math.floor(cxSet("icve_ppt_sec") || 1));
        // 读 "3/40" 当前页/总页。读不到按 15 秒当看过。
        let total = 0;
        const pageEl = document.querySelector(".preview .page,.preview .current");
        const txt = (pageEl && (pageEl.textContent || "").trim()) || "";
        const mm = txt.match(/(\d+)\s*\/\s*(\d+)/);
        if (mm) total = parseInt(mm[2]) || 0;
        if (!total) { log("PPT 读不出总页数,按 15 秒当看过", "warn"); await sleep(15e3); return; }
        for (let p = 1; p < total && p < 500; p++) {
            if (cxTimeUp()) { log("到点收工(PPT 看到第 " + p + "/" + total + " 页)", "warn"); return; }
            const root = document.querySelector(".FilePreview,.guide,.teach");
            const vue = root && root.__vue__;
            if (vue && vue.next) { try { vue.next(); } catch (e) {} }
            else {
                const btn = Array.from(document.querySelectorAll(".preview [class*=next],.preview button,.btn-next"))
                    .find(b => /下一页|next/i.test(b.textContent || "") || /next/i.test(b.className || ""));
                if (btn) { try { btn.click(); } catch (e) {} } else break;
            }
            await sleep(secs * 1e3);
        }
        log("PPT 翻完(" + total + " 页)");
    }
    async function icveRun() {
        // 共享倍速:读 cx_video_rate,第142轮起不再夹 2(见 moocRun 注释)。原来那栏 icve_rate 已删。
        const rate = (() => { const r = cxSet("cx_video_rate"); const n = typeof r === "number" ? r : parseFloat(r);
            return (isFinite(n) && n >= 1) ? n : 1; })();
        cxArm();
        const log = (m, lv) => logMsg("职教云刷课: " + m, lv);
        keepTabAwake();
        const curId = icveCurId();
        if (!curId) {
            // 目录页:读任务列表进 GM,然后跳第一个任务。
            let tasks = [];
            for (let i = 0; i < 150 && !tasks.length; i++) { await sleep(200); tasks = icveReadTasks(); }
            if (!tasks.length) { log("目录页没读出任务列表(可能要点课件目录?),不动", "warn"); return; }
            GM_setValue("zjy_tasks", JSON.stringify(tasks));
            log("读到 " + tasks.length + " 个任务,跳第一个开始(列表已存)");
            const first = document.querySelector(".items .fIteml a,.items .fIteml");
            if (first) { try { location.href = (first.href || (first.querySelector("a") || {}).href); } catch (e) {} return; }
            log("没找到第一个任务链接,请手动点一个任务开始", "warn");
            return;
        }
        // 学习页
        let tasks = [];
        try { tasks = JSON.parse(GM_getValue("zjy_tasks", "[]")) || []; } catch (e) {}
        if (!tasks.length) { log("GM 里没有任务列表 —— 请先到课程目录页让脚本读一次", "warn"); return; }
        const idx = tasks.findIndex(t => t.id === curId);
        log(idx >= 0 ? "[" + (idx + 1) + "/" + tasks.length + "] " + (tasks[idx].name || "") : "当前任务不在列表里,自己刷这一节");
        const type = icveType();
        if (type === "video") { await icveWatchVideo(rate, log); log("视频看完"); }
        else if (type === "ppt") { await icveReadPpt(log); }
        else if (type === "image") { await sleep(3e3); log("图片任务,停 3 秒当看过"); }
        else log("这个任务(video/PPT/图片都不是)没有可看的,跳过", "warn");
        if (cxTimeUp()) { cxDisarm(); log("到点收工", "warn"); return; }
        if (idx < 0) { log("不在列表里,不自动翻下一个", "warn"); return; }
        const next = tasks[idx + 1];
        if (!next) { log("全部任务刷完", "warn"); return; }
        log("下一任务: " + (next.name || ""));
        await sleep(5e3);
        const base = location.href.split("?")[0];
        location.replace(base + "?id=" + encodeURIComponent(next.id));
    }
    // 入口:host + 开关 + 顶层 + 路径是目录或学习页。目录页没 ?id=,学习页有 ?id=。
    if (cxSet("icve_do") && window.top === window.self && icveHost()
        && /\/(study|icve-study|learnspace)\//.test(location.pathname)) {
        setTimeout(() => {
            showPanel("刷课 · 职教云");
            icveRun();
        }, 3e3);
    }
    // ══ 雨课堂刷课(yuketang.cn)══════════════════════════════════════
    // studentLog 的「学习内容」在 iframe 中。读取课程目录数据,优先点击原生目录行打开视频。
    // 任务类型和完成进度来自页面组件;只播放视频,进度仍由网站播放器正常记录。
    function yktHost() {
        const h = location.hostname;
        return ["yuketang.cn", "xuetangx.com"].some(domain => h === domain || h.endsWith("." + domain));
    }
    function yktRate() {
        const n = Number(cxSet("cx_video_rate"));
        if (yktRateFallbackState() === n) return 1;
        return Number.isFinite(n) && n >= 1 ? n : 1;
    }
    function yktRateFallbackState(value) {
        const key = "ai6_ykt_normal_rate:" + (yktClass(location.href) || location.pathname);
        const memory = yktRateFallbackState.memory || (yktRateFallbackState.memory = new Map());
        try {
            if (value !== undefined) {
                memory.set(key, value);
                if (value === null) sessionStorage.removeItem(key);
                else sessionStorage.setItem(key, String(value));
            }
            const stored = sessionStorage.getItem(key);
            return stored == null ? memory.get(key) : Number(stored);
        } catch (e) { return memory.get(key); }
    }
    function yktUseNormalRate(v, reason, log = logMsg) {
        if (!v || !yktApplyVideoRate(v, 1)) return false;
        yktRateFallbackState(Number(cxSet("cx_video_rate")));
        log(reason + ",本课程改用 1 倍继续播放;其他课程保留原倍速", "warn");
        return true;
    }
    function yktMedia(doc = document, depth = 0) {
        // 优先主播放器,避免附件预览/数字人伴读视频抢占;新版播放器就在顶层文档。
        for (const selector of [".learning-center-player video", ".xt_video_player_container video", "#video-box video", ".xtplayer video", ".detail-container video"]) {
            const v = doc.querySelector(selector);
            if (v) return v;
        }
        if (depth < 4) for (const frame of Array.from(doc.querySelectorAll("iframe"))) {
            try { const v = frame.contentDocument && yktMedia(frame.contentDocument, depth + 1); if (v) return v; } catch (e) {}
        }
        return doc.querySelector("video");
    }
    function yktApplyVideoRate(v, rate) {
        if (!v) return false;
        try {
            const root = v.closest(".xt_video_player_container");
            if (root) {
                // XtPlayer 的 speed() 用闭包记住菜单选项,每秒恢复倍速,心跳也读 options.speed.value。
                // 必须走原生菜单;只写 video.playbackRate 会被恢复,并让网站记录的倍速与实际不符。
                const menu = root.querySelector(".xt_video_player_speed");
                const item = menu && Array.from(menu.querySelectorAll("li[data-speed]"))
                    .find(el => Number(el.getAttribute("data-speed")) === rate);
                // 不支持倍速的课程可能整个没有速度菜单,1 倍仍然必须可以应用。
                if (!item && rate !== 1) return false;
                if (item && !item.classList.contains("xt_video_player_common_active")) {
                    // 原生菜单在 mousemove 后才接受选项点击。
                    const EventType = v.ownerDocument.defaultView.MouseEvent;
                    const rect = menu.getBoundingClientRect();
                    menu.dispatchEvent(new EventType("mouseover", { bubbles: true, clientX: rect.left, clientY: rect.top }));
                    menu.dispatchEvent(new EventType("mousemove", { bubbles: true, clientX: rect.left + 2, clientY: rect.top + 2 }));
                    item.click();
                    menu.dispatchEvent(new EventType("mouseout", { bubbles: true }));
                }
                if (item && !item.classList.contains("xt_video_player_common_active")) return false;
            }
            // 数字人/普通 HTML5 播放器,以及原生切清晰度后暂时恢复的媒体值。
            if (Math.abs(v.playbackRate - rate) > 0.001) v.playbackRate = rate;
            return Math.abs(v.playbackRate - rate) < 0.001;
        } catch (e) { return false; }
    }
    function yktPushRate() {
        yktRateFallbackState(null); // 用户主动修改时可以重新尝试,自动轮询不清除此状态。
        const rate = yktRate(), v = yktMedia();
        if (!v) { logMsg("雨课堂倍速已设为 " + rate + " 倍,等待播放器加载"); return; }
        if (yktApplyVideoRate(v, rate)) logMsg("雨课堂倍速已应用到当前视频: " + rate + " 倍");
        else if (!(rate > 1 && yktUseNormalRate(v, "雨课堂当前课程不支持 " + rate + " 倍")))
            logMsg("雨课堂当前播放器尚未就绪,等待加载后应用倍速", "warn");
    }
    function yktHome() {
        return /^\/v2\/web\/index\/?$/.test(location.pathname);
    }
    function yktCourses() {
        if (!yktHome()) return [];
        const seen = new Set(), courses = [];
        const keys = yktCourses.keys || (yktCourses.keys = new WeakMap());
        // 网站 lessonCardS 的根节点点击会保存学校/平台上下文并调用原生 goLog。
        // 只读学生课程卡片,不混入教师课程或替用户切换筛选条件。
        for (const row of Array.from(document.querySelectorAll(".lesson-cardS"))) {
            if (!row.getClientRects().length || getComputedStyle(row).visibility === "hidden") continue;
            const vm = yktVue(row, v => v.cardData && v.cardData.classroom_id != null, false);
            const data = vm && vm.cardData;
            const classroom = data ? String(data.classroom_id) : "";
            if (!keys.has(row)) keys.set(row, "row:" + (yktCourses.serial = (yktCourses.serial || 0) + 1));
            const id = classroom ? "class:" + classroom : keys.get(row);
            if (seen.has(id)) continue;
            const title = row.querySelector("h1"), className = row.querySelector(".className");
            const name = (data && data.course && data.course.name) || (title && title.textContent.trim());
            if (!name) continue;
            seen.add(id);
            courses.push({ id: id, classroom: classroom, name: String(name),
                className: String((data && data.name) || (className && className.textContent.trim()) || ""), row: row });
        }
        return courses;
    }
    function yktOpenCourse(id) {
        // 点击时重新读取,避免首页搜索/切学期后误点已经被替换的卡片。
        const course = yktCourses().find(c => c.id === id);
        if (!course) { logMsg("雨课堂:课程列表已变化,请重新选择", "warn"); return; }
        try {
            sessionStorage.setItem("ai6_ykt_home_scan", JSON.stringify({ classroom: course.classroom, at: Date.now() }));
            logMsg("雨课堂:进入「" + course.name + "」并扫描任务");
            course.row.click();
        } catch (e) {
            try { sessionStorage.removeItem("ai6_ykt_home_scan"); } catch (_) {}
            logMsg("雨课堂:课程入口未能打开,请点击网页上的课程卡片", "warn");
        }
    }
    function yktTakeHomeScan() {
        try {
            const raw = sessionStorage.getItem("ai6_ykt_home_scan");
            if (!raw) return false;
            const request = JSON.parse(raw);
            if (!request || !Number.isFinite(request.at) || Date.now() - request.at > 60000 || request.at > Date.now()) {
                sessionStorage.removeItem("ai6_ykt_home_scan"); return false;
            }
            if (yktHome()) return false;
            sessionStorage.removeItem("ai6_ykt_home_scan");
            return /^\/v2\/web\/studentLog\/[^/]+\/?$/.test(location.pathname)
                && (!request.classroom || request.classroom === yktClass(location.href));
        } catch (e) {
            try { sessionStorage.removeItem("ai6_ykt_home_scan"); } catch (_) {}
            return false;
        }
    }
    async function yktScanHomeCourse() {
        const path = location.pathname, active = () => location.pathname === path;
        const log = (m, lv) => logMsg("雨课堂扫描: " + m, lv);
        const source = await yktEnterDirectory(log, active);
        if (!source || !active()) return;
        const tasks = yktTasks(source);
        yktTaskSync(tasks); yktBindRows(source, tasks);
        log(tasks.length ? "扫描到 " + tasks.length + " 个任务;可在面板「进度」查看"
            : "课程目录暂时为空,等待网站加载");
    }
    // 列表页的叶子任务(.leaf-detail),取"第 n 个"。
    function yktLeafs(doc = document) {
        return Array.from(doc.querySelectorAll(".leaf-detail"));
    }
    function yktLeafName(leaf) {
        const t = leaf.querySelector(".leaf-title, .leaf-name, .title");
        return (t && (t.textContent || "").trim()) || "";
    }
    function yktVue(el, match, descend = true) {
        const seen = new Set();
        const visit = (vm, depth) => {
            if (!vm || depth > 6 || seen.has(vm) || seen.size > 300) return null;
            seen.add(vm);
            if (match(vm)) return vm;
            for (const child of (descend && Array.isArray(vm.$children) ? vm.$children : [])) {
                const found = visit(child, depth + 1);
                if (found) return found;
            }
            return null;
        };
        for (let depth = 0; el && depth < 15; depth++, el = el.parentElement) {
            try {
                let vm = (el.wrappedJSObject || el).__vue__;
                for (let n = 0; vm && n < 20; n++, vm = vm.$parent) {
                    const found = visit(vm, 0);
                    if (found) return found;
                }
            } catch (e) {}
        }
        return null;
    }
    function yktDirectory(doc = document) {
        return yktVue(doc.querySelector(".study-content__container"), vm => Array.isArray(vm.chapter_list));
    }
    function yktLeafVm(leaf) {
        return yktVue(leaf, vm => !!vm.leafData && vm.leafData.id != null, false);
    }
    function yktLeafDone(leaf) {
        const vm = yktLeafVm(leaf), dir = yktDirectory();
        if (vm) {
            // 目录 map 为 0..1,单行组件的 schedule 为 0..100。
            const value = dir && dir.leaf_schedules[vm.leafData.id];
            if (value != null) return Number(value) >= 1;
            return Number(vm.schedule) >= 100;
        }
        return !!leaf.querySelector(".finished, .done, .complete");
    }
    function yktVideoLeaf(leaf) {
        const vm = yktLeafVm(leaf);
        if (!vm) return false;
        const data = vm.leafData;
        return Number(data.leaf_type) === 0 && !data.is_locked && !data.is_third_party
            && !vm.cannotContinueStudy && !vm.viewByTeacher;
    }
    function yktCourse(url) {
        try {
            const u = new URL(url, location.href);
            if (u.origin !== new URL(location.href).origin) return "";
            const m = u.pathname.match(/^\/pro\/lms\/([^/]+)\/([^/]+)\/(studycontent|video|forum)(?:\/|$)/);
            return m ? m[1] + "/" + m[2] : "";
        } catch (e) { return ""; }
    }
    function yktClass(url) {
        try {
            const u = new URL(url, location.href);
            if (u.origin !== new URL(location.href).origin) return "";
            const pro = u.pathname.match(/^\/pro\/lms\/[^/]+\/([^/]+)\/(studycontent|video|forum)(?:\/|$)/);
            const web = u.pathname.match(/^\/v2\/web\/(?:studentLog|xcloud\/video-student)\/([^/]+)(?:\/|$)/);
            const graph = u.pathname.match(/^\/ai-workspace\/lms-graph\/([^/]+)(?:\/|$)/);
            return (pro || web || graph || [])[1] || "";
        } catch (e) { return ""; }
    }
    function yktVideoPage(url = location.href) {
        try {
            const u = new URL(url, location.href);
            return u.origin === new URL(location.href).origin && (
                /^\/v2\/web\/xcloud\/video-student\/[^/]+\/[^/]+\/?$/.test(u.pathname)
                || /^\/pro\/lms\/[^/]+\/[^/]+\/video\/[^/]+\/?$/.test(u.pathname)
                || /^\/ai-workspace\/lms-graph\/[^/]+\/video\/[^/]+\/?$/.test(u.pathname));
        } catch (e) { return false; }
    }
    function yktContext(value) {
        // sessionStorage 随当前标签页导航,避免多课程、多标签串跳。
        const course = yktClass(location.href);
        if (!course) return null;
        const key = "ai6_ykt_course_v2:" + course;
        try {
            if (value !== undefined) sessionStorage.setItem(key, JSON.stringify(value));
            const state = JSON.parse(sessionStorage.getItem(key) || "null");
            return state && yktClass(state.listUrl) === course
                && /(?:\/studycontent\/?$|^\/v2\/web\/studentLog\/[^/]+\/?$)/.test(new URL(state.listUrl).pathname) ? state : null;
        } catch (e) { return null; }
    }
    function yktSource() {
        const dir = yktDirectory();
        if (dir) return { doc: document, dir: dir, url: location.href, embedded: false };
        for (const frame of Array.from(document.querySelectorAll ? document.querySelectorAll("iframe") : [])) {
            try {
                const url = new URL(frame.getAttribute("src") || "", location.href);
                if (!yktCourse(url.href) || !/\/studycontent\/?$/.test(url.pathname)
                    || yktClass(url.href) !== yktClass(location.href)) continue;
                const doc = frame.contentDocument;
                const inner = doc && yktDirectory(doc);
                if (inner) return { doc: doc, dir: inner, url: url.href, embedded: true, frame: frame };
            } catch (e) {}
        }
        return null;
    }
    function yktTasks(source) {
        const dir = source.dir, rows = yktLeafs(source.doc), list = [];
        // 与 OCS 相同:章 -> section_leaf_list -> leaf_list/单个叶子。无需每一行都有 __vue__。
        for (const chapter of (dir.chapter_list || [])) {
            for (const section of (chapter.section_leaf_list || [])) {
                for (const data of (Array.isArray(section.leaf_list) ? section.leaf_list : [section])) {
                    if (data && data.id != null) list.push({ data: data, chapter: chapter.name || "" });
                }
            }
        }
        const rowVms = rows.map(yktLeafVm);
        // 兼容只有行组件数据的旧布局。
        if (!list.length) rowVms.forEach(vm => { if (vm) list.push({ data: vm.leafData, chapter: "" }); });
        const byId = new Map();
        rowVms.forEach((vm, i) => { if (vm) byId.set(String(vm.leafData.id), rows[i]); });
        // 完整目录按渲染次序对应,与 OCS 一致;过滤/折叠导致数目不符时只按明确 ID 对应。
        const ordered = rows.length === list.length && rowVms.every((vm, i) => vm
            ? String(vm.leafData.id) === String(list[i].data.id)
            : !list[i].data.name || yktLeafName(rows[i]).replace(/\s+/g, "").includes(String(list[i].data.name).replace(/\s+/g, "")));
        const seen = new Set();
        return list.filter(item => { const id = String(item.data.id); if (seen.has(id)) return false; seen.add(id); return true; })
            .map((item, i) => {
                const data = item.data, id = String(data.id), row = byId.get(id) || (ordered ? rows[i] : null);
                const vm = row && yktLeafVm(row);
                const schedule = (dir.leaf_schedules || {})[id];
                const percent = schedule != null ? Number(schedule) * 100 : vm && vm.schedule != null ? Number(vm.schedule) : null;
                const tag = row && row.querySelector(".unit-tag");
                const type = data.leaf_type != null ? Number(data.leaf_type)
                    : row && (row.querySelector(".icon--shipin") || (tag && /^(视频|片段|视频片段)$/.test(tag.textContent.trim()))) ? 0
                    : row && row.querySelector(".icon--taolun1") ? 4 : -1;
                return { id: id, data: data, row: row, vm: vm, chapter: item.chapter,
                    name: data.name || (row && yktLeafName(row)) || "未命名任务", type: type,
                    done: percent != null && percent >= 100, percent: percent,
                    locked: !!(data.is_locked || data.is_third_party || dir.viewByTeacher
                        || (vm && (vm.cannotContinueStudy || vm.viewByTeacher))
                        || (row && row.classList.contains("leaf-detail-disable"))) };
            });
    }
    function yktTaskKey(id) {
        return "ykt:" + yktClass(location.href) + ":" + id;
    }
    function yktTaskSync(tasks) {
        for (const task of tasks) iframeMsg("task", { key: yktTaskKey(task.id),
            kind: task.type === 0 ? "video" : task.type === 3 ? "document" : "other",
            name: task.name, chapter: task.chapter || "", state: task.done ? "已完成" : "待做",
            note: task.locked ? "未开放或不可自动学习" : task.percent != null ? "网站进度 " + Math.floor(task.percent) + "%" : "等待网站进度" });
    }
    function yktTaskState(id, state, note) {
        iframeMsg("task", { key: yktTaskKey(id), state: state, note: note || "" });
    }
    function yktRemember(source, task, tasks, videoPath) {
        const snapshot = tasks.map(t => ({ id: t.id, name: t.name, chapter: t.chapter, type: t.type,
            done: t.done, percent: t.percent, locked: t.locked }));
        return yktContext({ listUrl: location.href, directoryUrl: source.url, leafId: task.id,
            videoPath: videoPath, pending: null, tasks: snapshot });
    }
    function yktBindRows(source, tasks) {
        const bound = yktBindRows.bound || (yktBindRows.bound = new WeakSet());
        for (const task of tasks) {
            if (task.type !== 0 || !task.row || bound.has(task.row)) continue;
            bound.add(task.row);
            // 手动点目录时也记住返回页。父页原生路由切到视频后可继续播放。
            task.row.addEventListener("click", () => {
                const graphUrl = yktLearningSpaceUrl(task, source);
                const path = graphUrl ? new URL(graphUrl).pathname : source.embedded
                    ? new URL(yktWebVideoUrl(task, source) || location.href).pathname
                    : new URL(yktTaskUrl(task, source) || location.href).pathname;
                yktRemember(source, task, yktTasks(source), path);
                yktTaskState(task.id, "进行中", "正在打开视频");
            }, true);
        }
    }
    function yktTaskUrl(task, source) {
        if (task.row && task.vm) return yktVideoUrl(task.row);
        const dir = source.dir, data = task.data;
        try {
            if (!dir.$router || task.type !== 0 || task.locked) return "";
            const route = dir.$router.resolve({ name: "lms-video", params: { classroom_id: dir.classroom_id,
                sign: dir.sign, leaf_id: data.id, sku_id: dir.skuId, courseware_id: 0 },
                query: data.is_guidance ? { start: data.clip_start, end: data.clip_end } : {} });
            const url = new URL(route.href, source.url);
            return yktClass(url.href) === yktClass(location.href) && yktCourse(url.href)
                && url.pathname.endsWith("/video/" + task.id) ? url.href : "";
        } catch (e) { return ""; }
    }
    function yktLearningSpaceUrl(task, source) {
        // 与网站 goDetail / goLearningSpace 的课程配置分支一致。此分支原生 window.open
        // 会新开标签,父页面地址不变;直接在当前标签打开相同 URL 才能保持连续播放。
        if (task.type !== 0 || task.locked) return "";
        const vm = task.vm || source.dir, data = task.data;
        const graph = vm.resourceGraphData || source.dir.resourceGraphData || {};
        if (!graph.config_loaded) return "";
        const knowledge = graph.is_new || graph.is_xbk_origin_classroom;
        if (!knowledge && !graph.is_white) return "";
        const classroom = String(vm.classroom_id || source.dir.classroom_id || "");
        if (!classroom || classroom !== yktClass(location.href) || classroom !== yktClass(source.url)) return "";
        const url = new URL("/ai-workspace/lms-graph/" + encodeURIComponent(classroom)
            + "/video/" + encodeURIComponent(task.id), location.href);
        if (knowledge && data.node_id !== undefined) url.searchParams.set("node_id", data.node_id);
        const iframe = vm.yktIframe || source.dir.yktIframe;
        if (!iframe || !iframe.isykt) { url.searchParams.set("fromProIframe", "1"); url.searchParams.set("isyth", "1"); }
        if (!knowledge && graph.is_white) url.searchParams.set("is_chapter", "1");
        if (data.is_guidance) { url.searchParams.set("start", data.clip_start); url.searchParams.set("end", data.clip_end); }
        return url.href;
    }
    function yktWebVideoUrl(task, source) {
        if (task.type !== 0 || task.locked || !source.embedded) return "";
        const classroom = yktClass(location.href);
        if (!classroom || classroom !== yktClass(source.url)) return "";
        // studentLog 收到目录的 type:17 时就是进入此路由;保留学校/平台及片段范围。
        const url = new URL("/v2/web/xcloud/video-student/" + encodeURIComponent(classroom)
            + "/" + encodeURIComponent(task.id), location.href);
        for (const key of ["university_id", "platform_id"]) {
            const value = new URL(location.href).searchParams.get(key) || new URL(source.url).searchParams.get(key);
            if (value) url.searchParams.set(key, value);
        }
        if (task.data.is_guidance) { url.searchParams.set("start", task.data.clip_start); url.searchParams.set("end", task.data.clip_end); }
        return url.href;
    }
    function yktSameTabVideo(task, source, tasks, url, log, active) {
        if (!active() || !url || !yktVideoPage(url) || task.locked || task.type !== 0
            || yktClass(url) !== yktClass(location.href)
            || !new URL(url).pathname.endsWith("/" + encodeURIComponent(task.id))) return false;
        if (!yktRemember(source, task, tasks, new URL(url).pathname)) {
            log("无法保存连续播放状态,请允许本站存储", "warn"); return false;
        }
        yktTaskState(task.id, "进行中", "正在打开视频");
        location.href = url;
        return true;
    }
    function yktNavigationNotice(source) {
        for (const doc of [document, source.doc]) {
            for (const el of Array.from(doc.querySelectorAll(".el-message, .el-message-box__wrapper, .el-dialog__wrapper, .toastMessage"))) {
                if (!el.getClientRects().length) continue;
                const text = (el.textContent || "").trim();
                if (/未发布|未开放|无法继续|已结课|不在.{0,10}时间|没有权限|无权限|登录|验证码|学习承诺/.test(text)) return text.slice(0, 160);
            }
        }
        return "";
    }
    function yktActive(path) {
        return location.pathname === path && cxSet("ykt_do") && !GLOBAL.stop && !cxTimeUp();
    }
    async function yktEnterDirectory(log, active) {
        let clicked = false, fallback = "";
        for (let i = 0; i < 150 && active(); i++) {
            if (!clicked) {
                const tab = document.querySelector("#tab-content")
                    || Array.from(document.querySelectorAll(".mainTab__tabs [role=tab], .mainTab__tabs button, .mainTab__tabs span"))
                        .find(el => (el.textContent || "").trim() === "学习内容");
                const vm = yktVue(document.querySelector(".mainTab__tabs") || tab,
                    v => typeof v.handleTabClick === "function" && Array.isArray(v.mainTabList));
                try {
                    // 首页扫描已打开内容页时不要再点一次,避免网站重建 iframe 后点到旧目录。
                    const source = yktSource();
                    if (source && !source.dir.loading && ((vm && vm.activeTabName === "content")
                        || (tab && tab.getAttribute("aria-selected") === "true"))) return source;
                    // OCS 优先点原生 tab,也避免 Firefox 沙箱向页面方法传对象的兼容问题。
                    if (tab) { tab.click(); clicked = true; }
                    else if (vm) { vm.handleTabClick({ name: "content" }); clicked = true; }
                    if (clicked) log("切换到「学习内容」,等待课程目录");
                } catch (e) {}
            }
            const source = yktSource();
            if (source && !source.dir.loading) return source;
            const frame = document.querySelector(".tab-pane-content-iframe");
            if (frame) {
                try {
                    const url = new URL(frame.getAttribute("src") || "", location.href);
                    if (yktCourse(url.href) && yktClass(url.href) === yktClass(location.href) && /\/studycontent\/?$/.test(url.pathname)) {
                        url.searchParams.delete("iframe_from"); fallback = url.href;
                    }
                } catch (e) {}
            }
            await sleep(200);
        }
        if (active() && fallback) {
            log("内嵌目录未能读取,打开该课程的完整目录重试", "warn"); location.href = fallback;
        } else if (active()) log("学习内容尚未加载,请确认课程页面已登录且目录可打开", "warn");
        return null;
    }
    function yktVideoUrl(leaf) {
        const vm = yktLeafVm(leaf);
        if (!vm || !yktVideoLeaf(leaf) || !vm.$router) return "";
        try {
            const data = vm.leafData;
            const route = vm.$router.resolve({ name: "lms-video", params: {
                classroom_id: vm.classroom_id, sign: vm.sign, leaf_id: data.id,
                sku_id: vm.skuId, courseware_id: 0
            }, query: data.is_guidance ? { start: data.clip_start, end: data.clip_end } : {} });
            const url = new URL(route.href, location.href);
            if (!yktCourse(url.href) || !/\/video\/[^/]+\/?$/.test(url.pathname)) return "";
            if (yktCourse(location.href) && yktCourse(url.href) !== yktCourse(location.href)) return "";
            return url.href;
        } catch (e) { return ""; }
    }
    function yktIsList() {
        return /\/v2\/web\/(studentLog|xcloud\/video-list|.*studycontent)/.test(location.pathname)
            || /^\/pro\/lms\/[^/]+\/[^/]+\/studycontent\/?$/.test(location.pathname)
            || !!document.querySelector(".chapter-list, .leaf-detail");
    }
    function yktIsVideo() {
        return yktVideoPage() || location.pathname.includes("video-student")
            || /^\/pro\/lms\/[^/]+\/[^/]+\/video\//.test(location.pathname)
            || !!document.querySelector("#video-box, .xtplayer, video");
    }
    function yktIsForum() {
        return /\/forum/.test(location.pathname) || !!document.querySelector(".new_discuss_list");
    }
    // AI 学伴工作台(/ai-workspace/lms-graph):跟 v2 学习页完全不同 —— SPA 里展开树、
    // 点叶子右侧出视频。有自己的叶子体系,所以单独一条路。
    function yktIsAi() {
        return location.pathname.indexOf("/ai-workspace/lms-graph") >= 0
            && !!document.querySelector(".leaf-item, .detail-container");
    }
    function yktAiLeafs() {
        return Array.from(document.querySelectorAll(".leaf-item"));
    }
    function yktAiName(leaf) {
        const t = leaf.querySelector(".leaf-item-title, .title");
        return (t && (t.textContent || "").trim()) || "";
    }
    // 已完成 = 行内 .icon-yuanquangou(绿勾);自测(带「自测」标签)不自动答,跳过
    function yktAiDone(leaf) {
        return !!leaf.querySelector(".icon-yuanquangou");
    }
    function yktAiSkip(leaf) {
        const tag = leaf.querySelector(".leaf-item-tag");
        return !!(tag && (tag.textContent || "").includes("自测"));
    }
    // 把折叠的树全部展开(最多点 5 层,参考实现就这么干)
    async function yktAiExpand() {
        for (let i = 0; i < 5; i++) {
            const closed = Array.from(document.querySelectorAll(".expand-icon:not(.is-expanded)"));
            if (!closed.length) return;
            for (const el of closed) { try { el.click(); } catch (e) {} }
            await sleep(300);
        }
    }
    // 找当前叶子之后第一个要学的(未完成且非自测)
    function yktAiNext(fromIdx) {
        const leafs = yktAiLeafs();
        for (let i = fromIdx + 1; i < leafs.length; i++) {
            if (!yktAiDone(leafs[i]) && !yktAiSkip(leafs[i])) return leafs[i];
        }
        return null;
    }
    async function yktAiWatchVideo(target, rate, log) {
        let v = null;
        for (let i = 0; i < 50 && !v; i++) {
            if (!target || !target.isConnected) return "selection-lost";
            if (!target.classList.contains("is-active")) { await sleep(200); continue; }
            await sleep(200);
            v = document.querySelector(".detail-container video, video");
        }
        if (!v) { log("目标叶子未切换或右侧播放器未出现,停在当前任务", "warn"); return "missing"; }
        let last = -1, still = 0;
        try { v.muted = true; v.currentTime = 1; yktApplyVideoRate(v, yktRate()); } catch (e) {}
        try { const p = v.play(); if (p && p.catch) p.catch(() => {}); } catch (e) {}
        while (true) {
            await sleep(2e3);
            if (cxTimeUp()) { log("到点收工,这一节看到 " + Math.floor(v.currentTime) + "s", "warn"); return "timeup"; }
            if (!target.isConnected || !target.classList.contains("is-active")) return "selection-lost";
            if (!v.isConnected) return "replaced";
            if (v.ended) return "ended";
            yktApplyVideoRate(v, yktRate());
            if (v.paused) { const p = v.play(); if (p && p.catch) p.catch(() => {}); }
            if (v.currentTime === last) {
                if (++still >= 30) { log("视频 60 秒没有推进,停在当前任务", "warn"); return "stuck"; }
            } else still = 0;
            last = v.currentTime;
        }
    }
    async function yktAiStudyLeaf(target, rate, log) {
        const taskId = "ai:" + yktAiLeafs().indexOf(target);
        if (!target || !target.isConnected) return false;
        log("点击叶子:「" + (yktAiName(target) || "?") + "」开刷");
        try { target.click(); } catch (e) {}
        try { target.scrollIntoView({ behavior: "smooth", block: "center" }); } catch (e) {}
        const status = await yktAiWatchVideo(target, rate, log);
        if (status !== "ended") {
            if (status === "timeup") cxDisarm();
            yktTaskState(taskId, "待做", status === "timeup" ? "到达停止时间,视频未播完" : "视频未完成: " + status);
            log("当前叶子未确认播放结束,暂停自动切节", "warn");
            return false;
        }
        yktTaskState(taskId, "待确认", "视频已播完 · 等待网站完成标记");
        for (let i = 0; i < 60; i++) {
            if (cxTimeUp()) { cxDisarm(); yktTaskState(taskId, "待做", "到达停止时间,网站完成标记未确认"); return false; }
            if (!target.isConnected || !target.classList.contains("is-active")) {
                yktTaskState(taskId, "待做", "当前叶子已变化,未确认网站完成标记");
                return false;
            }
            if (yktAiDone(target)) {
                yktTaskState(taskId, "已完成", "网站已显示完成标记");
                return true;
            }
            await sleep(1000);
        }
        yktTaskState(taskId, "待做", "视频已播完,网站尚未显示完成标记");
        log("视频已播完但网站仍未标记完成,暂停自动切节", "warn");
        return false;
    }
    // 点第 n 个叶子。返回是否点到了。
    function yktClickLeaf(n) {
        const leaf = yktLeafs()[n];
        if (!leaf) return false;
        try { leaf.click(); } catch (e) {}
        return true;
    }
    // XtPlayer 的 playBtn.toggle 会自行 catch 并吞掉 play() 的拒绝结果。
    // 直接取得媒体 Promise;网站原生 play 监听仍会更新按钮、遮罩和学习心跳。
    function yktStartVideo(v) {
        if (!v || !v.isConnected || !v.paused || v.ended) return;
        v.muted = true;
        v.defaultMuted = true;
        return v.play();
    }
    function yktMediaMatches(v, path) {
        if (!v || !v.isConnected || location.pathname !== path) return false;
        if (!/^\/ai-workspace\/lms-graph\/[^/]+\/video\//.test(path)) return true;
        const leafId = path.split("/").filter(Boolean).pop();
        const vm = yktVue(v, obj => yktSpaceValue(obj, "leafId") != null
            && yktSpaceValue(obj, "playerRef") != null);
        if (!vm) return true; // 旧播放器没有课程组件,仍使用媒体更换判定。
        const leaf = yktSpaceValue(vm, "leafInfo"), playerRef = yktSpaceValue(vm, "playerRef");
        const player = playerRef && playerRef.player;
        return String(yktSpaceValue(vm, "leafId")) === leafId
            && (!leaf || leaf.id == null || String(leaf.id) === leafId)
            && yktSpaceValue(vm, "isVideoReady") !== false
            && (!player || !player.video || player.video === v);
    }
    // 同一课节可能先保留旧播放器,再异步换媒体/地址;整个生命周期只由这一趟循环负责。
    async function yktWatchVideo(rate, log, active = null, onStatus = null) {
        const path = location.pathname;
        active = active || (() => yktActive(path));
        let v = null, source = "", last = 0, still = 0, replacements = 0, ratePauses = 0;
        let blocked = false, waiting = false, pending = null, rateWarning = "", lastStatus = "", armed = false, finished = false;
        let listenDoc = null, listenVideo = null;
        const status = text => {
            if (lastStatus === text) return;
            lastStatus = text;
            if (typeof onStatus === "function") onStatus(text);
        };
        const play = (gesture = false) => {
            if (!active() || finished || !yktMediaMatches(v, path) || v.ended || v.error || ((blocked || waiting) && !gesture)) return;
            try {
                let currentRate = yktRate();
                if (!yktApplyVideoRate(v, currentRate) && rateWarning !== String(currentRate)) {
                    rateWarning = String(currentRate);
                    if (currentRate > 1 && yktUseNormalRate(v, "当前课程未能使用 " + currentRate + " 倍", log)) currentRate = 1;
                    else log("当前播放器未能设置倍速,等待播放器就绪", "warn");
                }
                if (!v.paused || (pending && pending.target === v && !gesture)) return;
                const target = v, src = source, request = {};
                pending = { target: target, request: request };
                const failed = e => {
                    if (!active() || v !== target || source !== src || !target.isConnected
                        || (pending && pending.request !== request)) return;
                    if (e && e.name === "NotAllowedError") {
                        if (!blocked) log("浏览器阻止了自动播放,请在页面点击一次;之后将自动重试播放", "warn");
                        blocked = true; status("等待点击播放 · 浏览器限制");
                    } else if (e && e.name !== "AbortError") status("播放启动失败 · 正在重试");
                };
                try {
                    // 不改 currentTime、不创建第二个播放器;play 事件由真实媒体播放产生。
                    Promise.resolve(yktStartVideo(target)).catch(failed).finally(() => {
                        if (pending && pending.request === request) pending = null;
                    });
                } catch (e) { pending = null; failed(e); }
            } catch (e) { status("播放启动失败 · 正在重试"); }
        };
        const onGesture = event => {
            if (!event.isTrusted || !active() || !v || !v.paused) return;
            blocked = false; waiting = false; still = 0; status("正在启动播放");
            play(true); // 必须在真实手势的同步调用栈里播放。
        };
        const onReady = () => { waiting = false; still = 0; play(); };
        // 网站可能在 ended 回调后立即重置播放器。事件到来时锁存结果,不等下一次 2 秒轮询。
        const onEnded = () => { if (armed && active() && yktMediaMatches(v, path)) finished = true; };
        const cleanup = () => {
            if (listenDoc) for (const name of ["pointerup", "keydown"]) listenDoc.removeEventListener(name, onGesture, true);
            if (listenVideo) for (const name of ["loadedmetadata", "canplay"]) listenVideo.removeEventListener(name, onReady);
            if (listenVideo) listenVideo.removeEventListener("ended", onEnded);
            listenDoc = null; listenVideo = null;
        };
        const adopt = media => {
            cleanup(); v = media; source = v.currentSrc || v.src || "";
            last = Number(v.currentTime) || 0; still = 0; ratePauses = 0; pending = null; blocked = false; waiting = false; armed = !v.ended; finished = false;
            v.loop = false;
            yktWatchVideo.last = { path: path, media: v, source: source, time: last };
            listenDoc = v.ownerDocument; listenVideo = v;
            if (listenDoc) for (const name of ["pointerup", "keydown"]) listenDoc.addEventListener(name, onGesture, true);
            for (const name of ["loadedmetadata", "canplay"]) v.addEventListener(name, onReady);
            v.addEventListener("ended", onEnded);
            status(v.ended ? "等待当前课节播放器就绪" : "正在启动播放");
            play();
        };
        status("等待播放器加载");
        try {
            const previous = yktWatchVideo.last;
            // SPA 先换地址,后销毁旧 video。旧节还在时既不重播,也不把旧 ended 当新节完成。
            if (previous && previous.path !== path) {
                let ready = false, metadata = false;
                const loaded = () => { metadata = true; };
                previous.media.addEventListener("loadedmetadata", loaded);
                try {
                    for (let i = 0; i < 300 && active(); i++) {
                        const media = yktMedia();
                        if (yktMediaMatches(media, path) && (media !== previous.media
                            || (media.currentSrc || media.src || "") !== previous.source
                            || (metadata && !media.ended)
                            || (!media.ended && Number(media.currentTime) < previous.time - 1))) { ready = true; break; }
                        await sleep(200);
                    }
                } finally { previous.media.removeEventListener("loadedmetadata", loaded); }
                if (!active()) return "stopped";
                if (!ready) { log("下一节的播放器尚未加载,保留当前目录位置", "warn"); return "missing"; }
            }
            while (active()) {
                if (finished) return "ended";
                let fresh = yktMedia();
                if (!fresh || !fresh.isConnected) {
                    status(v ? "播放器正在重建 · 等待加载" : "等待播放器加载");
                    for (let i = 0; i < 150 && (!fresh || !fresh.isConnected) && active(); i++) {
                        await sleep(200); fresh = yktMedia();
                    }
                    if (!active()) break;
                    if (!fresh || !fresh.isConnected) { log("等待播放器超时,停留在当前视频", "warn"); return "missing"; }
                }
                if (!yktMediaMatches(fresh, path)) {
                    status("等待当前课节的视频数据就绪");
                    for (let i = 0; i < 300 && active() && !yktMediaMatches(fresh, path); i++) {
                        await sleep(200); fresh = yktMedia();
                    }
                    if (!active()) break;
                    if (!yktMediaMatches(fresh, path)) { log("页面课节与播放器数据不一致,已暂停接管", "warn"); return "missing"; }
                }
                const src = fresh.currentSrc || fresh.src || "";
                if (fresh !== v || source !== src) {
                    if (v && ++replacements > 15) { log("播放器反复重建,请检查页面或网络", "warn"); return "replaced"; }
                    if (v) log("同一课节的播放器已更新,继续从网站断点播放");
                    adopt(fresh);
                }
                if (v.error) { log("视频加载失败,停留在本节等待处理", "warn"); return "error"; }
                if (!v.ended) armed = true;
                if (v.ended && armed) return "ended";
                const time = Number(v.currentTime) || 0;
                yktWatchVideo.last.time = time;
                if (!v.paused && time > last) yktAcceptTransition();
                // 设置能写入但课程立即暂停/改回速度时,最多重试两拍,第三拍回退正常速度。
                if (!blocked && !pending && !v.ended && !v.seeking && yktRate() > 1
                    && (v.paused || Math.abs(v.playbackRate - yktRate()) > .001)) {
                    if (++ratePauses >= 3 && yktUseNormalRate(v, "倍速播放后反复暂停或被网站还原", log)) {
                        pending = null; waiting = false; ratePauses = 0; still = 0;
                    }
                } else if (!v.paused && time > last) ratePauses = 0;
                if (!v.paused && time > last) {
                    blocked = false; waiting = false; still = 0; status("正在播放");
                } else {
                    if (blocked) status("等待点击播放 · 浏览器限制");
                    else if (waiting) status("等待播放器恢复 · 可点击播放继续");
                    else if (!v.ended) status(v.paused ? "正在启动播放" : "正在缓冲 · 等待视频推进");
                    if (!blocked && !waiting && ++still >= 30) {
                        if (v.paused && !v.ended) {
                            waiting = true;
                            status("等待播放器恢复 · 可点击播放继续");
                            log("播放器尚未启动,继续等待加载或点击播放;恢复后会接着连播", "warn");
                        } else {
                            log("视频 60 秒没有推进,请检查播放器或页面提示;本节不会跳过", "warn"); return "stuck";
                        }
                    }
                }
                last = time;
                play();
                await sleep(2e3);
            }
            // 手动换课节时不干预新页面的播放器;关闭开关/定时停止才暂停本节。
            if (location.pathname === path && v && v.isConnected) { try { v.pause(); } catch (e) {} }
            log(location.pathname !== path ? "页面已切换,结束上一节的播放接管" : "播放已停止,保留当前进度", "warn"); return "stopped";
        } finally { cleanup(); }
    }
    function yktSpaceValue(vm, key) {
        if (!vm) return undefined;
        for (const obj of [vm, vm._setupProxy, vm._setupState, vm.$props]) {
            if (!obj || obj[key] === undefined) continue;
            const value = obj[key];
            return value && value.__v_isRef ? value.value : value;
        }
        return undefined;
    }
    function yktSpaceSource() {
        if (!/^\/ai-workspace\/lms-graph\/[^/]+\/(?:video|exercise)\//.test(location.pathname)) return null;
        const root = document.querySelector(".learning-space-student-chapter-nav, .learning-space-student-knowledge-nav");
        if (!root) return null;
        const vm = yktVue(root, v => Array.isArray(yktSpaceValue(v, "allLeafInfo")));
        if (!vm) return null;
        const data = yktSpaceValue(vm, "allLeafInfo");
        const progress = yktSpaceValue(vm, "progressInfo") || (yktSpaceValue(vm, "props") || {}).progressInfo || {};
        const rows = Array.from(root.querySelectorAll(".leaf-item, .project-nav-leaf")), keyed = new Map(), seen = new Set();
        // 两种目录都用 leaf.id + LEAF 作外壳 vnode key;知识目录的叶子行叫 project-nav-leaf。
        const visit = (node, depth = 0) => {
            if (!node || seen.has(node) || depth > 30 || seen.size > 5000) return;
            seen.add(node);
            const el = node.elm;
            if (el && el.classList && (el.classList.contains("nav-item-leaf-box")
                || el.classList.contains("project-nav-item__leaf-box")) && node.key != null) {
                const id = String(node.key).replace(/LEAF$/, ""), row = el.querySelector(".leaf-item, .project-nav-leaf");
                if (row && root.contains(row)) {
                    if (!keyed.has(id)) keyed.set(id, []);
                    keyed.get(id).push(row);
                }
            }
            for (const child of node.children || []) visit(child, depth + 1);
            if (node.componentInstance) visit(node.componentInstance._vnode, depth + 1);
        };
        visit(vm._vnode);
        const title = row => ((row.querySelector(".leaf-item-title, .project-nav-leaf__title") || {}).textContent || "").replace(/\s+/g, "");
        const normalize = value => String(value || "").replace(/\s+/g, "");
        // Vue 节点暂不可读时,仅在整份目录数量、顺序和标题全吻合时按 DOM 顺序回退。
        const orderedMatch = rows.length === data.length && data.every((leaf, index) =>
            normalize(leaf && (leaf.name || leaf.title)) === title(rows[index]));
        const activeRows = rows.filter(row => row.classList.contains("is-active"));
        const routeId = decodeURIComponent((location.pathname.match(/\/(?:video|exercise)\/([^/]+)\/?$/) || [])[1] || "");
        const ids = new Set(), tasks = [];
        for (const leaf of data) {
            if (!leaf || leaf.id == null || ids.has(String(leaf.id))) continue;
            const id = String(leaf.id); ids.add(id);
            let matches = keyed.get(id) || [];
            if (!matches.length && leaf.name) {
                const name = normalize(leaf.name || leaf.title);
                // 没有 vnode 的部署只接受唯一名字;同名任务交还网站目录。
                if (data.filter(d => d && normalize(d.name || d.title) === name).length === 1)
                    matches = rows.filter(r => title(r) === name);
            }
            if (!matches.length && orderedMatch) matches = [rows[data.indexOf(leaf)]];
            if (!matches.length && id === routeId && activeRows.length === 1
                && title(activeRows[0]) === normalize(leaf.name || leaf.title)) matches = activeRows;
            const row = matches.length === 1 ? matches[0] : null;
            const value = (progress.leaf_schedules || {})[id];
            const percent = (typeof value === "number" || typeof value === "string") && value !== "" && Number.isFinite(Number(value))
                ? Math.max(0, Math.min(100, Number(value) * 100)) : null;
            tasks.push({ id: id, data: leaf, row: row, name: leaf.name || "未命名任务", chapter: leaf.chapter_name || "",
                type: Number(leaf.leaf_type), percent: percent, done: percent === 100,
                locked: !!(leaf.is_locked || leaf.locked || leaf.is_third_party || leaf.isSelfTest
                    || (row && (row.classList.contains("is-locked") || row.querySelector(".icon-suoding")))) });
        }
        return { root: root, vm: vm, tasks: tasks };
    }
    async function yktContinueSpace(taskId, state, log, active, completion = null) {
        let source = yktSpaceSource();
        if (!source || !source.tasks.some(t => t.id === String(taskId))) return false;
        const currentTask = source.tasks.find(t => t.id === String(taskId));
        const homeworkSaved = currentTask.type === 6 && completion && completion.id === String(taskId)
            && Number.isInteger(completion.total) && completion.total > 0 && completion.submitted === completion.total;
        if (!state) state = { listUrl: new URL("/v2/web/studentLog/" + yktClass(location.href), location.href).href,
            leafId: String(taskId), videoPath: location.pathname };
        if (state) yktContext(Object.assign({}, state, { pending: String(taskId) }));
        const refreshVm = yktVue(source.root, vm => typeof yktSpaceValue(vm, "getStudyProgress") === "function");
        log(homeworkSaved ? "网站已确认本作业 " + completion.submitted + "/" + completion.total + " 题提交,按左侧目录继续"
            : "本节已处理,在当前目录核对网站进度");
        // 作业提交和得分/目录百分比是两件事;已核实全题提交即可点下一任务,不改写网站进度。
        let saved = !!homeworkSaved;
        for (let i = 0; !saved && i < 12 && active(); i++) {
            const task = source.tasks.find(t => t.id === String(taskId));
            if (task && task.done) { saved = true; break; }
            if (refreshVm) {
                // 只调用网站现有的进度查询,不写学习进度;未返回的请求最多等待一次。
                let settled = false;
                await new Promise(resolve => {
                    const timer = setTimeout(resolve, 5000);
                    Promise.resolve().then(() => yktSpaceValue(refreshVm, "getStudyProgress").call(refreshVm))
                        .catch(() => {}).finally(() => { settled = true; clearTimeout(timer); resolve(); });
                });
                if (!settled) break;
            }
            await sleep(5000);
            source = yktSpaceSource();
            if (!source) break;
        }
        if (!active()) return true;
        source = yktSpaceSource();
        saved = saved || !!(source && source.tasks.some(t => t.id === String(taskId) && t.done));
        if (!saved) {
            log("本节已处理,网站进度尚未确认完成,已保留当前节;可刷新后继续", "warn");
            return true;
        }
        if (!source) return true;
        yktTaskSync(source.tasks);
        const index = source.tasks.findIndex(t => t.id === String(taskId));
        if (index < 0) { log("当前课节已不在目录中,停止本次切节", "warn"); return true; }
        // 连播只向后走。末节结束不能绕回之前进度尚未更新的课节。
        const ordered = source.tasks.slice(index + 1);
        const next = ordered.find(t => (t.type === 0 || t.type === 6) && !t.done && !t.locked);
        if (!next) { log("后面没有可处理的未完成视频或作业,本次任务结束"); return true; }
        if (!next.row || !next.row.isConnected) {
            // 章节折叠时用网站自己的展开方法,随后重新按 ID 定位。
            const expand = yktSpaceValue(source.vm, "expandAllMenu");
            if (typeof expand === "function") { try { expand.call(source.vm); } catch (e) {} }
            for (let i = 0; i < 50 && active(); i++) {
                await sleep(200);
                const fresh = yktSpaceSource(), target = fresh && fresh.tasks.find(t => t.id === next.id);
                if (target && target.row && target.row.isConnected) break;
            }
        }
        if (!active()) return true;
        source = yktSpaceSource();
        const target = source && source.tasks.find(t => t.id === next.id && !t.done && !t.locked);
        const notice = yktNavigationNotice({ doc: document });
        if (notice || !target || !target.row || !target.row.isConnected) {
            log(notice ? "网站提示:" + notice : "下一节目录未展开或无法唯一定位,请在左侧选择视频", "warn"); return true;
        }
        const path = location.pathname, nextPath = path.replace(/\/(?:video|exercise)\/[^/]+\/?$/,
            "/" + (target.type === 6 ? "exercise" : "video") + "/" + encodeURIComponent(target.id));
        const remembered = yktContext();
        if (remembered && remembered.transition && remembered.transition.fromPath === path
            && remembered.transition.toPath === nextPath) {
            log("本次已点击过该下一节,页面又回到了上一节;已停止重复切换,请检查页面提示", "warn"); return true;
        }
        if (state && !yktContext(Object.assign({}, state, { leafId: target.id, videoPath: nextPath, pending: null,
            transition: { fromPath: path, toPath: nextPath, fromId: String(taskId), toId: target.id },
            tasks: source.tasks.map(t => ({ id: t.id, name: t.name, chapter: t.chapter, type: t.type,
                done: t.done, percent: t.percent, locked: t.locked })) }))) {
            log("无法记录本次切节,已保留当前页面", "warn"); return true;
        }
        yktTaskState(target.id, "进行中", "正在点击目录");
        log("点击左侧目录下一节:「" + target.name + "」");
        try { target.row.scrollIntoView({ block: "nearest" }); target.row.click(); }
        catch (e) { log("目录点击失败,请手动打开该视频", "warn"); return true; }
        for (let i = 0; i < 50 && active(); i++) await sleep(200);
        if (location.pathname === nextPath) log(target.type === 6 ? "已进入下一节作业,交给答题流程" : "已进入下一节地址,等待课节数据和播放器就绪");
        else if (active()) {
            const message = yktNavigationNotice({ doc: document }) || "目录点击后未切换,请检查页面提示";
            yktTaskState(target.id, "待做", message); log(message, "warn");
        }
        return true;
    }
    // 讨论页:默认不评论(risk);"first"抄第一条
    async function yktDiscuss(log) {
        if (cxSet("study_discuss") !== "first") { log("讨论自动回复未开启,保留当前页面"); return; }
        const box = document.querySelector("textarea.el-textarea__inner");
        if (!box) { log("讨论页没有输入框,当看过跳过", "warn"); return; }
        const first = document.querySelector(".new_discuss_list .cont_detail");
        if (!first) { log("讨论区没内容可抄,跳过", "warn"); return; }
        box.value = first.textContent || "";
        box.dispatchEvent(new Event("input", { bubbles: true }));
        await sleep(1e3);
        const btn = document.querySelector("button.submitComment");
        if (btn) { try { btn.click(); } catch (e) {} log("讨论已抄第一条提交"); }
        else log("没找到提交按钮(已填未提交)", "warn");
    }
    async function yktRun() {
        // 共享倍速:读 cx_video_rate,第142轮起不再夹 2(见 moocRun 注释)。原来那栏 ykt_rate 已删。
        const rate = yktRate();
        cxArm();
        const log = (m, lv) => logMsg("雨课堂刷课: " + m, lv);
        const path = location.pathname;
        const active = () => yktActive(path);
        let source = null;
        if (!active()) return;
        if (yktHomeworkOuter() || yktHomeworkPage()) return;
        keepTabAwake();
        if (yktIsAi() && !yktVideoPage()) {
            log("AI 学伴工作台:展开树,找下一个未完成叶子");
            await yktAiExpand();
            let leafs = [];
            for (let i = 0; i < 100 && !leafs.length; i++) { await sleep(200); leafs = yktAiLeafs(); }
            if (!leafs.length) { log("AI 工作台没读到叶子,不动", "warn"); return; }
            yktTaskSync(leafs.map((leaf, i) => ({ id: "ai:" + i, name: yktAiName(leaf), type: 0,
                done: yktAiDone(leaf), locked: yktAiSkip(leaf), percent: null })));
            log("AI 工作台扫描到 " + leafs.length + " 个任务");
            // 从当前(.is-active)的下一个开始;没有 active 就从第一个
            const cur = leafs.findIndex(l => l.classList && l.classList.contains("is-active"));
            const startIdx = cur >= 0 ? cur : -1;
            let target = yktAiNext(startIdx);
            let guard = 0;
            while (!target && guard++ < 2) { target = yktAiNext(-1); if (target) break; }
            if (!target) { log("AI 学伴整门都学完了(或全是自测)", "warn"); return; }
            if (!await yktAiStudyLeaf(target, rate, log)) return;
            // 循环:点下一个,直到没有(SPA 内切,不整页跳)
            for (let i = 0; i < 200; i++) {
                if (cxTimeUp()) { cxDisarm(); log("到点收工", "warn"); return; }
                leafs = yktAiLeafs();
                const idx = leafs.findIndex(l => l === target);
                if (idx < 0) { log("目录刷新后无法重新定位当前叶子,已暂停切节", "warn"); return; }
                target = yktAiNext(idx);
                if (!target) { log("AI 学伴整门刷完", "warn"); return; }
                if (!await yktAiStudyLeaf(target, rate, log)) return;
            }
            return;
        }
        if (/^\/v2\/web\/studentLog(?:\/|$)/.test(path)) {
            source = await yktEnterDirectory(log, active);
            if (!source || !active()) return;
        }
        if (yktVideoPage() || /\/video-student\//.test(path) || /^\/pro\/lms\/[^/]+\/[^/]+\/video\//.test(path)
            || (!source && !yktIsList() && yktIsVideo())) {
            let state = yktContext();
            // SPA 的异步回调/网站限制可能把下一节退回上一节。不得自动重播并再次点击同一目标。
            if (state && state.transition && state.transition.fromPath === path) {
                yktTaskState(state.transition.toId, "待做", "切节后页面返回 · 连播已暂停");
                log("切到下一节后页面又返回上一节,已暂停重复播放和切换;请检查网站提示,处理后关闭再开启连播", "warn");
                return;
            }
            log("视频页:接管课节 " + path.split("/").filter(Boolean).pop());
            if (state && state.tasks) yktTaskSync(state.tasks);
            const space = yktSpaceSource();
            if (space) yktTaskSync(space.tasks);
            const leafId = path.split("/").filter(Boolean).pop();
            const taskId = state && state.videoPath === path ? state.leafId : leafId;
            const status = await yktWatchVideo(rate, log, active, note => yktTaskState(taskId, "进行中", note));
            if (status !== "ended" || !active()) {
                const reason = { missing: "播放器未加载", replaced: "播放器反复重建", error: "视频加载失败",
                    stuck: "视频未推进 · 请检查页面", stopped: "播放已停止" };
                yktTaskState(taskId, "待做", reason[status] || "播放未完成"); return;
            }
            yktTaskState(taskId, "待确认", "视频已播完 · 等待网站保存");
            const endedMedia = yktMedia();
            if (yktMediaMatches(endedMedia, path)) { try { endedMedia.pause(); } catch (e) {} }
            if (!state || state.videoPath !== path) {
                const list = new URL(location.href);
                if (/\/video-student\//.test(path) || /^\/ai-workspace\//.test(path)) list.pathname = "/v2/web/studentLog/" + yktClass(location.href);
                else list.pathname = list.pathname.replace(/\/video\/[^/]+\/?$/, "/studycontent");
                list.searchParams.delete("start"); list.searchParams.delete("end");
                state = { listUrl: list.href, leafId: leafId, videoPath: path };
            }
            if (await yktContinueSpace(taskId, state, log, active)) return;
            log("本节播放结束,等待保存后回目录核对进度");
            state.pending = state.leafId;
            if (!yktContext(state)) { log("无法保存连续播放状态,已停留在本节", "warn"); return; }
            await sleep(5e3);
            if (active()) location.href = state.listUrl;
            return;
        }
        if (yktIsForum()) {
            log("讨论页");
            await yktDiscuss(log);
            return;
        }
        // 等网站目录和进度请求都完成后再挑任务,避免空进度误判全部未学。
        let tasks = [], dir = null;
        for (let i = 0; i < 300 && active(); i++) {
            source = yktSource() || source;
            dir = source && source.dir;
            if (dir && !dir.loading) {
                if (typeof dir.setFoldAll === "function") dir.setFoldAll(false);
                await sleep(200);
                tasks = yktTasks(source);
                const candidate = tasks.find(t => t.type === 0 && !t.done && !t.locked);
                if (tasks.length && (!source.embedded || !candidate || candidate.row || yktLearningSpaceUrl(candidate, source))) break;
            }
            await sleep(200);
        }
        if (!active()) return;
        if (!tasks.length) {
            const count = yktLeafs(source ? source.doc : document).length;
            log("未读取到课程任务数据:目录行 " + count + " 个,课程组件" + (dir ? "已找到" : "未找到")
                + "。请在「学习内容」页刷新重试", "warn"); return;
        }
        yktTaskSync(tasks);
        yktBindRows(source, tasks);
        log("扫描到 " + tasks.length + " 个任务,其中视频 " + tasks.filter(t => t.type === 0).length
            + " 个,未完成视频 " + tasks.filter(t => t.type === 0 && !t.done && !t.locked).length + " 个"
            + (source.embedded ? "(内嵌课程目录)" : ""));
        const state = yktContext();
        if (state && state.pending != null) {
            log("核对上一节的服务器进度");
            yktTaskState(state.pending, "待确认", "等待网站进度更新");
            let saved = false;
            for (let i = 0; i < 9 && active(); i++) {
                if (Number((dir.leaf_schedules || {})[state.pending]) >= 1) { saved = true; break; }
                // 网站自带只读刷新方法。每次至多等 5 秒,不让未返回的请求卡死。
                if (typeof dir.getLearnSchedule === "function") {
                    await new Promise(resolve => {
                        const timer = setTimeout(resolve, 5e3);
                        Promise.resolve().then(() => dir.getLearnSchedule()).catch(() => {})
                            .then(() => { clearTimeout(timer); resolve(); });
                    });
                }
                await sleep(5e3);
            }
            if (!active()) return;
            saved = saved || Number((dir.leaf_schedules || {})[state.pending]) >= 1;
            if (!saved) { log("上一节已播完,但网站尚未记为完成。已暂停切节,请检查课程进度后刷新继续", "warn"); return; }
            state.pending = null;
            yktContext(state);
            tasks = yktTasks(source);
            yktTaskSync(tasks);
        }
        const next = tasks.find(task => task.type === 0 && !task.done && !task.locked);
        if (!next) { log("当前目录没有可播放的未完成视频;其他类型或未开放任务需在页面查看"); return; }
        const learningUrl = yktLearningSpaceUrl(next, source);
        if (learningUrl) {
            log("按课程学习空间地址在当前标签打开:「" + next.name + "」");
            yktSameTabVideo(next, source, tasks, learningUrl, log, active);
            return;
        }
        if (source.embedded) {
            if (!next.row) { log("任务已扫描,但对应目录条目尚未展开。请展开章节后重试", "warn"); return; }
            const videoPath = new URL(yktWebVideoUrl(next, source) || location.href).pathname;
            if (!yktRemember(source, next, tasks, videoPath)) { log("无法保存连续播放状态,请允许本站存储", "warn"); return; }
            log("按课程原生目录打开:「" + next.name + "」");
            next.row.click();
            for (let i = 0; i < 25 && active(); i++) await sleep(200);
            if (!active()) return;
            const fresh = yktSource(), notice = yktNavigationNotice(fresh || source);
            if (notice) { yktTaskState(next.id, "待做", notice); log("网站提示:" + notice, "warn"); return; }
            const freshTasks = fresh && !fresh.dir.loading ? yktTasks(fresh) : [];
            const target = freshTasks.find(t => t.id === next.id && t.type === 0 && !t.locked && !t.done);
            if (!target) {
                yktTaskState(next.id, "待做", "目录状态已变化");
                log("点击后目录状态已变化,暂停本次跳转", "warn"); return;
            }
            log("原生目录未切换,改为在当前标签打开同一节视频");
            const url = yktLearningSpaceUrl(target, fresh) || yktWebVideoUrl(target, fresh);
            if (!yktSameTabVideo(target, fresh, freshTasks, url, log, active))
                log("无法确认本节播放地址,请手动打开视频", "warn");
            return;
        }
        const url = yktTaskUrl(next, source), vm = next.vm || dir;
        if (!url) { log("无法读取本节的播放地址,请手动打开视频", "warn"); return; }
        // 旧版顶层目录也统一进入实际 pro 目录,后续返回地址与课程绑定。
        if (!yktCourse(location.href)) {
            const list = new URL(url);
            list.pathname = list.pathname.replace(/\/video\/[^/]+\/?$/, "/studycontent");
            list.searchParams.delete("start"); list.searchParams.delete("end");
            location.href = list.href;
            return;
        }
        if (!yktRemember(source, next, tasks, new URL(url).pathname)) { log("浏览器未允许保存连续播放状态,请允许本站存储后重试", "warn"); return; }
        // 与网站 goDetail 相同的状态持久化;使用当前标签页避免新标签被拦截。
        try { if (vm.$store && vm.$store.state) localStorage.setItem("provuex", JSON.stringify(vm.$store.state)); } catch (e) {}
        log("播放未完成视频:「" + next.name + "」");
        yktTaskState(next.id, "进行中", "正在打开视频");
        if (active()) location.href = url;
    }
    // 面板在课程首页/学习日志/未完成页都可用,不依赖自动播放开关或视频任务 DOM。
    // 作业/考试页由各自的 WorkerJSPlus 建面板,避免先占掉它的平台标题。
    function yktPanelPage() {
        if (yktHomeworkOuter()) return true;
        if (/\/(result|exam|exercise|cover)(\/|$)/.test(location.pathname)) return false;
        return /^\/v2\/web(\/|$)/.test(location.pathname)
            || /^\/ai-workspace\/lms-graph(\/|$)/.test(location.pathname)
            || yktIsList() || yktIsVideo() || yktIsForum();
    }
    function yktKeepPanel() {
        const panel = PANEL;
        if (!panel || !panel.host || panel.yktKept) return;
        panel.yktKept = true;
        panel.setVisual("normal");
        const doc = panel.host.ownerDocument;
        let restoring = false;
        // 课程 SPA 重绘 body 时可能移走脚本宿主。只挂回原对象,不重建面板、不重启任务。
        // 延后一拍恢复,避免页面连续更新时同步反复插入。
        const observer = new MutationObserver(() => {
            if (panel.host.isConnected || restoring) return;
            restoring = true;
            setTimeout(() => {
                restoring = false;
                if (!panel.host.isConnected && doc.body) doc.body.appendChild(panel.host);
            }, 100);
        });
        observer.observe(doc, { childList: true, subtree: true });
    }
    function yktBoot() {
        if (window.top !== window.self || !yktHost()) return;
        yktHomeworkBridge();
        // 面板只挂一次;持续观察路由,覆盖从课程首页进入学习页的 SPA 导航。
        let mounted = false, running = false, runKey = "", scanKey = "", scanState = "", homeKey = "";
        setInterval(() => {
            if (!document.body || !yktPanelPage()) return;
            // 雨课堂进入时展开面板,避免旧存档 hide=true 只闪出一个 5 秒就消失的黄色提示。
            // 用户进来后仍可用面板关闭按钮/快捷键主动隐藏。
            if (!mounted) {
                mounted = true;
                GM_setValue("hide", false);
                showPanel("刷课 · 雨课堂");
                yktKeepPanel();
                if (!cxSet("ykt_do")) logMsg("雨课堂面板已就绪。在总览开启「自动播放并连播」后,进入学习内容即可连续播放");
            }
            if (yktHome()) {
                const courses = yktCourses();
                if (PANEL && PANEL.setYktCourses) PANEL.setYktCourses(courses, yktOpenCourse);
                const key = JSON.stringify(courses.map(c => [c.id, c.name]));
                if (key !== homeKey) {
                    homeKey = key;
                    logMsg(courses.length ? "雨课堂首页:识别到 " + courses.length + " 门课程,请在面板「总览」选择课程并扫描"
                        : "雨课堂首页:等待课程列表,请打开「我听的课」");
                }
                runKey = "";
                return;
            }
            homeKey = "";
            if (PANEL && PANEL.setYktCourses) PANEL.setYktCourses(null);
            // 首页主动选择课程属于一次扫描请求,关闭自动播放时也会打开学习内容。
            if (!running && yktTakeHomeScan()) {
                running = true; runKey = "";
                yktScanHomeCourse().catch(e => logMsg("雨课堂扫描失败:" + (e.message || e), "error"))
                    .finally(() => { running = false; });
                return;
            }
            // 扫描/展示任务不依赖自动播放开关。仅在目录页扫描,不覆盖视频页的进行中状态。
            if (!/\/video-student\//.test(location.pathname) && !/\/video\/[^/]+\/?$/.test(location.pathname)) {
                const source = yktSource();
                if (source && !source.dir.loading) {
                    const tasks = yktTasks(source);
                    const key = yktClass(location.href) + ":" + tasks.map(t => t.id).join(",");
                    const state = key + ":" + tasks.map(t => t.percent + "/" + t.locked).join(",");
                    yktBindRows(source, tasks);
                    if (tasks.length && state !== scanState) {
                        yktTaskSync(tasks);
                        if (key !== scanKey && !running) runKey = "";
                        scanKey = key; scanState = state;
                    }
                }
            }
            if (!cxSet("ykt_do") || GLOBAL.stop) {
                runKey = "";
                const state = yktContext();
                if (state && state.transition) { delete state.transition; yktContext(state); }
                return;
            }
            if (yktHomeworkOuter()) {
                // 作业页只能由作业 worker 驱动,避免旧 AI 工作台分支抢点下一个叶子。
                runKey = "";
                const state = yktContext();
                if (state && state.transition && state.transition.toPath !== location.pathname) {
                    delete state.transition; yktContext(state);
                }
                return;
            }
            const key = location.pathname;
            if (running || key === runKey) return;
            if (yktIsList() || yktIsVideo() || yktIsForum() || yktIsAi()) {
                runKey = key;
                running = true;
                yktRun().catch(e => logMsg("雨课堂启动失败:" + (e.message || e), "error"))
                    .finally(() => { running = false; });
            } else runKey = "";
        }, 1000);
    }
    yktBoot();
    // ══ 中国大学MOOC 答题(icourse163)══════════════════════════════
    // 作业在 /learn 的 hash=#/learn/quiz(SPOC 是 /spoc/learn 同构),考试在
    // #/learn/examObject 或 /mooc/main/newExam。DOM 抄 参考实现ICourseProject.work:
    //   作业题 .u-questionItem:题干 .j-title .j-richTxt,选项 .choices li,填空 .inputArea;
    //   考试题 [class*=questionBody]:题干 [class*=questionInfo],选项 [class*=optionBody]。
    // 单选/多选/判断没配 fill → 走默认点选项;填空/简答填 textarea(UE 或原生)。
    function moocExamHost() {
        return (location.hostname === "www.icourse163.org" || location.hostname === "icourse163.org")
            && (location.hash.indexOf("learn/examObject") >= 0
                || location.pathname.indexOf("/mooc/main/newExam") >= 0);
    }
    function moocQuizHost() {
        return (location.hostname === "www.icourse163.org" || location.hostname === "icourse163.org")
            && location.hash.indexOf("learn/quiz") >= 0
            && location.hash.indexOf("learn/quizscore") < 0;
    }
    WorkerJSPlus({
        name: "中国大学MOOC 测验/作业",
        match: moocQuizHost,
        root: ".u-questionItem",
        elements: {
            question: ".j-title .j-richTxt",
            options: ".choices li, .inputArea",
            $options: ".choices li, .inputArea"
        },
        wrap: obj => {
            obj.question = formatString(obj.question.replace(/^\s*\d+[.、]\s*/, ""));
            obj.options = obj.options.map(i => formatString(String(i).replace(/^[A-Za-z][.、)\s]*/, "")));
            // 答过的选项会标 .u-icon-correct/.u-icon-wrong —— 它们该被跳过
            if (obj.$options && obj.$options.length) {
                obj.$options = obj.$options.filter((i, el) => {
                    return !$(el).find(".u-icon-correct,.u-icon-wrong").length;
                });
            }
        },
        fill: (type, answer, $option) => {
            if (type === 2 || type === 4 || type === 5) {
                const ta = $option.find("textarea");
                if (ta.length) {
                    const ed = typeof UE$1 !== "undefined" && UE$1.getEditor(ta.attr("name"));
                    if (ed) ed.setContent(answer); else ta.val(answer);
                }
            }
        },
        finished: () => {
            // MOOC 作业是单题滚动(SPA hash 换 #/learn/quiz?lessonId=..&questionId=..),
            // 不像别的平台有"下一题"按钮 —— 填完自动交的开关交给框架的自动交卷。
            return false;
        }
    });
    WorkerJSPlus({
        name: "中国大学MOOC 考试",
        match: moocExamHost,
        root: "[class*=questionBody]",
        elements: {
            question: "[class*=questionInfo] .j-richTxt, [class*=questionInfo]",
            options: "[class*=optionBody]",
            $options: "[class*=optionBody] input, [class*=optionBody] textarea",
        },
        ignore_click: $item => {
            const inp = $item.find("input");
            return inp.length && inp.prop("checked");
        },
        wrap: obj => {
            obj.question = formatString(obj.question.replace(/^\s*\d+[.、]\s*/, ""));
            obj.options = obj.options.map(i => formatString(String(i).replace(/^[A-Za-z][.、)\s]*/, "")));
        },
        fill: (type, answer, $option) => {
            if (type === 2 || type === 4 || type === 5) {
                const ta = $option.find("textarea");
                if (ta.length) {
                    const ed = typeof UE$1 !== "undefined" && UE$1.getEditor(ta.attr("name"));
                    if (ed) ed.setContent(answer); else ta.val(answer);
                }
            }
        }
    });
    WorkerJSPlus({
        name: "学习通作业",
        match: location.pathname === "/mooc2/work/dowork" || location.pathname === "/mooc-ans/mooc2/work/dowork",
        root: ".questionLi",
        elements: {
            question: "h3",
            options: ".stem_answer .answerBg .answer_p, .textDIV, .eidtDiv",
            $options: ".stem_answer .answerBg, .textDIV, .eidtDiv",
            type: "input[type^=hidden]:eq(0)"
        },
        wrap: obj => {
            obj.question = obj.question.replace(obj.$item.find(".colorShallow").text(), "").replace(/^(\d+\.\s)/, "");
        },
        ignore_click: $item => {
            return Boolean($item.find(".check_answer,.check_answer_dx").length);
        },
        fill: (type, answer, $option) => {
            if (type === 4 || type === 2 || type === 5) {
                UE$1.getEditor($option.find("textarea").attr("name")).setContent(answer);
            }
        }
    });
    WorkerJSPlus({
        name: "超星旧版考试",
        match: (location.pathname === "/exam/test/reVersionTestStartNew" || location.pathname === "/exam-ans/exam/test/reVersionTestStartNew") && !location.href.includes("newMooc=true"),
        root: ".TiMu",
        elements: {
            question: ".Cy_TItle .clearfix",
            options: ".Cy_ulTop .clearfix",
            $options: ":radio, :checkbox, .Cy_ulTk textarea",
            type: "[name^=type]:not([id])"
        },
        ignore_click: $item => {
            return $item.get(0).checked;
        },
        fill: (type, answer, $option) => {
            if (type === 4 || type === 2 || type === 5) {
                UE$1.getEditor($option.attr("name")).setContent(answer);
            }
        },
        finished: auto_jump => {
            auto_jump && setInterval(function() {
                const btn = $(".saveYl:contains(下一题)").offset();
                var mouse = document.createEvent("MouseEvents"), arr = [ btn.left + Math.ceil(Math.random() * 80), btn.top + Math.ceil(Math.random() * 26) ];
                mouse.initMouseEvent("click", true, true, document.defaultView, 0, 0, 0, arr[0], arr[1], false, false, false, false, 0, null);
                _self.event = $.extend(true, {}, mouse);
                delete _self.event.isTrusted;
                _self.getTheNextQuestion(1);
            }, Math.ceil(GLOBAL.fillAnswerDelay * Math.random()) * 2);
        }
    });
    WorkerJSPlus({
        name: "超星章节测验",
        match: location.pathname === "/work/doHomeWorkNew" || location.pathname === "/mooc-ans/work/doHomeWorkNew",
        init: start,
        root: ".clearfix .TiMu",
        elements: {
            question: ".Zy_TItle .clearfix",
            options: "ul:eq(0) li .after",
            // 章节测验(doHomeWorkNew)的选项没有原生 radio/checkbox：每个 <li> 自己带
            // onclick="addChoice(this)"、role="radio|checkbox"，里面只有一个 .num_option 的 <span>。
            // 填答案是 $options.eq(i).get(0).click()，原来点的是那个 span —— 合成 click 在这版式上
            // 不触发 <li> 的 addChoice(真机实测：题干正常、答案也算出来了，却选不上)。所以选择题
            // 直接把 <li role> 当 $options(点击宿主就是它)；填空题仍取 li 里的 textarea 给 fill 回调。
            // 保留 :radio/:checkbox 作别的版式(有原生控件、li 不带 role)的兜底。
            $options: "ul:eq(0) li[role], ul:eq(0) li textarea, ul:eq(0) li :radio, ul:eq(0) li :checkbox",
            type: "input[name^=answertype]"
        },
        ignore_click: $item => {
            if ($item.is("input")) {
                return $item.get(0).checked;
            }
            // 选择题现在的 $item 是 <li>：选中后超星会给它 / 里面的 .num_option 加高亮类，
            // 认得出就别重复点(单选重复点会取消)；认不出(全新题)返回 false 照旧点一次。
            const cls = ($item.attr("class") || "") + " " + ($item.find(".num_option").attr("class") || "");
            return /check_answer|checkStatus|\bcur\b|\bactive\b|\bcheck\b/.test(cls);
        },
        fill: async (type, answer, $option) => {
            if (type === 4 || type === 2 || type === 5) {
                // 填空:$option 是 li 里的 textarea,取它的 name 喂 UEditor
                const name = $option.is("textarea") ? $option.attr("name") : $option.find("textarea").attr("name");
                UE$1.getEditor(name).setContent(answer);
            }
        }
    });
    WorkerJSPlus({
        name: "超星新版考试",
        match: () => {
            const cxSinglePage = (location.pathname === "/exam/test/reVersionTestStartNew" || location.pathname === "/exam-ans/exam/test/reVersionTestStartNew" || location.pathname === "/mooc-ans/exam/test/reVersionTestStartNew") && location.href.includes("newMooc=true");
            const cxAll = location.pathname === "/mooc2/exam/preview" || location.pathname === "/exam-ans/mooc2/exam/preview" || location.pathname === "/mooc-ans/mooc2/exam/preview";
            return cxSinglePage || cxAll;
        },
        root: ".questionLi",
        elements: {
            question: "h3 div",
            options: ".answerBg .answer_p, .textDIV, .eidtDiv",
            $options: ".answerBg, .textDIV, .eidtDiv",
            type: "input[name^=type]:eq(" + GLOBAL.i + ")"
        },
        ignore_click: $item => {
            return Boolean($item.find(".check_answer,.check_answer_dx").length);
        },
        hook: () => {
            GLOBAL.i = Number((location.pathname === "/exam/test/reVersionTestStartNew" || location.pathname === "/exam-ans/exam/test/reVersionTestStartNew" || location.pathname === "/mooc-ans/exam/test/reVersionTestStartNew") && location.href.includes("newMooc=true"));
        },
        wrap: obj => {
            if (obj.type === 6) {
                obj.type = 4;
            }
        },
        fill: (type, answer, $option) => {
            if (type === 4 || type === 2 || type === 5) {
                const name = $option.find("textarea").attr("name");
                UE$1.getEditor(name).setContent(answer);
                if (GLOBAL.i === 0) {
                    console.log("#" + name.replace("answerEditor", "save_"));
                    $("#" + name.replace("answerEditor", "save_")).click();
                }
            }
        },
        finished: a => {
            a && $('.nextDiv .jb_btn:contains("下一题")').click();
        }
    });
    WorkerJSPlus({
        name: "超星随堂测验",
        match: location.pathname.includes("/page/quiz/stu/answerQuestion"),
        root: ".question-item",
        elements: {
            question: ".topic-txt",
            options: ".topic-option-list",
            $options: ".topic-option-list input",
            type: "input[class^=que-type]"
        },
        ignore_click: $item => {
            return Boolean($item.find(".check_answer,.check_answer_dx").length);
        },
        wrap: obj => {
            if (obj.type === 16) {
                obj.type = 3;
            }
        },
        fill: (type, answer, $option) => {
            if (type === 4 || type === 2) {
                $option.val(answer);
            }
        }
    });
    function JSONParseHook(func) {
        if (location.host.includes("zhihuishu")) {
            let oldSend = XMLHttpRequest.prototype.send;
            XMLHttpRequest.prototype.send = function() {
                this.addEventListener("readystatechange", function() {
                    if (this.readyState === 4 && this.response.includes("workExamParts")) {
                        try {
                            func(JSON.parse(this.response));
                        } catch (err) {}
                    }
                }, false);
                return oldSend.apply(this, arguments);
            };
        } else {
            const parse = JSON.parse;
            JSON.parse = function(...args) {
                const o = parse.call(this, ...args);
                func(o);
                return o;
            };
        }
    }
    function hookZhiHuiShuWork(o, arr) {
        function format(item) {
            let options = [];
            let options_id;
            if (item.questionOptions && item.questionOptions.length) {
                options = item.questionOptions.map(o => {
                    return formatString(o.content);
                });
                options_id = item.questionOptions.map(o => {
                    return o.id;
                });
            }
            return {
                qid: item.id,
                question: formatString(item.name),
                type: getQuestionType(item.questionType.name),
                options_id: options_id,
                options: options
            };
        }
        if (o.rt && o.rt.examBase && o.rt.examBase.workExamParts.length > 0) {
            GLOBAL.content = o.rt;
            GLOBAL.json = o.rt.examBase.workExamParts.map(part => {
                return part.questionDtos.map(item => {
                    if ("阅读理解（选择）/完型填空" === item.questionType.name || "听力训练" === item.questionType.name || !(item.questionType.name.includes("填空") || item.questionType.name.includes("问答")) && item.questionChildrens && item.questionChildrens.length > 0) {
                        return item.questionChildrens.map(i => {
                            console.log(format(i));
                            return format(i);
                        }).flat();
                    } else {
                        return format(item);
                    }
                });
            }).flat();
        } else if (o.rt && Object.keys(o.rt).length > 0 && !isNaN(Object.keys(o.rt)[0])) {
            GLOBAL.img = o.rt;
        }
    }
    WorkerJSPlus({
        name: "智慧树作业/考试",
        match: !location.href.includes("checkHomework") && location.host.includes("zhihuishu") && (location.pathname === "/stuExamWeb.html" || location.href.includes("/webExamList/dohomework/") || location.href.includes("/webExamList/doexamination/")),
        root: ".examPaper_subject",
        elements: {
            question: ".subject_describe div,.smallStem_describe p",
            options: ".subject_node .nodeLab .node_detail",
            $options: ".subject_node .nodeLab .node_detail",
            type: ".subject_type span:first-child"
        },
        hook: () => {
            JSONParseHook(hookZhiHuiShuWork);
        },
        intv: () => {
            return $(".answerCard").length;
        },
        wrap: obj => {
            Object.assign(obj, GLOBAL.json[GLOBAL.index - 1]);
            console.log(obj);
            if ($(".yidun_popup").hasClass("yidun_popup--light")) {
                iframeMsg("tip", {
                    type: "stop",
                    tip: "答题暂停，请自行通过验证"
                });
                GLOBAL.stop = true;
            }
        },
        ignore_click: $item => {
            return $item.hasClass("onChecked");
        },
        fill: (type, answer, $option) => {
            if (type === 4 || type === 2) {
                UE$1.getEditor($option.find("textarea").attr("name")).setContent(answer);
            }
        },
        finished: async () => {
            const saving = vm.saveMask("正在保存");
            // finally 关遮罩：原来是「进度到 100 才关」，于是 len===0（一道题都没抓到）
            // 或者中途抛异常时，整页被那层半透明遮罩永久锁住，只能刷新
            try {
                const len = $(".answerCard_list li").length;
                for (let i = 0; i < len; i++) {
                    await sleep(500);
                    try {
                        $(".answerCard_list1 li").eq(i).click();
                        await sleep(1e3);
                        $(".el-button:contains(下一题)").click();
                    } catch (e) {
                        $(".el-button:contains(保存)").click();
                    }
                    saving.set((i + 1) / len * 100);
                }
            } finally {
                saving.close();
            }
        },
        fillFinish: () => {
            // 点击答题卡对应题目
            const cardItem = $(".answerCard_list li").eq(GLOBAL.index - 1);
            if (cardItem.length > 0) {
                const cardEl = cardItem.get(0);
                if (typeof safeClick === 'function') {
                    safeClick(cardEl, { clickInner: false });
                } else {
                    cardEl.click();
                }
            }
            
            // 点击下一题按钮
            const nextBtn = $(".el-button:contains(下一题)");
            if (nextBtn.length > 0 && nextBtn.is(':visible')) {
                const btnEl = nextBtn.get(0);
                if (typeof safeClick === 'function') {
                    safeClick(btnEl, { clickInner: false });
                } else {
                    btnEl.click();
                }
            }
        }
    });
    WorkerJSPlus({
        name: "智慧树学分课作业",
        match: location.href.includes("/atHomeworkExam/stu/homeworkQ/exerciseList") || location.href.includes("atHomeworkExam/stu/examQ/examexercise"),
        root: ".questionBox:eq(0)",
        elements: {
            question: ".questionContent",
            options: ".optionUl label .el-radio__label,.el-checkbox__label",
            $options: ".optionUl label",
            type: ".questionTit"
        },
        intv: () => {
            return $(".answerCard").length || $(".questionTit").length;
        },
        wrap: async obj => {
            obj.options = obj.options.map(item => {
                return formatString(item.replaceAll(/^[a-zA-Z][.|\s+]/g, ""));
            });
            if ($(".yidun_popup").hasClass("yidun_popup--light")) {
                iframeMsg("tip", {
                    type: "stop",
                    tip: "答题暂停，请自行通过验证"
                });
                GLOBAL.stop = true;
            }
        },
        ignore_click: $item => {
            return $item.hasClass("is-checked");
        },
        finished: () => {
            if ($(".Nextbtndiv .Topicswitchingbtn-gray:contains(下一题)").hasClass("Topicswitchingbtn-gray")) return false;
            $(".Topicswitchingbtn:contains(下一题)").click();
            return true;
        }
    });
    WorkerJSPlus({
        name: "智慧树学分课考试",
        match: location.host === "studentexambaseh5.zhihuishu.com",
        root: ".ques-detail",
        elements: {
            question: ".questionName .centent-pre",
            options: ".radio-view li  .preStyle,.checkbox-views label .preStyle",
            $options: ".radio-view li,.checkbox-views label",
            type: ".letterSortNum"
        },
        intv: () => {
            return $(".questionContent").length;
        },
        ignore_click: $item => {
            return $item.hasClass("is-checked");
        },
        wrap: obj => {
            obj.options = obj.options.map(item => {
                return formatString(item.replaceAll(/^[a-zA-Z][.|\s+]/g, ""));
            });
            if ($(".yidun_popup").hasClass("yidun_popup--light")) {
                iframeMsg("tip", {
                    type: "stop",
                    tip: "答题暂停，请自行通过验证"
                });
                GLOBAL.stop = true;
            }
            if (obj.type === 15) {
                obj.question = formatString($(".centent-son-pre").text());
                obj.type = 1;
            }
        },
        finished: auto_jump => {
            if (auto_jump) {
                const btn = $(".next-topic:contains(下一题)");
                btn.click();
                return !btn.hasClass("noNext");
            }
        }
    });
    WorkerJSPlus({
        name: "智慧树作业查看",
        match: location.href.includes("checkHomework") && location.host.includes("zhihuishu"),
        hook: () => {
            JSONParseHook(hookZhiHuiShuWork);
        },
        init: () => {
            R({
                type: 2,
                content: GLOBAL.content,
                img: GLOBAL.img
            });
        }
    });
    GLOBAL.timeout = 10 * 1e3;
    function uploadAnswer(data) {
        const arr2 = division(data, 100);
        if (!GM_getValue("upload_answer")) return;   // 见 uploadAnswerToPlat 上面那段说明
        for (let arr2Element of arr2) {
            GM_xmlhttpRequest({
                method: "POST",
                url: "https://lyck6.cn/pcService/api/uploadAnswer",
                headers: {
                    "Content-Type": "application/json;charset=utf-8"
                },
                data: JSON.stringify(arr2Element),
                timeout: GLOBAL.timeout
            });
        }
    }
    // 这两个函数把「平台自己在页面 JSON 里泄露的标准答案」发回 lyck6.cn 的公共题库。
    // 发的不是你的作答、也不涉及你的 AI key，但它原来是无条件的：命中职教云/云课堂/
    // 雨课堂那几个适配器就自动上传，面板上没有任何开关，用户不知情。
    // 开关默认关 —— 往外发数据的事得用户自己点开，不能默认替他决定。
    // 闸设在函数入口而不是 7 个调用点：调用点散在适配器里，加一处漏一处，
    // 而这里改一次全都管住（下次谁新增适配器也自动受管）。
    function uploadAnswerToPlat(data, plat) {
        const arr2 = division(data, 100);
        if (!GM_getValue("upload_answer")) return;
        for (let arr2Element of arr2) {
            GM_xmlhttpRequest({
                method: "POST",
                url: "https://lyck6.cn/collect-service/v1/uploadAnswerToPlat?plat=" + plat,
                headers: {
                    "Content-Type": "application/json;charset=utf-8"
                },
                data: JSON.stringify(arr2Element),
                timeout: GLOBAL.timeout
            });
        }
    }
    // ══ 智慧树新形态课程 / AI助教 / examloop 答题 ═════════════════
    function zhSmartWorkHost() {
        const h = location.hostname, p = location.pathname;
        return (h === "smartcourseexam.zhihuishu.com" && p.indexOf("/ReviewExam") >= 0)
            || (h === "studentexamcomh5.zhihuishu.com" && p.indexOf("studentReviewTestOrExam") >= 0);
    }
    function zhFusionExamHost() {
        const h = location.hostname;
        return (h === "fusioncourseh5.zhihuishu.com" || h === "studywisdomh5.zhihuishu.com"
                || h === "wisdom-mooc.zhihuishu.com") && /\/exam/.test(location.pathname);
    }
    function zhExamLoopHost() {
        return location.hostname === "examloop.zhihuishu.com" && location.pathname.indexOf("/exam") >= 0;
    }
    // A:新形态课程作业 / 掌握提升 —— 单题滚动,做完点 .next-topic.next-t 翻下一题。
    WorkerJSPlus({
        name: "智慧树新形态作业",
        match: zhSmartWorkHost,
        root: ".questionContent",
        elements: {
            question: ".questionName .centent-pre",
            options: ".radio-view li.clearfix, .checkbox-views label.el-checkbox, .fillAnswer",
            $options: ".radio-view li.clearfix, .checkbox-views label.el-checkbox",
            type: ".letterSortNum"
        },
        intv: () => {
            return $(".questionContent").length;
        },
        ignore_click: $item => {
            const inp = $item.find("input");
            return inp.length && inp.prop("checked");
        },
        wrap: obj => {
            obj.options = obj.options.map(i => formatString(String(i).replace(/^[A-Za-z][.、)\s]*/, "")));
            if ($(".yidun_popup").hasClass("yidun_popup--light")) {
                iframeMsg("tip", { type: "stop", tip: "答题暂停,请自行通过验证" });
                GLOBAL.stop = true;
            }
        },
        finished: auto_jump => {
            if (!auto_jump) return false;
            const btn = $(".next-topic.next-t:visible");
            if (!btn.length || btn.hasClass("noNext") || btn.hasClass("is-disabled")) return false;
            btn.click();
            return true;
        }
    });
    // B:AI助教 / 新AI助教 / 新AI学伴掌握度 —— 整卷一屏扫完(.exam-item 全在页面上)。
    WorkerJSPlus({
        name: "智慧树AI助教掌握度",
        match: zhFusionExamHost,
        root: ".exam-item",
        elements: {
            question: ".quest-title .option-name",
            options: ".exam-item label",
            $options: ".exam-item label",
            type: ".quest-type"
        },
        ignore_click: $item => {
            const inp = $item.find("input");
            return inp.length && inp.prop("checked");
        },
        wrap: obj => {
            obj.options = obj.options.map(i => formatString(String(i).replace(/^[A-Za-z][.、)\s]*/, "")));
        }
    });
    // C:新形态课程考试(examloop)—— 整卷,无显式题型字段,defaultWorkTypeResolver 兜底。
    WorkerJSPlus({
        name: "智慧树新形态考试",
        match: zhExamLoopHost,
        root: ".question-area-content",
        elements: {
            question: "div.flex-1, .question-title, [class*=questionTitle]",
            options: "label.user-select.group",
            $options: "label.user-select.group"
        },
        ignore_click: $item => {
            const inp = $item.find("input");
            return inp.length && inp.prop("checked");
        },
        wrap: obj => {
            obj.question = formatString(obj.question);
            obj.options = obj.options.map(i => formatString(String(i).replace(/^[A-Za-z][.、)\s]*/, "")));
        }
    });
    WorkerJSPlus({
        name: "职教云考试",
        match: location.pathname === "/exam/examflow_index.action",
        intv: () => {
            return $(".divQuestionTitle").length;
        },
        root: ".q_content",
        elements: {
            question: ".divQuestionTitle",
            options: ".questionOptions .q_option",
            $options: ".questionOptions .q_option div,div[id^=_baidu_editor_]"
        },
        ignore_click: $item => {
            return $($item).attr("class") === "checkbox_on";
        },
        wrap: obj => {
            const type = getQuestionType(obj.$item.next().attr("answertype"));
            obj.type = type === undefined ? defaultWorkTypeResolver(obj.$options) : type;
        },
        fill: (type, answer, $option) => {
            if (type === 4 || type === 2 || type === 5) {
                UE$1.getEditor($option.attr("id")).setContent(answer);
            }
        },
        finished: async () => {
            if ($(".paging_next").attr("style").includes("block") || !$(".paging_next").attr("style").includes("none")) {
                $(".paging_next").click();
                await sleep(1e3);
                return true;
            }
        }
    });
    WorkerJSPlus({
        name: "职教云测验",
        match: location.pathname === "/study/directory/dir_course.html",
        intv: () => {
            return $(".panel_item").length;
        },
        root: ".panel_item .panel_item",
        elements: {
            question: ".preview_cm .preview_stem",
            options: ".preview_cm ul li span:last-child",
            $options: ".preview_cm ul li input"
        },
        wrap: obj => {
            obj.type = getQuestionType(obj.$item.parent().find(".panel_title").text());
            obj.options = obj.options.map(i => {
                return i.trim().replace(/^[abAB]\)\s+/, "").replace(/^[A-Za-z]\s+/, "").trim();
            });
        },
        ignore_click: $item => {
            return $item.attr("checked") === "checked";
        }
    });
    WorkerJSPlus({
        name: "职教云MOOC",
        match: location.pathname === "/study/homework/do.html" || location.pathname === "/study/workExam/testWork/preview.html" || location.pathname === "/study/onlineExam/preview.html" || location.pathname === "/study/workExam/homeWork/preview.html" || location.pathname === "/study/workExam/onlineExam/preview.html",
        root: ".e-q-r",
        elements: {
            question: ".e-q-q .ErichText",
            options: ".e-a-g li",
            $options: ".e-a-g li",
            type: ".quiz-type"
        },
        ignore_click: $item => {
            return $item.hasClass("checked");
        },
        wrap: obj => {
            if (obj.type === "A1A2题") {
                obj.type = 1;
            }
            obj.question = obj.question.replace(/<img src="https:\/\/cdn-zjy.icve.com.cn\/common\/images\/question_button\/blankspace(\d+).gif">/gi, "");
            obj.options = obj.options.map(i => {
                return i.trim().replace(/^[abAB]\)\s+/, "").replace(/^[A-Za-z]\s+/, "").trim();
            });
        }
    });
    function parseIcve(questions) {
        return questions.map(item => {
            const options = item.Selects.map(opt => {
                return formatString(opt);
            });
            const type = getQuestionType(item.ACHType.QuestionTypeName);
            const answer = item.Answers.map(key => {
                if (type === 0 || type === 1) {
                    return options[key.charCodeAt() - 65];
                } else if (type === 3) {
                    return key === "1" ? "正确" : "错误";
                }
            });
            const answerKey = type === 0 || type === 1 ? item.Answers : answer;
            const parsed = {
                id: item.Id,
                question: item.ContentText,
                answerKey: answerKey,
                options: type === 3 ? [ "正确", "错误" ] : options,
                answer: answer,
                type: type
            };
            uploadQuestionBankCandidate({
                question: formatString(item.ContentText),
                options: parsed.options,
                type: type
            }, answer, "智慧职教平台标准答案");
            return parsed;
        });
    }
    WorkerJSPlus({
        name: "资源库 新版",
        match: location.pathname === "/icve-study/jobTest" || location.pathname === "/icve-study/coursePreview/jobTest" || location.pathname === "/icve-study/coursePreview/test",
        root: ".subjectDet",
        elements: {
            question: "h5,.titleTest span:last",
            options: ".optionList label",
            $options: ".optionList input",
            type: ".title,.titleTest .xvhao"
        },
        ignore_click: $item => {
            return $item.prop("checked");
        },
        wrap: obj => {
            console.log(obj);
        },
        fill: (type, answer, $option) => {
            if (type === 4 || type === 2) {
                UE$1.getEditor($option.attr("name")).setContent(answer);
            }
        }
    });
    WorkerJSPlus({
        name: "资源库 WWW开头",
        match: location.pathname === "/study/works/works.html" || location.pathname === "/study/exam/exam.html",
        root: ".questions",
        elements: {
            question: ".preview_stem",
            options: "li .preview_cont",
            $options: "li input",
            type: "input:hidden"
        },
        hook: () => {
            JSONParseHook(o => {
                if (location.pathname === "/study/works/works.html") {
                    if (o.paper) {
                        GLOBAL.json = parseIcve(o.paper.PaperQuestions);
                        uploadAnswer(GLOBAL.json);
                    }
                } else if (location.pathname === "/study/exam/exam.html") {
                    if (o.array) {
                        GLOBAL.json = parseIcve(o.array.map(item => {
                            return item.Questions;
                        }).flat());
                        uploadAnswer(GLOBAL.json);
                    }
                }
            });
        },
        ignore_click: $item => {
            return $item.prop("checked");
        },
        wrap: obj => {
            function get_element(id) {
                for (let jsonElement of GLOBAL.json) {
                    if (jsonElement.id === id) {
                        return jsonElement;
                    }
                }
            }
            const ele = get_element(obj.$item.find("input:hidden").val());
            obj.question = ele.question;
            obj.answer = ele.answerKey ? ele.answerKey : ele.answer;
            obj.type = ele.type;
            obj.options = ele.options;
            console.log(obj);
        },
        fill: (type, answer, $option) => {
            if (type === 4 || type === 2) {
                UE$1.getEditor($option.attr("name")).setContent(answer);
            }
        }
    });
    WorkerJSPlus({
        name: "智慧职教 作业/考试",
        match: location.host.includes("zjy2.icve.com.cn"),
        intv: () => {
            return $(".subjectDet").length;
        },
        root: ".subjectDet",
        elements: {
            question: "h5,.titleT .htmlP",
            options: ".optionList .el-radio__label,.el-checkbox__label",
            $options: ".optionList input",
            type: ".titleTwo,.xvhao"
        },
        hook: () => {
            const parse = ques => {
                return ques.map(i => {
                    const options = [];
                    const answer = [];
                    if (i.typeId === "3") {
                        answer.push(i.optionAnswer === "1" ? "正确" : "错误");
                    } else if (/[12]/.test(i.typeId)) {
                        options.push(...JSON.parse(i.dataJson).map(i => {
                            if (i.IsAnswer) {
                                answer.push(formatString(i.Content));
                            }
                            return formatString(i.Content);
                        }));
                    }
                    return {
                        options: options,
                        qid: i.id,
                        answer: answer
                    };
                });
            };
            JSONParseHook(o => {
                if (o.name && o.questions && o.totalScore) {
                    GLOBAL.json = parse(o.questions);
                } else if (o.data && o.data.questions) {
                    GLOBAL.json = parse(o.data.questions);
                }
            });
        },
        ignore_click: $item => {
            return $($item).parent().attr("class") === "is-checked";
        },
        wrap: obj => {
            function findAnswer(id) {
                for (let jsonElement of GLOBAL.json) {
                    if (jsonElement.qid === id) {
                        return jsonElement.answer;
                    }
                }
            }
            obj.answer = findAnswer(obj.$item.attr("id"));
        }
    });
    function parseYkt(problems) {
        return problems.map(item => {
            const question = formatString(item.Body);
            const type = getQuestionType(item.TypeText);
            const options = [];
            const answer = [];
            if (type <= 1) {
                options.push(...item.Options.sort((a, b) => {
                    return a.key.charCodeAt(0) - b.key.charCodeAt(0);
                }).map(item => {
                    return formatString(item.value);
                }));
                if (item.Answer) {
                    if (Array.isArray(item.Answer)) {
                        answer.push(...item.Answer);
                    } else {
                        answer.push(...item.Answer.split(""));
                    }
                }
            } else if (type === 3 && item.Answer && item.Answer.length === 1) {
                answer.push(item.Answer[0].replace("true", "正确").replace("false", "错误"));
            }
            return {
                answer: answer,
                options: options,
                type: type,
                qid: item.problem_id,
                question: question
            };
        });
    }
    function parsehnzkwText(problems) {
        return problems.map(item => {
            const type = item.flag === 1 ? 2 : item.flag === 0 ? 0 : item.flag === 4 ? 1 : item.flag === 3 ? 3 : undefined;
            let answer = [];
            let options = [];
            if (type === 2) {
                answer.push(item.answer);
                return {
                    question: formatString(item.content),
                    options: options,
                    type: type,
                    answer: answer
                };
            } else if (type === 0) {
                for (let subjectOption of item.optionss) {
                    const opt = formatString(subjectOption);
                    options.push(opt);
                }
                if (type === 1) {
                    item.answer.split("|").map(i => {
                        answer.push(options[i.toUpperCase().charCodeAt(0) - 65]);
                    });
                } else {
                    answer.push(options[item.answer.toUpperCase().charCodeAt(0) - 65]);
                }
                return {
                    question: formatString(item.content),
                    options: options,
                    type: type,
                    answer: answer
                };
            } else if (type === 3) {
                for (let subjectOption of item.selectOption) {
                    const opt = formatString(subjectOption);
                    options.push(opt);
                }
                answer.push(item.answer);
                return {
                    question: formatString(item.content),
                    options: options,
                    type: type,
                    answer: answer
                };
            }
        });
    }
    function parseDanWei(pro) {
        return pro.map(i => {
            const type = getQuestionType(i.ttop010);
            const question = i.ttop011;
            const options = [];
            const answer = [];
            if (type === 0 || type === 1 || type === 3) {
                options.push(...i.ttop018.length > 0 ? i.ttop018.split("$$") : [ "正确", "错误" ]);
                answer.push(...i.ttop022.split("").map(item => {
                    return options[item.charCodeAt(0) - 65];
                }));
            } else if (type === 2 || type === 4) {
                answer.push(...i.ttop021.split("$$"));
            }
            return {
                question: question,
                type: type,
                answer: answer,
                options: options
            };
        }).filter(i => i);
    }
    function parseYxbyunExam(problems) {
        return problems.map(item => {
            const type = getQuestionType(item.bigName);
            return item.smallContent.map(item => {
                let answer = [];
                let options = [];
                if (type === 2) {
                    answer.push(item.answer);
                    return {
                        question: formatString(item.content),
                        options: options,
                        type: type,
                        answer: answer
                    };
                } else if (type === 0 || type === 3 || type === 1) {
                    let answer = [];
                    let options = [];
                    for (let subjectOption of item.question.optionList) {
                        const opt = formatString(subjectOption.questionContent);
                        options.push(opt);
                    }
                    if (type === 1) {
                        item.question.questionAnswer.split(",").map(i => {
                            answer.push(options[i.toUpperCase().charCodeAt(0) - 65]);
                        });
                    } else {
                        answer.push(options[item.question.questionAnswer.toUpperCase().charCodeAt(0) - 65]);
                    }
                    return {
                        question: formatString(item.question.questionTitle),
                        options: options,
                        type: type,
                        answer: answer
                    };
                }
            });
        });
    }
    WorkerJSPlus({
        name: "雨课堂旧版考试",
        match: location.pathname.includes("/v/quiz/quiz_result"),
        intv: () => {
            return $("#cover").attr("style").includes("display: none;");
        },
        root: ".problem_item",
        elements: {
            question: ".notBullet:eq(0)",
            options: ".notBullet:gt(0)",
            $options: ".problembullet"
        },
        ignore_click: $item => {
            return $item.hasClass("is-checked");
        },
        wrap: async obj => {
            const $item = obj.$item;
            const tmp = $item.find(".ptype").clone();
            tmp.children().remove();
            obj.type = getQuestionType(tmp.text());
            obj.question = await yuketangOcr(obj.question.attr("data-background"));
            if (obj.$options.length === 2) {
                obj.options = [ "正确", "错误" ];
            } else {
                const opt = [];
                for (const tmpElement of $item.find(".notBullet:gt(0)")) {
                    opt.push(await yuketangOcr(jQuery(tmpElement).attr("data-background")));
                }
                obj.options = opt;
            }
        }
    });
    WorkerJSPlus({
        name: "学堂在线",
        match: location.host === "www.xuetangx.com" && location.pathname.includes("/exercise/"),
        intv: () => {
            return $(".answer").length;
        },
        root: ".content:eq(0)",
        elements: {
            question: ".question .fuwenben",
            options: ".question .leftQuestion .leftradio > span:last-child",
            $options: ".question .leftradio",
            type: ".question .title"
        },
        ignore_click: $item => {
            return $item.find(".radio_jqq").hasClass("active");
        },
        wrap: obj => {
            if (obj.type === 3) {
                obj.$options = $(".answerList .radio_jqq");
            }
        },
        fill: (type, answer, $option) => {
            if (type === 4 || type === 2) {
                UE.getEditor($option.find("textarea")).setContent(answer);
            }
        },
        finished: () => {
            const $right = $(".tabbar").find(".right");
            $right.click();
            return !$right.hasClass("unselect");
        }
    });
    WorkerJSPlus({
        name: "雨课堂新版考试",
        match: location.host.includes("yuketang.cn") && location.pathname.includes("/result/"),
        hook: () => {
            JSONParseHook(async o => {
                if (o.data && o.data.problems && o.data.problems.length > 0) {
                    uploadAnswerToPlat(parseYkt(o.data.problems), 50);
                }
            });
        }
    });
    WorkerJSPlus({
        name: "雨课堂新版考试",
        match: (location.host === "examination.xuetangx.com" || location.host === "changjiang-exam.yuketang.cn") && (location.pathname.includes("/exam/") || location.pathname.includes("/cover/")),
        hook: () => {
            JSONParseHook(async o => {
                if (o.data && o.data.problems && o.data.problems.length > 0) {
                    GLOBAL.json = parseYkt(o.data.problems);
                }
            });
            const intv = setInterval(() => {
                try {
                    top.document.querySelector(".exam").__vue__.handleHangUpTip = function() {};
                    const querySelector = top.document.querySelector;
                    top.document.querySelector = function(...args) {
                        // 把页面自己的查找挡在面板外面。以前挡的是 #model-id 和
                        // hcSearcheModal（那两层容器），现在整个面板就是 #panelNode 一个元素
                        if (args[0] === "#panelNode") return false;
                        return querySelector.call(this, ...args);
                    };
                    const getElementById = top.document.getElementById;
                    top.document.getElementById = function(...args) {
                        if (args[0] === "panelNode") return false;
                        return getElementById.call(this, ...args);
                    };
                    clearInterval(intv);
                } catch (e) {}
            }, 100);
        },
        intv: () => {
            return jQuery(".subject-item").length;
        },
        root: ".exam-main--body .subject-item",
        elements: {
            question: ".item-body h4,.item-body span:eq(0)",
            options: ".item-body ul li",
            $options: ".item-body ul label, .blank-item-dynamic, .edui-editor-iframeholder",
            type: ".item-type"
        },
        ignore_click: $item => {
            return $item.hasClass("is-checked");
        },
        wrap: obj => {
            obj.options = obj.type === 3 ? [ "正确", "错误" ] : obj.options.map(i => {
                return i.replace(/^[A-G]\s/, "");
            });
            try {
                obj.qid = GLOBAL.json[GLOBAL.index - 1].qid;
                obj.plat = 50;
            } catch (e) {
                console.log(e);
            }
        }
    });
    function yktHomeworkKey(url) {
        try {
            const u = new URL(url, location.href);
            if (u.origin !== new URL(location.href).origin) return "";
            const m = u.pathname.match(/^\/(?:ai-workspace\/lms-graph|v2\/web\/(?:iframe-exercise|cloud\/student\/exercise))\/([^/]+)\/(?:exercise\/)?([^/]+)\/?$/);
            return m ? m[1] + ":" + m[2] : "";
        } catch (e) { return ""; }
    }
    function yktAcceptTransition() {
        const state = yktContext();
        if (state && state.transition && state.transition.toPath === location.pathname) {
            delete state.transition; yktContext(state);
        }
    }
    function yktHomeworkOuter() {
        return yktHost() && /^\/ai-workspace\/lms-graph\/[^/]+\/exercise\/[^/]+\/?$/.test(location.pathname);
    }
    function yktHomeworkParent() {
        try {
            return window.top !== window.self && yktHomeworkKey(window.top.location.href)
                && yktHomeworkKey(window.top.location.href) === yktHomeworkKey(location.href) ? window.top : null;
        } catch (e) { return null; }
    }
    function yktHomeworkRelay(type, message) {
        const parent = yktHomeworkParent(), run = GLOBAL.yktHomeworkRun;
        if (!parent || !run || !run.active()) return false;
        parent.postMessage({ ai6YktHomework: 1, type: type, message: message,
            key: run.key, token: run.token }, location.origin);
        return true;
    }
    function yktHomeworkTarget() {
        const target = yktHomeworkBridge.target;
        if (!target || !yktHomeworkOuter() || target.key !== yktHomeworkKey(location.href)) return null;
        try {
            const frame = Array.from(document.querySelectorAll("iframe")).find(f => f.contentWindow === target.win);
            return frame && frame.isConnected && yktHomeworkKey(target.win.location.href) === target.key ? target : null;
        } catch (e) { return null; }
    }
    function yktHomeworkPost(message) {
        const target = yktHomeworkTarget();
        if (!target) return false;
        if (!["ai_request", "ai_fill", "stop", "save_setting", "jump", "auto_jump"].includes(message.type)) return false;
        target.win.postMessage(Object.assign({}, message, { yktHomeworkRun: target.token }), location.origin);
        return message.type === "ai_request" || message.type === "ai_fill" || message.type === "jump";
    }
    function yktHomeworkBridge() {
        if (yktHomeworkBridge.started) return;
        yktHomeworkBridge.started = true;
        window.addEventListener("message", event => {
            const m = event.data;
            if (!m || m.ai6YktHomework !== 1 || event.origin !== location.origin || !yktHomeworkOuter()
                || m.key !== yktHomeworkKey(location.href)) return;
            const frame = Array.from(document.querySelectorAll("iframe")).find(f => f.contentWindow === event.source);
            try { if (!frame || yktHomeworkKey(frame.contentWindow.location.href) !== m.key) return; } catch (e) { return; }
            if (m.type === "ready") {
                const old = yktHomeworkBridge.target;
                if (old && old.win === event.source && old.token === m.token) return;
                yktHomeworkBridge.target = { win: event.source, key: m.key, token: m.token };
                yktAcceptTransition();
                showPanel("雨课堂作业"); yktKeepPanel();
                iframeMsg("homework_scope", m.token);
                iframeMsg("clear");
                event.source.postMessage({ type: "stop", val: GLOBAL.stop, yktHomeworkRun: m.token }, event.origin);
                logMsg("雨课堂作业:已接入当前作业,答题记录和设置使用当前面板");
                return;
            }
            const target = yktHomeworkTarget();
            if (!target || target.win !== event.source || target.token !== m.token) return;
            if (m.type === "homework_complete") {
                if (target.finished) return;
                const proof = m.message;
                if (!proof || !Number.isInteger(proof.total) || proof.total <= 0 || proof.submitted !== proof.total) return;
                target.finished = true;
                const path = location.pathname, id = m.key.split(":")[1];
                if (cxSet("ykt_do") && GM_getValue("auto_jump") !== false && !GLOBAL.stop) {
                    yktContinueSpace(id, yktContext(), (s, lv) => logMsg("雨课堂任务: " + s, lv), () => yktActive(path),
                        { id: id, total: proof.total, submitted: proof.submitted })
                        .catch(e => logMsg("雨课堂任务衔接失败:" + e.message, "error"));
                }
            } else if (["push", "update_answer", "clear", "progress", "tip", "stop", "ai_fill_question", "ai_response", "settings_updated"].includes(m.type)) {
                if (m.type === "stop") GLOBAL.stop = !!m.message;
                iframeMsg(m.type, m.message);
            }
        });
    }
    function yktHomeworkBoot(options) {
        if (!yktHost() || yktHomeworkBoot.started) return;
        yktHomeworkBoot.started = true;
        let running = null, candidate = "", stable = 0, serial = 0, stale = null, receiptKey = "", receipts = {};
        const tick = () => {
            const key = yktHomeworkPage() ? yktHomeworkKey(location.href) : "";
            if (running && GLOBAL.stop) running.resume = true;
            if (running && running.settled && !GLOBAL.stop && (running.resume
                || running.questionKey && running.questionKey !== yktHomeworkCurrent().key)) running.cancelled = true;
            if (running && !running.active()) {
                running.cancelled = true;
                if (!running.settled) return;
                if (key !== running.key) stale = { root: running.root, problem: running.problem };
                running = null; GLOBAL.yktHomeworkRun = null;
                GLOBAL.pendingAiFillQueue = []; GLOBAL.currentPendingItem = null;
                clearAiAnswerState();
            }
            if (!key || GLOBAL.stop) { candidate = ""; stable = 0; return; }
            if (running) return;
            // 父路由先切换、旧 iframe 后销毁时,旧题目不得重新开工。
            try {
                if (window.top !== window.self && /\/ai-workspace\/lms-graph\//.test(window.top.location.pathname)
                    && !yktHomeworkParent()) return;
            } catch (e) {}
            const current = yktHomeworkCurrent();
            if (!current.root || !yktHomeworkVisible(current.root) || !current.key || !current.problem) return;
            if (stale && current.root === stale.root && current.problem === stale.problem) return;
            stale = null;
            const next = key + ":" + current.key;
            if (candidate !== next) { candidate = next; stable = 0; }
            if (++stable < 2) return;
            const path = location.pathname, parent = yktHomeworkParent();
            if (receiptKey !== key) { receiptKey = key; receipts = {}; }
            const run = { key: key, token: Date.now() + ":" + (++serial), cancelled: false, settled: false, receipts: receipts };
            run.active = () => !run.cancelled && location.pathname === path
                && (!parent || yktHomeworkParent() === parent);
            running = run; GLOBAL.yktHomeworkRun = run;
            GLOBAL.json = []; GLOBAL.pendingAiFillQueue = []; GLOBAL.currentPendingItem = null;
            clearAiAnswerState();
            if (!yktHomeworkRelay("ready", {})) { showPanel(options.name); iframeMsg("clear"); }
            const select = { root: options.root, elements: options.elements, ignore_click: options.ignore_click, active: run.active };
            logMsg("雨课堂作业:开始识别当前作业 " + key.split(":")[1]);
            new WorkerJS(select, options.wrap, options.fill, options.finished, options.fillFinish).fillAnswer()
                .catch(e => { if (run.active()) yktHomeworkPause("答题启动失败:" + e.message); })
                .finally(() => { run.settled = true; });
        };
        setInterval(tick, 500);
    }
    // 有的课程把 A/B/C/D 全写在 Body,Options 只存按键。只接受完整连续字母,
    // 且数量必须与真实选项一致;不能从公式变量或残缺选项猜测内容。
    function yktHomeworkSplitOptions(question, count) {
        if (count < 2 || count > 7) return null;
        // 屏蔽公式和 HTML 属性,保留索引;选项之间不一定有空格。
        const masked = question.replace(/<[^>]*>|\\\([\s\S]*?\\\)|\\\[[\s\S]*?\\\]|\$\$[\s\S]*?\$\$|\$[^$\n]+\$/g,
            s => " ".repeat(s.length));
        const matches = Array.from(masked.matchAll(/(?<![A-Za-z\\])(?:([A-G])[.．、)）]|[(（]([A-G])[)）])/g));
        for (let i = 0; i <= matches.length - count; i++) {
            const group = matches.slice(i, i + count);
            if (!group.every((m, n) => (m[1] || m[2]) === String.fromCharCode(65 + n)) || i + count !== matches.length) continue;
            const options = group.map((m, n) => question.slice(m.index + m[0].length,
                n + 1 < count ? group[n + 1].index : question.length).trim());
            if (options.every(Boolean)) return { question: question.slice(0, group[0].index).trim(), options: options };
        }
        return null;
    }
    async function yktHomeworkRead(obj) {
        const current = yktHomeworkCurrent();
        if (!current.problem) return true;
        const path = location.pathname, key = current.key, run = GLOBAL.yktHomeworkRun;
        if (run) { run.questionKey = key; run.root = current.root; run.problem = current.problem; }
        obj.active = () => (!run || run.active()) && !GLOBAL.stop && location.pathname === path
            && current.root.isConnected && yktHomeworkCurrent().key === key;
        const parent = yktVue(current.root, vm => !!(vm.exerciseList && Array.isArray(vm.exerciseList.problems)));
        const font = parent && parent.exerciseList.font;
        // textContent 会将相邻段落粘连;解码前保留换行/块元素边界。
        const decode = html => getEncryptString(String(html || "").replace(/<br\b[^>]*>|<\/(?:p|div|li|td|tr|h[1-6])\s*>/gi, "$& "), font);
        const missing = value => !value.trim() || /^(?:[A-G][.、．)）]?|[(（][A-G][)）])$/i.test(value.trim());
        let label = "当前题";
        for (let attempt = 0; attempt <= 20; attempt++) {
            if (!obj.active()) return true;
            const p = yktHomeworkCurrent().problem, content = p.content;
            label = (p.index != null ? "第 " + p.index + " 题" : "当前题") + "（题目 ID " + key + "）";
            obj.qid = p.problem_id; obj.plat = 50;
            // 已判分或次数耗尽的题直接核对提交并翻题,不再搜题或改选项。
            if (p.left_times != null && Number(p.left_times) === 0
                || yktHomeworkSaved(p)) {
                obj.yktSubmitted = true;
                return;
            }
            obj.typeLabel = content.TypeText || content.TypeRenameText || content.Type || "";
            const nativeType = ({ 1: 0, 2: 1, 4: 2, 5: 4, 6: 3 })[Number(content.ProblemType)];
            obj.type = nativeType !== undefined ? nativeType : content.ProblemType != null ? 8 : getQuestionType(content.Type) ?? getQuestionType(obj.typeLabel);
            obj.question = await decode(content.Body);
            const entries = Array.isArray(content.Options) ? Array.from(content.Options) : [];
            obj.options = await Promise.all(entries.map(o => decode(o.value)));
            if (obj.type === 3) obj.options = entries.map((o, i) => obj.options[i] || ({ true: "正确", false: "错误" })[String(o.key)] || "");
            if (!obj.active()) return true;
            if (obj.type === 0 || obj.type === 1) {
                const dom = Array.from(current.root.querySelectorAll(".radioText,.checkboxText"));
                for (let i = 0; i < obj.options.length; i++) {
                    if (missing(obj.options[i]) && dom.length === obj.options.length)
                        obj.options[i] = await decode(dom[i].innerHTML);
                }
                if (obj.options.some(missing)) {
                    const split = yktHomeworkSplitOptions(obj.question, obj.options.length);
                    if (split) { obj.question = split.question; obj.options = split.options; }
                }
            }
            if (!obj.active()) return true;
            if (obj.question.trim() && Number.isFinite(obj.type)
                && (!(obj.type === 0 || obj.type === 1) || obj.options.length >= 2 && !obj.options.some(missing))) {
                // 等待中 Vue 可能替换了输入框,须刷新实际点击目标。
                obj.$options = jQuery(current.root).find("ul input,input.blank-item-dynamic,textarea");
                return;
            }
            if (attempt === 0) iframeMsg("tip", { tip: "雨课堂作业:" + label + "正在等待题干和选项加载" });
            if (attempt < 20) await sleep(200);
        }
        if (obj.active()) yktHomeworkPause(label + "选项内容尚未识别完整,等待 4 秒后仍不完整;已保留当前题,请检查题目后继续");
        return true;
    }
    function yktHomeworkAnswerSnapshot(p) {
        try {
            return JSON.stringify([p._answer, (p._answers || []).filter(a => a.num).map(a => [a.num, a.answer])]);
        } catch (e) { return ""; }
    }
    function yktHomeworkSaved(p) {
        if (!p || !p.user || !(Number(p.user.my_count) > 0 || p.user.submit_time)) return false;
        const run = GLOBAL.yktHomeworkRun, receipt = run && run.receipts && run.receipts[String(p.problem_id)];
        if (receipt && receipt.count === p.user.my_count && receipt.time === p.user.submit_time) {
            // 网站提交后自动翻题,旧题不再 formatData;用已确认回执对应的答案快照核对。
            const answer = yktHomeworkAnswerSnapshot(p);
            if (answer && answer === receipt.answer) return true;
        }
        const type = Number(p.content && p.content.ProblemType), mine = p.user.my_answer;
        if ((type === 1 || type === 6) && mine != null && p._answer != null) {
            // answer 是正确答案,my_answer 才是本人的提交答案,答错也有有效回执。
            return String(p._answer) === String(Array.isArray(mine) ? mine[0] : mine);
        }
        // 原生 refreshSubmitStatus 的标记是“可提交”,不是“未保存”。
        // formatData 会置 _changeStatus=false;只有后续改动才置 true。
        return p._changeStatus !== true && !(p._submitStatus && p._changeStatus !== false);
    }
    async function yktHomeworkComplete() {
        const path = location.pathname, run = GLOBAL.yktHomeworkRun;
        let missing = [], total = 0;
        // 提交响应先到、列表状态稍后更新时,给网站一次有限的同步时间。
        for (let i = 0; i <= 20; i++) {
            if (GLOBAL.stop || location.pathname !== path || run && !run.active()) return false;
            const current = yktHomeworkCurrent();
            const owner = current.root && yktVue(current.root, v => !!(v.exerciseList && Array.isArray(v.exerciseList.problems)));
            const problems = owner && owner.exerciseList.problems || [];
            total = problems.length;
            missing = problems.map((p, index) => yktHomeworkSaved(p) ? null : index + 1).filter(Boolean);
            if (total && !missing.length) {
                logMsg("雨课堂作业:全部 " + total + " 题已确认提交,准备进入下一任务");
                yktHomeworkRelay("homework_complete", { total: total, submitted: total });
                return false;
            }
            if (i < 20) await sleep(200);
        }
        return yktHomeworkPause(total ? "已到末题,第 " + missing.join("、") + " 题尚未确认提交或有新修改;请点击左侧题号检查后继续"
            : "未能读取整份作业的提交记录,请等待页面加载后继续");
    }
    function yktHomeworkPage() {
        return yktHost() && /^\/v2\/web\/(?:cloud\/student\/exercise|iframe-exercise)\/[^/]+/.test(location.pathname);
    }
    function yktHomeworkCurrent() {
        const root = Array.from(document.querySelectorAll(".container-problem .subject-item")).find(yktHomeworkVisible);
        const vm = root && yktVue(root, v => !!(v.problem && v.problem.content));
        return { root: root, vm: vm, problem: vm && vm.problem,
            key: vm && vm.problem ? String(vm.problem.problem_id || vm.problem.index || "")
                : ((root && root.querySelector(".item-type")) || {}).textContent || "" };
    }
    function yktHomeworkVisible(el) {
        if (!el || !el.isConnected || !el.getClientRects().length) return false;
        for (let n = el; n; n = n.parentElement) {
            const style = getComputedStyle(n);
            if (n.hidden || style.display === "none" || style.visibility === "hidden") return false;
        }
        return true;
    }
    // 雨课堂答不出当前题时的去留:默认(ai_fail_skip 开)点"下一题"跳过(不提交当前,留空),关掉才停下等人工。
    // 跟超星那套 continue 一样是"这题空着往下做",只是雨课堂一次一题、得靠点下一题来翻,所以单独一个。
    async function yktSkipOrPause(message) {
        if (!aiFailSkip()) return yktHomeworkPause(message);
        logMsg("雨课堂作业:" + message + "，已跳过本题", "warn");
        iframeMsg("tip", { tip: "雨课堂作业:" + message + "，跳过继续下一题" });
        return await yktHomeworkNext(true, true);
    }
    function yktHomeworkPause(message) {
        GLOBAL.stop = true;
        iframeMsg("stop", true);
        iframeMsg("tip", { tip: "雨课堂作业:" + message });
        logMsg("雨课堂作业:" + message, "warn");
        return false;
    }
    function yktHomeworkSubmitPolicy() {
        const mode = String(GM_getValue("submit_mode") || "off");
        const enabled = mode === "auto";
        const raw = parseInt(GM_getValue("submit_threshold")), threshold = isNaN(raw) ? 80 : Math.max(0, Math.min(100, raw));
        const total = Number(GLOBAL.answeredTotal) || 0;
        const count = Math.max(0, Math.min(Number(GLOBAL.successCount) || 0, total));
        const accuracy = total > 0 ? count / total * 100 : 0;
        return { enabled: enabled, mode: mode, allowed: enabled && total > 0 && accuracy >= threshold, accuracy: accuracy, threshold: threshold };
    }
    function yktHomeworkDialog() {
        const dialogs = Array.from(document.querySelectorAll(".el-dialog,.el-message-box"));
        for (const root of dialogs.filter(yktHomeworkVisible)) {
            const text = (root.textContent || "").replace(/\s+/g, "");
            if (root.matches(".homework-problem-blank-submit-dialog") || /有填空未填写|Theblankhasnotfinished/i.test(text)) return { root: root, type: "blank" };
            if (/部分习题提交失败/.test(text)) return { root: root, type: "error" };
            if (root.matches(".homework-problem-change-guard-dialog") || /刚刚答完的习题还没有提交|Notsubmittheproblemjustanswered/i.test(text)) return { root: root, type: "change" };
            if (root.matches(".homework-problem-batch-submit-dialog") || /道已作答习题未提交|problemshavenotbeensubmitted/i.test(text)) return { root: root, type: "batch" };
        }
        return null;
    }
    function yktHomeworkButton(root, pattern) {
        return Array.from(root.querySelectorAll("button,[role=button],.rain-btn"))
            .find(b => yktHomeworkVisible(b) && pattern.test((b.textContent || "").trim()));
    }
    async function yktHomeworkSubmit(before, path) {
        const policy = yktHomeworkSubmitPolicy();
        if (!policy.enabled) return yktHomeworkPause(policy.mode === "save"
            ? "提交方式为「仅保存答案不提交」,已保留当前答案,请手动提交后继续"
            : "提交方式不是「自动提交」,已保留当前答案,请手动提交后继续");
        if (!policy.allowed) return yktHomeworkPause("答题匹配率 " + policy.accuracy.toFixed(1) + "% 未达到提交阈值 " + policy.threshold + "%,请先检查答案");
        if (!before.problem || !before.key) return yktHomeworkPause("无法核对当前题目,未自动提交");
        const owner = yktVue(before.root, v => !!(v.exerciseList && Array.isArray(v.exerciseList.problems)));
        const user = before.problem.user || {}, count = Number(user.my_count) || 0, stamp = user.submit_time;
        const oldMessages = new Set(document.querySelectorAll(".el-message,.toastMessage"));
        const actions = new Set();
        let started = false;
        const confirmed = () => {
            const list = owner && owner.exerciseList && owner.exerciseList.problems;
            const p = list && list.find(p => String(p.problem_id) === before.key);
            const current = yktHomeworkCurrent();
            return [p, before.problem, current.key === before.key && current.problem].find(p => p && p.user && (Number(p.user.my_count) > count
                || p.user.submit_time && p.user.submit_time !== stamp));
        };
        for (let i = 0; i < 100; i++) {
            if (GLOBAL.stop || location.pathname !== path) return false;
            if (!yktHomeworkSubmitPolicy().allowed) return yktHomeworkPause("提交设置已改变,已停止后续确认操作");
            const saved = confirmed();
            if (saved) {
                const run = GLOBAL.yktHomeworkRun, answer = yktHomeworkAnswerSnapshot(saved);
                if (run && answer) {
                    if (!run.receipts) run.receipts = {};
                    run.receipts[before.key] = { count: saved.user.my_count, time: saved.user.submit_time, answer: answer };
                }
                logMsg("雨课堂作业:网站已确认本题提交");
                return true;
            }
            if (yktHomeworkCurrent().key !== before.key) return yktHomeworkPause("题目已切换但上一题提交结果未确认,请先核对");
            const challenge = document.querySelector("#homework-automation-risk-challenge,.yidun_modal");
            if (challenge && yktHomeworkVisible(challenge)) return yktHomeworkPause("网站要求验证,请完成验证后继续");
            const error = Array.from(document.querySelectorAll(".el-message,.toastMessage"))
                .find(el => !oldMessages.has(el) && yktHomeworkVisible(el)
                    && (el.classList.contains("el-message--error") || /失败|错误|网络异常|error|failed/i.test(el.textContent || "")));
            if (error) return yktHomeworkPause("提交未成功:" + error.textContent.trim());
            const dialog = yktHomeworkDialog();
            if (!dialog && Array.from(document.querySelectorAll(".el-dialog,.el-message-box")).some(yktHomeworkVisible)) {
                return yktHomeworkPause("页面有其它弹窗,请先处理后继续提交");
            }
            if (dialog) {
                if (dialog.type === "blank") return yktHomeworkPause("网站提示还有填空未填写,请补全后再提交");
                if (dialog.type === "error") return yktHomeworkPause("网站提示部分习题提交失败,请检查后重试");
                if (!actions.has(dialog.type)) {
                    // 批量弹窗只提交当前已经过本轮阈值判断的题,不交其它残留草稿。
                    const button = dialog.type === "change"
                        ? dialog.root.querySelector(".homework-problem-change-guard__primary-action") || yktHomeworkButton(dialog.root, /^(帮我提交|Yes)$/i)
                        : yktHomeworkButton(dialog.root, /^(仅提交本题|Only this question)$/i);
                    if (button && yktHomeworkVisible(button) && !button.disabled && !button.classList.contains("is-disabled")
                        && !button.classList.contains("is-loading") && button.getAttribute("aria-disabled") !== "true") {
                        actions.add(dialog.type); started = true;
                        button.click();
                        logMsg(dialog.type === "change" ? "雨课堂作业:已确认「帮我提交」,等待网站保存" : "雨课堂作业:已选择「仅提交本题」,等待网站保存");
                    }
                }
            } else if (!started) {
                const container = before.root.closest(".container-problem");
                const button = container && yktHomeworkButton(container, /^(提交(?:$|[\s（(，])|Submit(?:$|[\s(]))/i);
                if (button && !button.disabled && !button.classList.contains("is-disabled") && !button.classList.contains("is-loading")
                    && button.getAttribute("aria-disabled") !== "true") {
                    started = true; button.click();
                    logMsg("雨课堂作业:已提交当前题,等待确认结果");
                }
            }
            await sleep(200);
        }
        return yktHomeworkPause(started ? "提交结果等待超时,已保留现场,不会反复点击提交" : "提交按钮或确认按钮不可用,已保留当前答案");
    }
    async function yktHomeworkNext(needJump, skipUnanswerable) {
        if (GLOBAL.stop || !needJump && !yktHomeworkSubmitPolicy().enabled) return false;
        const path = location.pathname, before = yktHomeworkCurrent();
        const pending = before.problem && !yktHomeworkSaved(before.problem)
            && (before.problem._submitStatus || before.vm && before.vm.submitStatus);
        if (!skipUnanswerable && (pending || yktHomeworkDialog())) {
            if (!await yktHomeworkSubmit(before, path)) return false;
            if (GLOBAL.stop || location.pathname !== path || !needJump) return false;
            // 网站提交正确答案时可能自己翻题,此时不再点击下一题,以免跳过一题。
            const current = yktHomeworkCurrent();
            if (current.root && current.key && current.key !== before.key) return true;
        }
        if (!needJump) return false;
        let next = Array.from(document.querySelectorAll(".container-problem .el-button--text"))
            .find(b => /^(下一题|Next(?: question)?)$/i.test((b.textContent || "").trim()) && b.getClientRects().length);
        if (!next || next.disabled || next.classList.contains("is-disabled")) return yktHomeworkComplete();
        await sleep(GLOBAL.fillAnswerDelay);
        if (GLOBAL.stop || location.pathname !== path || !next.isConnected) return false;
        next.click();
        let recovered = false;
        for (let i = 0; i < 50 && !GLOBAL.stop && location.pathname === path; i++) {
            await sleep(200);
            const current = yktHomeworkCurrent();
            if (current.root && current.key && current.key !== before.key) return true;
            // 页面稍后才更新待提交状态时,下一题会先弹截图中的确认框。
            if (!recovered && yktHomeworkDialog()) {
                recovered = true;
                if (skipUnanswerable) {
                    const dialog = yktHomeworkDialog();
                    const discard = dialog && dialog.type === "change"
                        && yktHomeworkButton(dialog.root, /^(先不用了|暂不提交|不提交|Don.t submit|Not now|No)$/i);
                    if (!discard || discard.disabled || discard.classList.contains("is-disabled")
                        || discard.getAttribute("aria-disabled") === "true") {
                        return yktHomeworkPause("当前题未提交，网站没有可确认的「不提交并继续」选项；脚本未自动提交");
                    }
                    discard.click();
                    logMsg("雨课堂作业:已选择「先不用了」,继续跳过未作答题", "warn");
                    continue;
                }
                if (!await yktHomeworkSubmit(before, path)) return false;
                if (GLOBAL.stop || location.pathname !== path) return false;
                const after = yktHomeworkCurrent();
                if (after.root && after.key && after.key !== before.key) return true;
                next = Array.from(document.querySelectorAll(".container-problem .el-button--text"))
                    .find(b => /^(下一题|Next(?: question)?)$/i.test((b.textContent || "").trim()) && yktHomeworkVisible(b));
                if (!next || next.disabled || next.classList.contains("is-disabled")) return false;
                next.click();
            }
        }
        // 不能像旧版那样先返回 true,300ms 后重答仍未翻走的旧题。
        if (GLOBAL.stop || location.pathname !== path) return false;
        return yktHomeworkPause("下一题未加载,已暂停;请检查页面提示后继续");
    }
    WorkerJSPlus({
        name: "雨课堂作业",
        match: yktHomeworkPage,
        intv: () => {
            return jQuery(".container-problem .subject-item:visible").length;
        },
        root: ".container-problem .subject-item:visible",
        elements: {
            question: ".problem-body",
            options: "label .radioText,.checkboxText",
            $options: "ul input,input.blank-item-dynamic,textarea"
        },
        ignore_click: $item => {
            return $item.prop("checked");
        },
        wrap: yktHomeworkRead,
        finished: yktHomeworkNext
    });
    WorkerJSPlus({
        name: "云班课",
        match: location.pathname === "/web/index.php" && location.href.includes("m=reply"),
        root: ".topic-item",
        elements: {
            question: ".t-con .t-subject",
            options: ".t-option  label .option-content",
            $options: ".el-radio__input,.el-checkbox__input",
            type: ".t-info .t-type"
        },
        ignore_click: $item => {
            return $item.hasClass("is-checked");
        },
        wrap: obj => {
            if (obj.type === "A1A2题") {
                obj.type = 1;
            }
            obj.question = obj.question.replace(/<img src="https:\/\/cdn-zjy.icve.com.cn\/common\/images\/question_button\/blankspace(\d+).gif">/gi, "");
            obj.options = obj.options.map(i => {
                return i.trim().replace(/^[abAB]\)\s+/, "").replace(/^[A-Za-z]\s+/, "").trim();
            });
        }
    });
    WorkerJSPlus({
        name: "中国地质大学",
        match: location.pathname.includes("/Exam/OnlineExamV2/"),
        root: ".stViewItem",
        elements: {
            question: ".stViewHead  div",
            options: ".stViewCont  .stViewOption a",
            $options: ".stViewCont  .stViewOption a,input"
        },
        intv: () => {
            return $(".ExamTime").length;
        },
        wrap: obj => {
            obj.type = getQuestionType(obj.$item.parent().parent().prev().find(".E_E_L_I_C_R_C_T_SubType").text());
            obj.question = obj.question.replace(/\(\d+分\)/, "");
            obj.options = obj.options.map(i => {
                return i.replace(/\([A-Za-z]\)/, "").trim();
            });
        },
        fill: (type, answer, $option) => {
            if (type === 4 || type === 2) {
                $option.val(answer);
            }
        }
    });
    WorkerJSPlus({
        name: "单位",
        match: (location.host === "61.183.163.9:8089" || location.host === "zjpt.nnjjtgs.com:8081") && (location.href.includes("ksnr") || location.href.includes("lxnr")),
        hook: () => {
            JSONParseHook(o => {
                if (o.topicList && o.topicList.length > 0) {
                    GLOBAL.json = parseDanWei(o.topicList);
                    GLOBAL.json.forEach(item => uploadQuestionBankCandidate(item, item.answer, "单位题库平台标准答案"));
                    uploadAnswer(GLOBAL.json);
                }
            });
        },
        root: ".tm",
        elements: {
            question: ".tmnrbj span:last-child",
            options: ".van-radio-group .dxt .van-radio__label,.van-checkbox__label",
            $options: ".van-radio-group .dxt .van-radio__label,.van-checkbox__label,.van-field__control",
            type: ".tmnrbj span"
        },
        intv: () => {
            return $(".ExamTime").length || document.getElementById("pup-b");
        },
        wrap: obj => {
            obj.answer = GLOBAL.json[jQuery(".tmnrbj span:last-child").text().match(/^(\d+)、/)[1] - 1].answer;
        },
        finished: () => {
            jQuery(".xyt").click();
            return true;
        }
    });
    WorkerJSPlus({
        name: "小鹅通",
        match: location.pathname.includes("/evaluation_wechat/examination/detail/"),
        root: ".question-title,.title__text",
        elements: {
            question: "#detail_div",
            options: "label  .image-text-box p",
            $options: "label,.simulation_inp"
        },
        ignore_click: ($item, type) => {
            if (type === 0) {
                return $item.html().includes("single-exam-radio-active");
            } else if (type === 1) {
                return $item.html().includes("check-i-active");
            }
        },
        wrap: obj => {
            const $item = obj.$item;
            obj.$options = $item.parent().next().find(".option-item,.checking-option__container,.fill_blank");
            obj.type = getQuestionType($item.next().text());
            if (obj.type === 2) {
                obj.$options = $item.parent().parent();
            }
            if (obj.type === 3) {
                obj.options = [ "正确", "错误" ];
            } else {
                obj.options = jQuery.map($item.parent().next().find(".option-item #detail_div"), function(val) {
                    return formatString(filterImg(val));
                });
            }
        },
        fill: (type, answer, $option) => {
            if (type === 2) {
                const vue = $option.get(0).__vue__;
                vue.content[0] = answer;
                vue.emitAnswer();
                $option.find(".simulation_inp").text(answer);
            }
        }
    });
    WorkerJSPlus({
        name: "小饿通H5",
        match: location.host.includes("h5.xiaoeknow") || location.href.includes("/exam/h5_evaluation/"),
        root: ".practice-detail__body",
        elements: {
            question: ".question-wrap__title #detail_div",
            options: ".question-option #detail_div",
            $options: ".question-option #detail_div",
            type: ".question-wrap__title-tag"
        },
        wrap: obj => {
            const $item = obj.$item;
            obj.$options = $item.parent().next().find(".option-item,.checking-option__container,.fill_blank");
            obj.type = TYPE[$item.next().text().replace(/\s+/, "").replace("（", "").replace("）", "")];
            if (obj.type === 2) {
                obj.$options = $item.parent().parent();
            }
            if (obj.type === 3) {
                obj.options = [ "正确", "错误" ];
            } else {
                obj.options = jQuery.map($item.parent().next().find(".option-item #detail_div"), function(val) {
                    return formatString(filterImg(val));
                });
            }
        },
        finished: () => {
            $(".practice-detail__bottom-item:last-child").click();
            return $(".next").text() === "下一题";
        }
    });
    WorkerJSPlus({
        name: "人卫慕课测验",
        match: location.pathname.includes("/memberFront/paper.zhtml"),
        intv: () => {
            return $("#question_").attr("style").length === 0;
        },
        root: ".quesinfo",
        elements: {
            question: "dl dt",
            options: "dd label",
            $options: "dd input"
        },
        wrap: obj => {
            if (obj.$options.length === 2) {
                obj.type = 3;
                obj.options = [ "正确", "错误" ];
            } else {
                obj.type = 0;
            }
        }
    });
    WorkerJSPlus({
        name: "青书学堂考试",
        match: location.host.includes("qingshuxuetang") && (location.pathname.includes("/Student/MakeupExamPaper") || location.pathname.includes("Student/ExamPaper")),
        intv: () => {
            return $(".paper-container .question-detail-container").length;
        },
        root: ".paper-container .question-detail-container",
        elements: {
            question: ".question-detail-description .detail-description-content",
            options: ".question-detail-options label .option-description",
            $options: ".question-detail-options label input",
            type: ".question-detail-type .question-detail-type-desc"
        },
        ignore_click: $item => {
            return $item.prop("checked");
        }
    });
    WorkerJSPlus({
        name: "青书学堂测验",
        match: location.host.includes("qingshuxuetang") && location.pathname.includes("/Student/ExercisePaper") || location.host === "quiz.qingshuxuetang.com" && location.pathname.includes("/Student/Quiz/Detail"),
        intv: () => {
            return $(".question-detail-container").length;
        },
        root: ".question-detail-container",
        elements: {
            question: ".question-detail-description  span",
            options: ".question-detail-options label .option-description",
            $options: ".question-detail-options div input,.question-detail-solution-textarea",
            type: ".question-detail-type"
        },
        wrap: obj => {
            obj.options = obj.options.map(i => {
                return i.replace(/\([A-Za-z]\)/, "").trim();
            });
        },
        ignore_click: ($item, type) => {
            if (type === 1) {
                return $item.prop("checked");
            }
        },
        fill: (type, answer, $option) => {
            if (type === 4 || type === 2) {
                $option.parents().find(".question-controller-wrapper .next").click();
            }
        }
    });
    WorkerJSPlus({
        name: "优学院测验",
        match: location.pathname === "/learnCourse/learnCourse.html",
        intv: () => {
            return $(".question-setting-panel").length;
        },
        root: ".split-screen-wrapper",
        elements: {
            question: ".question-title-scroller .question-title-html",
            options: ".choice-list .content-wrapper .text",
            $options: ".choice-list .checkbox ,.question-body-wrapper .choice-btn",
            type: ".question-title-scroller .question-type-tag"
        },
        wrap: obj => {
            obj.options = obj.options.map(i => {
                return formatString(i.replaceAll(/[a-zA-z]\)\s+/g, "").replaceAll(/^[a-z]\s+/g, "").replaceAll(/^[a-z]、\s+/g, "").trim());
            });
        },
        ignore_click: $item => {
            return $item.hasClass("selected");
        }
    });
    WorkerJSPlus({
        name: "优学院作业",
        match: location.pathname === "/quiz/pc.html",
        intv: () => {
            return $(".questions").length;
        },
        root: ".question-item",
        elements: {
            question: ".question-title",
            options: "ul label .choice-title",
            $options: "ul label input",
            type: ".title"
        },
        wrap: obj => {
            obj.options = obj.options.map(i => {
                return formatString(i.replaceAll(/[a-zA-z]\)\s+/g, "").replaceAll(/^[a-z]\s+/g, "").replaceAll(/^[a-z]、\s+/g, "").trim());
            });
        },
        ignore_click: $item => {
            return $item.prop("checked");
        }
    });
    WorkerJSPlus({
        name: "优学院考试",
        match: location.host === "utest.ulearning.cn" && location.pathname === "/",
        intv: () => {
            return $(".section-area").length;
        },
        root: ".question-area .question-item",
        elements: {
            question: ".base-question .title .rich-text",
            options: ".choice-list label .rich-text",
            $options: ".choice-list  label, .iconfont",
            type: ".base-question .title .tip"
        },
        wrap: obj => {
            obj.options = obj.options.map(i => {
                return formatString(i.replaceAll(/[a-zA-z]\)\s+/g, "").replaceAll(/^[a-z]\s+/g, "").replaceAll(/^[a-z]、\s+/g, "").trim());
            });
        },
        ignore_click: $item => {
            return $item.hasClass("is-checked");
        },
        finished: () => {
            if ($(".next-part:contains(下个部分)").length) {
                $(".next-part").click();
                return true;
            } else {
                return false;
            }
        }
    });
    WorkerJSPlus({
        name: "优学院作业",
        match: location.pathname === "/umooc/learner/homework.do",
        intv: () => {
            return $(".multiple-choices").length;
        },
        root: ".multiple-choices,.judge",
        elements: {
            question: "h5 .position-rltv span:last-child",
            options: "ul label span:last-child",
            $options: "ul label input,.radios .radio input",
            type: "h5 .typeName"
        },
        wrap: obj => {
            obj.options = obj.options.map(i => {
                return formatString(i.replaceAll(/[a-zA-z]\)\s+/g, "").replaceAll(/^[a-z]\s+/g, "").replaceAll(/^[a-z]、\s+/g, "").trim());
            });
        },
        ignore_click: $item => {
            return $item.prev().hasClass("checkbox-checked");
        }
    });
    WorkerJSPlus({
        name: "万学",
        match: location.pathname.includes("/sls/N2014_StudyController/next"),
        root: ".question",
        elements: {
            question: "tr .nm2",
            options: ".grey td p",
            $options: ".option li label",
            type: "tr .nm2"
        },
        wrap: obj => {
            obj.question = obj.question.parent().find("td p").text();
        }
    });
    WorkerJSPlus({
        name: "wenJuanAutoFill",
        match: location.host.includes("wenjuan.com") && location.pathname === "/s/",
        root: "questionContent",
        elements: {
            question: ".title",
            options: ".icheckbox_div .option_label",
            $options: ".icheckbox_div label",
            type: ".question_num"
        },
        ignore_click: $item => {
            return $item.attr("class").includes("checked");
        }
    });
    WorkerJSPlus({
        name: "学起（考试）",
        match: location.pathname.includes("/oxer/page/ots/examIndex.html"),
        intv: () => {
            return $(".tika_topline").length;
        },
        root: ".queItemClass",
        elements: {
            question: "dt .din:eq(1)",
            options: ".clearfix div",
            $options: ".clearfix .xuan,input"
        },
        ignore_click: $item => {
            return $item.parent().hasClass("cur");
        },
        wrap: obj => {
            obj.plat = 66;
            obj.qid = obj.$item.attr("id");
            obj.type = getQuestionType(obj.$item.parent().find("div .fb:eq(0)").text());
            if (obj.type === 3) {
                obj.options = [ "正确", "错误" ];
            }
        }
    });
    WorkerJSPlus({
        name: "学起（测试）",
        match: location.pathname.includes("/oxer/page/ots/UniversityStart.html"),
        intv: () => {
            return $(".uniQueList").length;
        },
        root: ".uniQueItem",
        elements: {
            question: ".QueStem",
            options: "ul li span",
            $options: "ul li"
        },
        ignore_click: $item => {
            return $item.parent().hasClass("lichecked");
        },
        wrap: obj => {
            obj.type = getQuestionType(obj.$item.parents(".uniQueList").find(".fir").text());
            if (obj.type === 3) {
                obj.options = [ "正确", "错误" ];
            }
            console.log(obj);
        }
    });
    WorkerJSPlus({
        name: "易班考试",
        match: location.host === "exam.yooc.me" && location.pathname.includes("/group"),
        intv: () => {
            return $(".jsx-3527395752").length;
        },
        root: "main:last",
        elements: {
            question: "h3 div",
            options: ".mb ul li .flex-auto",
            $options: ".mb ul li",
            type: ".mb-s"
        },
        ignore_click: $item => {
            return $item.hasClass("_c");
        },
        fill: (type, answer, $option) => {
            if (type === 4 || type === 2) {
                $(".exam-input").val("answer");
            }
        },
        finished: need_jump => {
            if ($('.round:contains("下一题")').hasClass("ghost")) return false;
            $('.round:contains("下一题")').click();
            return true;
        }
    });
    WorkerJSPlus({
        name: "英华学堂",
        match: () => {
            const pathMatch = location.pathname.includes("/user/work") || location.pathname.includes("/user/exam");
            const matchHostArr = [ "mooc.kdcnu.com", "mooc.yncjxy.com", "mooc.cdcas.com", "mooc.cqcst.edu.cn", "mooc.kmcc.edu.cn", "mooc.wuhues.com" ];
            return pathMatch && matchHostArr.includes(location.host);
        },
        intv: () => {
            return $("#stateName").text().trim() === "进行中";
        },
        root: ".courseexamcon-main",
        elements: {
            question: ".name",
            options: ".list li .txt",
            $options: ".list li .exam-inp",
            type: ".type"
        },
        ignore_click: $item => {
            return $item.prop("checked");
        },
        fill: (type, answer, $option) => {},
        finished: auto_jump => {
            if ($(".next_exam").eq(3).prop("style")[0] == "display") return false;
            $(".next_exam").click();
        }
    });
    WorkerJSPlus({
        name: "厦门在线教育测验",
        match: location.pathname.includes("/nec/student/exam/exam-paper!test"),
        root: "#paper_form > div:nth-child(4) > table:nth-child(1) > tbody:nth-child(2)>tr:even",
        elements: {
            question: "td:eq(1)",
            options: ".optionUl label .el-radio__label,.el-checkbox__label",
            $options: ".optionUl label"
        },
        wrap: obj => {
            obj.options = obj.$item.next().find("tbody:first > tr tbody").map((i, y) => {
                return $(y).find("td:eq(1)").text();
            }).toArray();
            obj.$options = obj.$item.next().find("tbody:first > tr tbody").map((i, y) => {
                return $(y).find("input");
            });
            obj.type = 0;
        }
    });
    WorkerJSPlus({
        name: "金牌学堂",
        match: location.host === "www.goldgame.com.cn" && location.href.includes("/TestPage"),
        intv: () => {
            return $(".tab-btn-box li").length;
        },
        root: ".test-type-box ul .white-bg",
        elements: {
            question: ".position-relative h3",
            options: ".test-option label p:last-child",
            $options: ".test-option label input"
        },
        wrap: obj => {
            obj.question = obj.question.replace(/题目\d+\:/, "").trim().replace(/^\d+./, "");
            obj.type = getQuestionType(obj.$item.parent().parent().find(".test-type-tips").text());
            if (obj.$options.length > 2 && obj.$options.eq(0).hasClass("radiobox")) {
                obj.type = 0;
            }
        },
        fillFinish: data => {
            $(".answer-sheet li").eq(GLOBAL.index).click();
        }
    });
    WorkerJSPlus({
        name: "青岛开放大学",
        match: location.pathname.includes("/pages/exam/exam.html"),
        intv: () => {
            return $(".exam-content-block .exam-content-topic").length;
        },
        root: ".exam-content-block .exam-content-topic",
        elements: {
            question: ".exam-topic-title",
            options: ".exam-topic-answer .layui-unselect span",
            $options: ".exam-topic-answer .layui-unselect"
        },
        wrap: obj => {
            obj.type = getQuestionType(obj.$item.parent().find(".exam-content-title .exam-content-num").text());
        }
    });
    WorkerJSPlus({
        name: "点墨考试",
        match: location.pathname.includes("/Exam/StartExam"),
        root: "#question div div:first",
        elements: {
            question: "div:first",
            options: "div:first ~ div",
            $options: "div:first ~ div input"
        },
        wrap: obj => {
            obj.type = getQuestionType($(".alert #groupNameSpan").text());
        },
        finished: () => {
            $(".w-100 .btn-light:eq(1)").click();
            return true;
        }
    });
    WorkerJSPlus({
        name: "点墨测验",
        match: location.pathname.includes("/Course/TestPaper"),
        root: ".question",
        elements: {
            question: " div div:first div:first",
            options: " div div:first div:first ~ div",
            $options: " div div:first div:first ~ div input"
        },
        wrap: obj => {
            obj.type = getQuestionType($("h3").text());
            obj.question = obj.question.replace(/^\d+\./, "");
        }
    });
    WorkerJSPlus({
        name: "警官学院",
        match: location.pathname.includes("/bsmytest/startTi.do"),
        root: ".wrapper > div",
        elements: {
            question: ".dx",
            options: "p",
            $options: "p input"
        },
        wrap: obj => {
            if ($(".wrapper .cl").length > 0) {
                obj.question = obj.$item.text().replace(/[0-9]、/, "").replace(/\（.*?\）/g, "").trim().split("$")[0].replace(/\(.*?\)/g, "").trim();
            } else {
                obj.question = obj.question.replace(/[0-9]、/, "").replace(/\（.*?\）/g, "").trim();
            }
            obj.type = getQuestionType(obj.$item.parent().find("h2").text());
            obj.options = obj.options.map(item => {
                return item.replace(/[A-Za-z][\：]/, "").replace(/[A-Za-z][\：,\:]/, "").replace(/\；/, "").trim();
            });
        }
    });
    WorkerJSPlus({
        name: "exam2_euibe_com_exam",
        match: location.hostname === "exam2.euibe.com" && location.pathname === "/KaoShi/ShiTiYe.aspx",
        root: ".question",
        elements: {
            question: ".wenti",
            options: "li label span",
            $options: "li label"
        },
        wrap: obj => {
            obj.type = getQuestionType($(".question_head").text());
        },
        finished: need_jump => {
            $(".paginationjs-next").click();
            return true;
        }
    });
    WorkerJSPlus({
        name: "lzwyedu_jijiaool_com_exam",
        match: () => {
            const pathMatch = location.pathname.includes("/learnspace/course/test/") || location.pathname.includes("/Student/ExamManage/CourseOnlineExamination");
            const matchHostArr = [ "lzwyedu.jijiaool.com", "cgjx.jsnu.edu.cn", "learn-cs.icve.com.cn", "nwnu.jijiaool.com", "lut.jijiaool.com", "learn.courshare.cn", "cj1027-kfkc.webtrn.cn" ];
            return pathMatch && matchHostArr.includes(location.host);
        },
        root: ".test_item",
        elements: {
            question: ".test_item_tit",
            options: ".test_item_theme label .zdh_op_con",
            $options: "label input"
        },
        wrap: obj => {
            obj.question = obj.question.replace(/该题未做$/, "").replace(/^\d+\./, "").replace(/^\d+、/, "").replace(/[(（](\d+\s?(\.\d+)?分)[)）]$/, "").replace(/^((\d+.(\s+)?)?)[\[(（【](.*?)[】)）\]]/, "").trim();
            obj.type = getQuestionType(obj.$item.prevAll(".test_item_type:first").text());
            if (obj.type === 3) {
                obj.options = [ "对", "错" ];
            }
        }
    });
    WorkerJSPlus({
        name: "zzx_ouchn_edu_cn_exam",
        match: location.hostname === "zzx.ouchn.edu.cn" && location.pathname.includes("/edu/public/student/"),
        root: ".subject",
        elements: {
            question: ".question span",
            options: ".answer>span>p:first-child",
            $options: ".answer>span>p:first-child"
        },
        wrap: obj => {
            if (obj.$options.length > 1) {
                obj.type = 0;
            }
        }
    });
    WorkerJSPlus({
        name: "zzx_ouchn_edu_cn_exam",
        match: location.hostname === "zzx.ouchn.edu.cn" && location.pathname.includes("/edu/public/student/"),
        root: ".subject",
        elements: {
            question: ".question span",
            options: ".answer>span>p:first-child",
            $options: ".answer>span>p:first-child"
        },
        wrap: obj => {
            if (obj.$options.length > 1) {
                obj.type = 0;
            }
        }
    });
    WorkerJSPlus({
        name: "havust_hnscen_cn_exam",
        match: location.hostname === "havust.hnscen.cn" && location.pathname.includes("/stuExam/examing/"),
        root: ".main .mt_2 > div",
        elements: {
            question: ".flex_row+div",
            options: ".flex_row+div+div .el-radio__label,.el-checkbox__label",
            $options: ".flex_row+div+div .el-radio__label,.el-checkbox__label",
            type: ".flex_row .mr_2"
        }
    });
    WorkerJSPlus({
        name: "www_zygbxxpt_com_exam",
        match: location.hostname === "www.zygbxxpt.com" && location.pathname.includes("/exam"),
        root: ".Body",
        elements: {
            question: ".QName",
            options: ".QuestinXuanXiang p:parent",
            $options: ".QuestinXuanXiang p:parent",
            type: ".QName span"
        },
        wrap: obj => {
            obj.question = obj.question.replace(/\([^\)]*\)/g, "").replace(/\【.*?\】/g, "");
            obj.options = obj.options.map(item => {
                return item.split(">").pop().trim();
            });
        }
    });
    WorkerJSPlus({
        name: "xuexi_jsou_cn_work",
        match: location.hostname === "xuexi.jsou.cn" && location.pathname.includes("/jxpt-web/student/newHomework/showHomeworkByStatus"),
        root: ".insert",
        elements: {
            question: ".window-title",
            options: ".questionId-option .option-title div[style^=display]",
            $options: ".questionId-option .option-title .numberCover"
        },
        wrap: obj => {
            obj.type = {
                1: 0,
                2: 1,
                7: 3
            }[obj.$item.find(".question-type").val()];
            if (obj.options.length == 2) {
                obj.type = 3;
            }
        }
    });
    WorkerJSPlus({
        name: "czvtc_cjEdu_com_exam",
        match: () => {
            const pathMatch = location.pathname.includes("/ExamInfo") || location.pathname.includes("/Examination");
            const matchHostArr = [ "czvtc.cj-edu.com", "hbkjxy.cj-edu.com", "bhlgxy.cj-edu.com", "hbsi.cj-edu.com", "czys.cj-edu.com", "hbjd.cj-edu.com", "xttc.cj-edu.com", "bvtc.cj-edu.com", "caztc.cj-edu.com" ];
            return pathMatch && matchHostArr.includes(location.host);
        },
        intv: () => {
            return $(".el-container .all_subject>.el-row").length;
        },
        root: ".el-container .all_subject>.el-row",
        elements: {
            question: ".stem div:last-child",
            options: ".el-radio-group .el-radio__label,.el-checkbox-group .el-checkbox__label",
            $options: ".el-radio-group .el-radio__original,.el-checkbox-group .el-checkbox__original"
        },
        wrap: obj => {
            if (obj.$options.length < 3 && obj.$options.eq(0).attr("type") === "radio") {
                obj.type = 3;
            } else if (obj.$options.length > 2 && obj.$options.eq(0).attr("type") === "radio") {
                obj.type = 0;
            } else if (obj.$options.length > 2 && obj.$options.eq(0).attr("type") === "checkbox") {
                obj.type = 1;
            }
        }
    });
    WorkerJSPlus({
        name: "learning_mhtall_com_exam",
        match: location.host.includes("learning.mhtall.com") && location.pathname.includes("/rest/course/exercise/item"),
        root: "#div_item",
        elements: {
            question: ".item_title",
            options: ".opt div label",
            $options: ".opt div input:not(.button_short)",
            type: "h4"
        },
        ignore_click: $item => {
            return $item.prop("checked");
        },
        wrap: obj => {
            if (obj.type === 0 || obj.type === 3) {
                obj.answer = $(".div_answer").text().match(/[a-zA-Z]/).map(i => {
                    return obj.options[i.charCodeAt(0) - 65];
                });
            } else if (obj.type === 2) {
                obj.answer = $(".div_answer").text().replace("参考答案：", "").split("，");
            }
        },
        fill: (type, answer, $option) => {
            if (type === 2 || type === 4) {
                $option.val(answer);
                $(".DIV_TYPE_BLANK .button_short").click();
            }
        },
        fillFinish: () => {
            if ($(".opt+div+div input:eq(1)").val() === "下一题") {
                $(".opt+div+div input:eq(1)").click();
            } else {
                $(".button_short:eq(2)").click();
            }
        }
    });
    WorkerJSPlus({
        name: "168网校(测验)",
        match: location.host.includes("168wangxiao.com") && location.pathname.includes("/web/learningCenter/details/"),
        intv: () => {
            return $(".ret-answer").length === 0 && $(".info-container").length;
        },
        root: ".question-item-container",
        elements: {
            question: ".title-content",
            options: ".options .opt-content",
            $options: ".options label",
            type: ".top .type"
        }
    });
    WorkerJSPlus({
        name: "168网校(考试)",
        match: location.host.includes("168wangxiao.com") && location.pathname.includes("/web/examination/answer"),
        intv: () => {
            return $(".Answer-area").length;
        },
        root: ".Answer-area",
        elements: {
            question: ".listTit",
            options: ".el-radio__label span:last-child,.el-checkbox__label span:last-child",
            $options: ".el-radio__input,.el-checkbox__input input,.ql-editor p"
        },
        ignore_click: $item => {
            return $item.prop("checked");
        },
        wrap: obj => {
            if (obj.options.length === 0) {
                obj.type = 2;
            }
            console.log(obj);
        },
        fill: (type, answer, $option) => {
            if (type === 2 || type === 4) {
                console.log(answer);
                document.querySelector(".ql-editor p").textContent = answer;
            }
        },
        finished: () => {
            if ($(".ctrl .el-button:contains(下一题)").length != 0) {
                $(".ctrl .el-button:contains(下一题)").click();
                return true;
            } else if ($(".ctrl .el-button:contains(上一题)").length && $(".ctrl button").length === 1) {
                return false;
            }
        }
    });
    WorkerJSPlus({
        name: "法宣在线",
        match: location.host.includes("faxuanyun.com") && location.pathname.includes("/bps/examination"),
        intv: () => {
            return $("#timucontent").length;
        },
        root: "#timucontent",
        elements: {
            question: "h2",
            options: "ul li",
            $options: "ul input"
        },
        ignore_click: $item => {
            return $item.prop("checked");
        },
        wrap: obj => {
            obj.question = obj.question.replace(/[\（(].+?[)\）]/g, "");
            if ($(".layui-layer-content").length) {
                iframeMsg("tip", {
                    type: "stop",
                    tip: "答题暂停，请自行通过验证"
                });
                $("#lastButton").click();
                GLOBAL.stop = true;
                return false;
            }
        },
        finished: need_jump => {
            if ($("#nextButton").length) {
                $("#nextButton").click();
                return true;
            } else {
                return false;
            }
        }
    });
    WorkerJSPlus({
        name: "山财培训网 (补考)",
        match: location.host.includes("training.sdufe.edu.cn") && location.pathname.includes("/Exam/OnlineExam/"),
        intv: () => {
            return $(".exam_r_m").length;
        },
        root: ".exam_r_m",
        elements: {
            question: ".bt",
            options: ".btm",
            $options: ".btm input"
        },
        ignore_click: $item => {
            return $item.prop("checked");
        },
        wrap: obj => {
            obj.question = obj.question.replace(/[\（(].+?[)\）]/g, "");
            obj.options = $("br").parent().text().split(/[A-Z]\./).slice(1).map(item => {
                return item.trim();
            });
            if (obj.type === 3) {
                obj.answer = $("#answerDiv").text().replace("正确答案：", "").split();
            } else {
                obj.answer = $("#answerDiv").text().match(/[A-Z]/g).map(item => {
                    return obj.options[item.charCodeAt(0) - 65];
                });
            }
        },
        finished: () => {
            document.querySelector("#next").click();
            if (document.querySelector("#noAskCount").textContent == "0") {
                return false;
            }
            return true;
        }
    });
    WorkerJSPlus({
        name: "和学在线",
        match: (location.host.includes("student.hexuezx") || location.host.includes("student.jxjyzx")) && location.hash.includes("homework-questions"),
        intv: () => {
            return $(".el-card__body").length;
        },
        root: ".el-card__body",
        elements: {
            question: ".stem",
            options: ".el-radio__label,.el-checkbox__label span",
            $options: ".el-radio__input,.el-checkbox__input input"
        },
        ignore_click: $item => {
            return $item.prop("checked");
        },
        wrap: obj => {
            obj.question = obj.question.replace(/[\（(].+?[)\）]/g, "");
            console.log(obj);
        }
    });
    WorkerJSPlus({
        name: "高教在线",
        match: location.host === "www.cqooc.com" && (location.href.includes("/learn/mooc/exam/do") || location.href.includes("/learn/mooc/testing/do")),
        intv: () => {
            return $("#test-form").length;
        },
        root: "#test-form .cat",
        elements: {
            question: ".stem",
            options: ".option label",
            $options: ".option input"
        },
        ignore_click: $item => {
            return $item.prop("checked");
        },
        wrap: obj => {
            obj.question = obj.question.replace(/\(\d+分\)\d+\.\d+/, "");
            console.log(obj);
        }
    });
    WorkerJSPlus({
        name: "柠檬文才（考试）",
        match: () => {
            const pathMatch = location.pathname.includes("/separation/exam/");
            const matchHostArr = [ "learning.wuxuejiaoyu.cn", "learning.wencaischool.net", "learning.zk211.com", "study.wencaischool.net", "www.wencaischool.net" ];
            return pathMatch && matchHostArr.includes(location.host);
        },
        intv: () => {
            return $("#paperExam").css("display") != "none";
        },
        root: ".paperWrapper .tmList",
        elements: {
            question: ".tmTitleTxt",
            options: ".ansbox .opCont",
            $options: ".ansbox input"
        },
        ignore_click: $item => {
            return $item.prop("checked");
        },
        wrap: obj => {
            if (obj.options.length === 0) {
                obj.type = 2;
            }
            console.log(obj);
        },
        fill: (type, answer, $option) => {
            if (type === 4 || type === 2) {
                $option.val(answer);
            }
        }
    });
    WorkerJSPlus({
        name: "柠檬文才（作业）",
        match: () => {
            const matchHostArr = [ "learning.wuxuejiaoyu.cn", "learning.wencaischool.net", "learning.zk211.com", "study.wencaischool.net" ];
            return (location.pathname.includes("/hblearning/exam/") || location.pathname.includes("/xbsflearning/exam/") || location.pathname.includes("/openlearning/exam/") || location.pathname.includes("/jxlearning/exam/") || location.pathname.includes("/shandonglearning/exam")) && matchHostArr.includes(location.host);
        },
        intv: () => {
            return $("#paperExam").css("display") !== "none";
        },
        root: "#_block_content_exam #tblDataList>tbody>tr",
        elements: {
            question: "tbody:first>tr>td:last table",
            options: ".ansbox .opCont",
            $options: ".ansbox input"
        },
        ignore_click: $item => {
            return $item.prop("checked");
        },
        wrap: obj => {
            obj.question = $("#_block_content_exam #tblDataList>tbody>tr>td").find(" tbody:first>tr>td:last table:first").eq(GLOBAL.index - 1).find("tr:first").text();
            obj.options = [];
            $("#_block_content_exam #tblDataList>tbody>tr>td").find(" tbody:first>tr>td:last table:first").eq(GLOBAL.index - 1).find("tr:first").next().find("label").map((i, y) => {
                obj.options.push($(y).text());
            });
            obj.$options = $("#_block_content_exam #tblDataList>tbody>tr>td").find(" tbody:first>tr>td:last table:first").eq(GLOBAL.index - 1).find("tr:first").next().find("input").map((i, y) => {
                return y;
            });
            obj.type = 0;
            if (obj.options.length == 2) {
                obj.type = 3;
            } else if (obj.$options.eq(0).attr("type") != "radio") {
                obj.type = 1;
            }
            console.log(obj);
        }
    });
    WorkerJSPlus({
        name: "福建师范",
        match: location.host === "neo.fjnu.cn" && location.pathname.includes("/resource/index"),
        intv: () => {
            return $(".content").length && !$(".answer-content").length;
        },
        root: ".content",
        elements: {
            question: ".title",
            options: "label .el-radio__label,.el-checkbox__label",
            $options: "label input"
        },
        ignore_click: $item => {
            return $item.prop("checked");
        },
        wrap: obj => {
            console.log(obj);
        }
    });
    WorkerJSPlus({
        name: "优课学堂",
        match: location.host.includes("youkexuetang.cn") && location.pathname.includes("/student/"),
        intv: () => {
            return $(".paperItemBox").length;
        },
        root: ".paperItemBox",
        elements: {
            question: ".stem",
            options: ".el-radio__label,.el-checkbox__label",
            $options: ".el-radio__input,.el-checkbox__input input"
        },
        ignore_click: $item => {
            return $item.prop("checked");
        },
        wrap: obj => {
            obj.question = obj.question.replace(/[\（(].+?[)\）]/g, "");
            console.log(obj);
        }
    });
    WorkerJSPlus({
        name: "亿学宝云",
        match: location.host.includes("yxbyun.com") && location.pathname.includes("/yxbstudent/"),
        intv: () => {
            return $(".time_header").length || $(".pager_wrap").length;
        },
        hook: () => {
            JSONParseHook(o => {
                if (o.data && o.data.bigContent) {
                    GLOBAL.json = parseYxbyunExam(o.data.bigContent).reduce((acc, cur) => {
                        return acc.concat(cur);
                    }, []);
                    GLOBAL.json.forEach(item => uploadQuestionBankCandidate(item, item.answer, "亿学宝云平台标准答案"));
                    console.log(GLOBAL.json);
                }
            });
        },
        root: ".test",
        elements: {
            question: ".type",
            options: ".el-radio-group,.el-checkbox-group label",
            $options: ".el-radio__input,.el-checkbox__input input",
            type: ".el-tag"
        },
        wrap: obj => {
            Object.assign(obj, GLOBAL.json[GLOBAL.index - 1]);
        },
        ignore_click: $item => {
            return $item.prop("checked");
        }
    });
    WorkerJSPlus({
        name: "考试星（单题）",
        match: Boolean(location.host === "exam.kaoshixing.com" && location.pathname.includes("/exam/exam_start")),
        intv: () => {
            return $("#nextQuestions").length;
        },
        root: ".questions .questions-content",
        elements: {
            question: ".question-name",
            options: ".answers label .words",
            $options: ".answers label"
        },
        ignore_click: $item => {
            return $item.parent().find("input").prop("checked");
        },
        wrap: obj => {
            obj.question = obj.question.replace(/[\（(].+?[)\）]/g, "");
            console.log(obj);
        },
        finished: () => {
            if ($("#nextQuestions:contains(下一题)").length && $("#nextQuestions").css("display") !== "none") {
                $("#nextQuestions:contains(下一题)").click();
                return true;
            } else {
                return false;
            }
        }
    });
    WorkerJSPlus({
        name: "易考云",
        match: location.host === "exam.beeouc.com" && location.pathname.includes("/client"),
        intv: () => {
            return $(".question-body").length;
        },
        root: ".question-body",
        elements: {
            question: ".question-stem",
            options: ".question-option label",
            $options: ".question-option input",
            type: ".question-type"
        },
        ignore_click: $item => {
            return $item.prop("checked");
        },
        wrap: obj => {
            console.log(obj);
        },
        finished: () => {
            if ($(".question-footer button:contains(下一题)").length) {
                $(".question-footer button:contains(下一题)").click();
                return true;
            } else {
                return false;
            }
        }
    });
    WorkerJSPlus({
        name: "伊犁师范成人教育",
        match: location.host === "exam.weirenzheng.cn" && (location.pathname.includes("//GeneralTestPaper/Testing/") || location.pathname.includes("//GeneralTestPaper/SNTesting")),
        intv: () => {
            return $(".topic").length;
        },
        root: ".topic",
        elements: {
            question: ".qsctt",
            options: ".xuan li",
            $options: ".choice input"
        },
        ignore_click: $item => {
            return $item.prop("checked");
        },
        wrap: obj => {
            obj.options = obj.options.map(i => {
                return i.replace(/^[A-Z] \. /, "");
            });
            if (obj.$options.length == 2) {
                obj.options = [ "正确", "错误" ];
                obj.type = 3;
            }
        }
    });
    WorkerJSPlus({
        name: "绎通云课堂 （作业）",
        match: location.host.includes("ytccr.com") && (location.hash.includes("#/learning-work") || location.hash.includes("#/learning-details")),
        intv: () => {
            return $(".left-question").length;
        },
        root: ".border-item",
        elements: {
            question: ".qa-title",
            options: "label .opt-title-cnt",
            $options: "label input"
        },
        ignore_click: $item => {
            return $item.prop("checked");
        }
    });
    WorkerJSPlus({
        name: "重庆大学网络教育学院 （作业）",
        match: location.host === "exercise.5any.com" && location.pathname.includes("/Exercise/WebUI/Test/Answer"),
        intv: () => {
            return $(".examtime-content").length;
        },
        root: ".subject .font-16",
        elements: {
            question: ".stem .richtextcontent",
            options: ".option .richtextcontent",
            $options: ".option label input"
        },
        ignore_click: $item => {
            return $item.prop("checked");
        }
    });
    WorkerJSPlus({
        name: "毕节幼儿师范",
        match: location.host === "px.gzbjyzjxjy.cn" || location.host === "px.ggcjxjy.cn" && location.pathname.includes("/exam/shiti/dopapers"),
        intv: () => {
            return $(".panel-body").length;
        },
        root: ".panel-body>div",
        elements: {
            question: ".testpaper-question-stem",
            options: ".testpaper-question-choices li",
            $options: ".testpaper-question-footer input"
        },
        ignore_click: $item => {
            return $item.prop("checked");
        },
        wrap: obj => {
            console.log(obj);
        }
    });
    WorkerJSPlus({
        name: "贵州继续教育",
        match: location.host === "www.gzjxjy.gzsrs.cn" && location.pathname.includes("/personback/"),
        intv: () => {
            return $(".question-title").length;
        },
        root: ".question-title",
        elements: {
            question: ".show-text",
            options: "label",
            $options: "label input"
        },
        ignore_click: $item => {
            return $item.prop("checked");
        },
        wrap: obj => {
            console.log(obj);
        }
    });
    WorkerJSPlus({
        name: "和学自考",
        match: location.host === "zkpt.qdu.edu.cn" && location.pathname.includes("/examStu/exam/examPaper"),
        intv: () => {
            return $(".ant-spin-container").length;
        },
        root: ".ant-row",
        elements: {
            options: "label",
            $options: "label input"
        },
        ignore_click: $item => {
            return $item.prop("checked");
        },
        wrap: obj => {
            obj.question = obj.$item.parent().parent().prev().text();
            console.log(obj);
        }
    });
    WorkerJSPlus({
        name: "专技天下",
        match: location.host.includes("zgzjzj.com") && location.pathname.includes("/examination/perpar.html"),
        intv: () => {
            return $(".question_index").length;
        },
        root: ".question_index",
        elements: {
            question: "p",
            options: ".options li p,li>span:last-child",
            $options: ".options li",
            type: "p span"
        },
        ignore_click: $item => {
            return $item.hasClass("active");
        }
    });
    WorkerJSPlus({
        name: "睿学补考",
        match: location.href.includes("exam-app-exam-paper") && location.host.includes("ks.hustsnde.com"),
        intv: () => {
            return $("#paper").length;
        },
        root: "#paper .content-box",
        elements: {
            question: "ul li:eq(0) .desc",
            options: "ul li:eq(1)",
            $options: "ul label input",
            type: ".title"
        },
        ignore_click: $item => {
            return $item.prop("checked");
        },
        wrap: obj => {
            const options = obj.options[0].trim().split(/\[[A-Z]:?\]/).splice(1).map(i => {
                return i.trim();
            }).filter(i => i);
            if (options.length === 0) {
                obj.options = obj.options[0].trim().split(/\(?[A-Z\.?]\)?/).splice(1).map(i => {
                    return i.trim();
                }).filter(i => i);
            } else {
                obj.options = options;
            }
            if (obj.type === 3) {
                obj.options = [ "正确", "错误" ];
            }
        }
    });
    WorkerJSPlus({
        name: "云上河开",
        match: location.host === "jx.open.ha.cn" && location.pathname.includes("/jxpt-web/student/homework/showHomeworkByStatus"),
        intv: () => {
            return $("#shiti-content").length;
        },
        root: ".insert",
        elements: {
            question: ".window-title",
            options: "ul li div:last-child",
            $options: "ul li .numberCover"
        },
        ignore_click: $item => {
            return $item.parent().hasClass("answer-title");
        },
        wrap: obj => {
            obj.type = getQuestionType(obj.$item.parents(".layui-colla-item").find(".titleType").text());
        }
    });
    WorkerJSPlus({
        name: "ycjy.lut.edu.cn",
        match: location.host === "ycjy.lut.edu.cn" && location.pathname.includes("/learnspace/course/test/coursewareTest_intoTestPage.action"),
        intv: () => {
            return $(".bank_cont").length;
        },
        root: ".test_item",
        elements: {
            options: "label",
            $options: "label input"
        },
        ignore_click: $item => {
            return $item.prop("checked");
        },
        wrap: obj => {
            obj.type = getQuestionType(obj.$item.parent().find(".test_item_type").text());
            obj.question = obj.$item.find(".test_item_tit").contents()[0].nodeValue.trim();
        }
    });
    WorkerJSPlus({
        name: "exam.euibe.com",
        match: location.host === "exam.euibe.com" && location.pathname.includes("/KaoShi/ShiTiYe.aspx"),
        intv: () => {
            return $(".question_list").length;
        },
        root: ".question",
        elements: {
            question: ".wenti .stem",
            options: "label span",
            $options: "label input"
        },
        ignore_click: $item => {
            return $item.prop("checked");
        },
        wrap: obj => {
            obj.type = getQuestionType(obj.$item.parents(".question_list").find(".question_head").text());
        },
        finished: need_jump => {
            if ($(".paginationjs-next").hasClass("disabled")) {
                return false;
            }
            $(".paginationjs-next").click();
            return true;
        }
    });
    WorkerJSPlus({
        name: "学晖教育",
        match: location.host === "xhjy.ldzxjy.com" && location.pathname.includes("tikuUserBatch/keepTopic"),
        intv: () => {
            return $(".radio").length;
        },
        root: ".radio",
        elements: {
            question: ".issueTitle",
            options: "ul li span",
            $options: "ul li",
            type: ".issueTypes"
        },
        ignore_click: $item => {
            return $item.prop("checked");
        },
        finished: need_jump => {
            if ($(".next").text().includes("交卷")) {
                return false;
            }
            $(".next").click();
            return true;
        }
    });
    WorkerJSPlus({
        name: "东财在线",
        match: location.host === "classroom.edufe.com.cn" && (location.pathname.includes("/PracticePaper") || location.pathname.includes("/HomeWorkPaper")),
        intv: () => {
            return $(".TK-main").length;
        },
        root: ".CBTPaperMain-trunk",
        elements: {
            question: ".CBTPaperMain-divInline",
            options: "ul li label",
            $options: "ul li label"
        },
        ignore_click: $item => {
            return $item.hasClass("_CheckBox_checked");
        }
    });
    WorkerJSPlus({
        name: "北华大学在线教育",
        match: () => {
            const pathnameArr = [ "cj1026-kfkc.webtrn.cn", "beihua.peishenjy.com" ];
            return pathnameArr.includes(location.pathname) && location.pathname.includes("/Learning/CourseOnlineExamination") || location.pathname.includes("/learnspace/course/test");
        },
        intv: () => {
            return $(".s_mi").length;
        },
        root: ".test_item",
        elements: {
            question: ".test_item_tit",
            options: " label",
            $options: "label input"
        },
        ignore_click: $item => {
            return $item.prop("checked");
        },
        wrap: obj => {
            console.log(obj);
        }
    });
    WorkerJSPlus({
        name: "上海立达学院",
        match: location.host === "kkzxsx.lidapoly.edu.cn" && location.pathname.includes("/exam/"),
        intv: () => {
            return $(".exam-question").length;
        },
        root: ".main .item",
        elements: {
            question: ".text",
            options: ".options label .el-radio__label,.el-checkbox__label",
            $options: ".options label"
        },
        ignore_click: $item => {
            return $item.hasClass("is-checked");
        },
        wrap: obj => {
            obj.type = getQuestionType(obj.$item.parent().find(".text").text());
            console.log(obj);
        }
    });
    WorkerJSPlus({
        name: "石家庄科技继续教育",
        match: location.host.includes("kc.jxjypt.cn") && location.pathname.includes("/paper/start"),
        intv: () => {
            return $(".sub-content").length;
        },
        root: ".sub-content",
        elements: {
            question: ".sub-dotitle",
            options: ".sub-answer dd",
            $options: ".sub-answer dd,.mater-respond textarea",
            type: ".sub-dotitle i"
        },
        ignore_click: $item => {
            return $item.hasClass("cho-this");
        },
        wrap: obj => {
            console.log(obj);
        },
        fill: (type, answer, $option) => {
            if (type === 4) {
                $option.val(answer);
            }
        }
    });
    WorkerJSPlus({
        name: "石家庄理工职业学院",
        match: location.host.includes("edu.tianzerencai.com") && location.pathname.includes("/examinationDetail"),
        intv: () => {
            return $(".topic").length;
        },
        root: ".topic",
        elements: {
            question: ".title",
            options: ".main",
            $options: ".main",
            type: ".title"
        },
        ignore_click: $item => {
            return $item.hasClass("cho-this");
        },
        wrap: obj => {
            if (obj.type === 3) {
                obj.options = [ "正确", "错误" ];
                obj.$options = obj.$item.find(".judge button");
            } else if (obj.type === 1) {
                obj.options = obj.$item.find(".checkbox .option_text").map((i, y) => {
                    return $(y).text();
                }).toArray();
                obj.$options = obj.$item.find(".checkbox button");
            } else if (obj.type === 0) {
                obj.options = obj.$item.find(".radio .option_text").map((i, y) => {
                    return $(y).text();
                }).toArray();
                obj.$options = obj.$item.find(".radio button");
            }
            console.log(obj);
        }
    });
    WorkerJSPlus({
        name: "国开军盾",
        match: location.host.includes("s.jundunxueyuan.com") && location.hash.includes("#/exam/"),
        intv: () => {
            return $(".the-paper .section-item-question-item").length;
        },
        root: ".section-item-question-item",
        elements: {
            plat: 43,
            question: ".question-tit",
            options: ".el-radio-group label,.el-checkbox-group label",
            $options: ".el-radio-group input,.el-checkbox-group input",
            type: ".sub-dotitle i"
        },
        ignore_click: $item => {
            return $item.prop("checked");
        },
        wrap: obj => {
            obj.type = getQuestionType(obj.$item.parents(".section-item").find(".section-item-tit").text());
            console.log(obj);
        }
    });
    WorkerJSPlus({
        name: "博学bx",
        match: location.host.includes("bx.bossyun.com") && location.pathname.includes("/bx/study/examine"),
        intv: () => {
            return $(".question-list").length;
        },
        root: ".question-list",
        elements: {
            question: ".title",
            options: ".ant-radio-group label,.ant-checkbox-group label",
            $options: ".ant-radio-group input,.ant-checkbox-group input",
            type: ".tag"
        },
        ignore_click: $item => {
            return $item.prop("checked");
        }
    });
    WorkerJSPlus({
        name: "博学bx",
        match: location.host.includes("bx.bossyun.com") && location.pathname.includes("/bx/study/examine"),
        intv: () => {
            return $(".question-list").length;
        },
        root: ".question-list",
        elements: {
            question: ".title",
            options: ".ant-radio-group label,.ant-checkbox-group label",
            $options: ".ant-radio-group input,.ant-checkbox-group input",
            type: ".tag"
        },
        ignore_click: $item => {
            return $item.prop("checked");
        }
    });
    WorkerJSPlus({
        name: "电中在线",
        match: location.host.includes("old-zzx.ouchn.edu.cn") && location.pathname.includes("/edu/public/student/"),
        intv: () => {
            return $(".subject").length;
        },
        root: ".subject",
        elements: {
            question: ".question",
            options: ".answer .option-name",
            $options: ".answer"
        },
        wrap: obj => {
            obj.type = 0;
            console.log(obj);
        }
    });
    WorkerJSPlus({
        name: "爱学",
        match: () => {
            const pathMatch = location.pathname.includes("/Web/Test/doing");
            const matchHostArr = [ "ai.ztbu.edu.cn", "www.51ixuejiao.com" ];
            return pathMatch && matchHostArr.includes(location.host);
        },
        intv: () => {
            return $("card-title").length;
        },
        root: ".exam dd",
        elements: {
            question: "card-title",
            options: ".ans_area div",
            $options: ".ans_area div",
            type: "info"
        },
        ignore_click: $item => {
            return $item.attr("selected") === "selected";
        },
        wrap: obj => {
            console.log(obj);
        },
        fillFinish: data => {
            if (data.ans.includes("span") || data.type === 1) {
                $(".move_btn span:last").click();
            }
        }
    });
    WorkerJSPlus({
        name: "人卫智网",
        match: location.host.includes("exam.ipmph.com") && location.pathname.includes("/front/myschool/index.html"),
        intv: () => {
            return $(".body").length;
        },
        root: ".body",
        elements: {
            question: ".fch2 font",
            options: ".selet .el-radio__label",
            $options: ".selet input"
        },
        wrap: obj => {
            obj.type = 0;
            console.log(obj);
        },
        finished: () => {
            document.querySelector(".next-btn .text-right a:last-child").click();
        }
    });
    WorkerJSPlus({
        name: "卫生人力资源系统",
        match: location.host.includes("vgos.zbwsrc.cn") && location.pathname.includes("/TESExamClient/"),
        intv: () => {
            return $(".testitem").length;
        },
        root: ".testitem",
        elements: {
            question: ".stem",
            options: ".inputitem li",
            $options: ".inputitem input"
        },
        wrap: obj => {
            obj.type = 0;
            console.log(obj);
        }
    });
    WorkerJSPlus({
        name: "继教在线（考试）",
        match: location.pathname.includes("/Student/ExamManage/CourseOnlineExamination"),
        intv: () => {
            return $(".test_item").length;
        },
        root: ".test_item",
        elements: {
            question: ".test_item_tit",
            options: ".test_item_theme label",
            $options: ".test_item_theme input"
        },
        ignore_click: $item => {
            return $item.prop("checked");
        },
        wrap: obj => {
            const $item = obj.$item;
            obj.type = getQuestionType($item.prevAll(".test_item_type").text());
            if (obj.type === 3) {
                obj.options = [ "正确", "错误" ];
            }
        }
    });
    WorkerJSPlus({
        name: "国开",
        match: location.host === "lms.ouchn.cn" && location.pathname.includes("/exam/"),
        intv: () => {
            return $(".loading-gif").hasClass("ng-hide") && $(".hd .examinee .submit-label").eq(0).text() === "";
        },
        root: ".card ol .single_selection,.multiple_selection,.true_or_false,.short_answer",
        elements: {
            question: ".summary-title .subject-description",
            options: ".subject-options li .option-content",
            $options: ".subject-options label .left",
            type: ".summary-sub-title span:eq(0)"
        },
        ignore_click: ($item, type) => {
            return type === 1 && $item.find("input").hasClass("ng-not-empty");
        }
    });
    WorkerJSPlus({
        name: "广开",
        match: () => {
            const pathMatch = location.pathname.includes("/mod/quiz/attempt.php");
            const matchHostArr = [ "moodle.syxy.ouchn.cn", "xczxzdbf.moodle.qwbx.ouchn.cn", "elearning.bjou.edu.cn", "whkpc.hnqtyq.cn:5678", "course.ougd.cn", "study.ouchn.cn" ];
            return pathMatch && matchHostArr.includes(location.host);
        },
        root: ".que",
        elements: {
            question: ".qtext",
            options: ".answer div label,.flex-fill",
            $options: ".answer div input:visible"
        },
        wrap: data => {
            if (data.type === undefined) {
                try {
                    data.type = 4;
                    data.$item.find(".qtext .accesshide").remove();
                    data.question = formatString(data.$item.find(".qtext").html());
                    data.$options = data.$item.find("input[id$=_answer]");
                } catch (e) {}
            }
        },
        ignore_click: $item => {
            return Boolean($item.parent().find("input").eq(-1).prop("checked"));
        },
        finished: () => {
            $(".submitbtns .btn-primary").click();
        },
        fill: (type, answer, $option) => {
            if (type === 4) {
                console.log(type, answer, $option);
                console.log($option.attr("id"));
                $option.val(answer);
            }
        }
    });
    WorkerJSPlus({
        name: "保定继续教育",
        match: location.pathname.includes("/exam/answer.html"),
        root: ".stem-container",
        elements: {
            question: ".stem  span",
            options: ".option div .optStem",
            $options: ".option div input"
        },
        intv: () => {
            return $("#question").length;
        },
        wrap: obj => {
            obj.type = getQuestionType(obj.$item.parent().parent().find(".description").text());
        }
    });
    WorkerJSPlus({
        name: "noNiExam.js",
        match: location.pathname === "/app-afstudy/self_test.html",
        root: ".lineClass .b-papp-root",
        elements: {
            question: ".b-exam-top  .b-exam-tit",
            options: ".b-exam-box li label",
            $options: ".b-exam-box li  input",
            type: ".b-exam-top .b-exam-type"
        },
        ignore_click($item) {
            return $item.prop("checked");
        },
        wrap(obj) {
            obj.options = obj.options.map(i => {
                return i.replace(/[A-Za-z][\：]/, "").replace(/[A-Za-z][\：,\:]/, "").replace(/\；/, "").trim();
            });
        }
    });
    WorkerJSPlus({
        name: "www_pbaqks_com_text",
        match: location.host === "www.pbaqks.com" && location.pathname.includes("/P_ExamDetail/OnlineStuday"),
        root: ".main-container .single-box",
        elements: {
            question: ".single-main:first",
            options: ".choose-box label",
            $options: ".choose-box label",
            type: ".single-container .font-title",
            answer: "input:eq(1)"
        },
        ignore_click: $i => {
            return $i.find("input").is(":checked");
        },
        wrap: obj => {
            obj.question = obj.question.replace("标准答案", "").replace(/^\d+\./, "").replace(/\[.+?\]/g, "").trim();
        },
        fillFinish: () => {
            if ($(".main-container .single-box").find("input:eq(1)").eq(GLOBAL.index - 1).attr("value").split("").length > 1) {
                jQuery(".main-container .confirm a:last-child").click();
            }
        }
    });
    WorkerJSPlus({
        name: "安徽继续教育",
        match: location.pathname.includes("/study/html/content/studying/") || (location.pathname === "/study/html/content/tkOnline/" || location.pathname === "/study/html/content/sxsk/" || location.pathname === "/study/html/content/bkExam/"),
        intv: () => {
            return ($(".e-save-b").length || $(".e-b-g").length) && $(".totalscore").length === 0;
        },
        root: ".e-q",
        elements: {
            question: ".e-q-q .ErichText",
            options: ".e-a-g li",
            $options: ".e-a-g li"
        },
        ignore_click: $item => {
            return $item.attr("class").includes("checked");
        },
        wrap: obj => {
            obj.type = getQuestionType(obj.$item.parent().prev().find(".e-text").text());
            obj.options = obj.options.map(i => {
                return formatString(i.replaceAll(/^[ab]\)\s+/g, "").replaceAll(/^[a-z]\s+/g, "").replaceAll(/^[a-z]、\s+/g, "").trim());
            });
        }
    });
    WorkerJSPlus({
        name: "大连/九江",
        match: location.href.includes("/onlineclass/exam/"),
        intv: () => {
            return $(".excer_list_view___2Ahg9") || $(".excer_list_view___YOSCa");
        },
        root: ".single_excer_item___lFMCm,.single_excer_item___2lGB8",
        elements: {
            plat: 40,
            question: ".title_content___1Qagx .title_content_text___27NIL, .title_content___24J6D .title_content_text___8ruL4",
            options: ".options_content___nXSwG label .option_text___udjiE, .options_content___2YgyG label .option_text___1mfcu",
            $options: ".options_content___nXSwG label input,.options_content___2YgyG label input",
            type: ".title_content___1Qagx span:eq(1),.title_content___24J6D span:eq(1)"
        },
        ignore_click: $item => {
            return $($item).parent().hasClass("ant-checkbox-checked");
        },
        wrap: obj => {
            console.log(obj);
        },
        fill: (type, answer, $option) => {
            if (type === 4 || type === 2) {
                $option.val(answer);
            }
        }
    });
    WorkerJSPlus({
        name: "新疆继续教育",
        hook: () => {
            function parseXinJiangAgain(questions) {
                return questions.map(item => {
                    const answer = [];
                    const options = item.answers.map(opt => {
                        if (opt.isAnswer === "0") answer.push(formatString(opt.name));
                        return formatString(opt.name);
                    });
                    const type = item.types === "2" ? 3 : parseInt(item.types);
                    return {
                        question: item.name,
                        options: options,
                        answer: answer,
                        type: type
                    };
                });
            }
            JSONParseHook(o => {
                if (o.success && o.data.exam) {
                    const arr = o.data.exam.assessList.map(i => {
                        return i.questionList;
                    }).flat();
                    GLOBAL.json = parseXinJiangAgain(arr);
                }
            });
        },
        match: location.host === "www.ttcdw.cn" && location.pathname.includes("/p/uExam/goExam/"),
        root: ".question-item",
        elements: {
            question: ".question-item-title span",
            options: ".question-item-option label .el-checkbox__label,.el-radio__label",
            $options: ".question-item-option label"
        },
        wrap: obj => {
            Object.assign(obj, GLOBAL.json[GLOBAL.index - 1]);
        },
        intv: () => {
            return !$("div").hasClass("entrying-wrap");
        },
        ignore_click: $item => {
            return $item.hasClass("is-checked");
        },
        fill: (type, answer, $option) => {
            if (type === 4 || type === 2) {
                $option.val(answer);
            }
        }
    });
    WorkerJSPlus({
        name: "华侨继续教育",
        match: location.pathname.includes("/exam/student/exam/resource/paper_card2"),
        intv: () => {
            return $(".ui-question-answer-right").length === 0;
        },
        root: ".ui-question-group .ui-question",
        elements: {
            question: ".ui-question-title  div",
            options: ".ui-question-options  div",
            $options: ".ui-question-options .ui-question-options-order,.ke-container"
        },
        wrap: obj => {
            obj.type = getQuestionType(obj.$item.parent().find("h2").text());
        },
        ignore_click: $item => {
            return $item.parent().hasClass("ui-option-selected");
        },
        fill: (type, answer) => {
            if (type === 4 || type === 2 || type === 6) {
                const x = GLOBAL.index - $(".ui-question-options ").length - 1;
                KindEditor.instances[x].html(answer);
            }
        }
    });
    WorkerJSPlus({
        name: "上海开放大学",
        match: location.pathname.includes("/study/assignment/preview.aspx") || location.pathname.includes("/study/assignment/continuation.aspx"),
        hook: () => {
            if (GLOBAL.finish || $("a:contains(已完成批阅)").length === 1) {
                iframeMsg("tip", {
                    type: "hidden",
                    tip: "本页面已做完，无需自动答题"
                });
                return true;
            }
        },
        root: ".e-q",
        elements: {
            question: ".e-q-q .ErichText",
            options: ".e-a-g li",
            $options: ".e-a-g li"
        },
        wrap: obj => {
            obj.type = getQuestionType(obj.$item.parent().parent().parent().find(".e-text").eq(0).text());
            obj.options = obj.options.map(i => {
                return formatString(i.replaceAll(/[a-zA-z]\)\s+/g, "").replaceAll(/^[a-z]\s+/g, "").replaceAll(/^[a-z]、\s+/g, "").trim());
            });
        },
        ignore_click: $item => {
            return $item.attr("class").includes("checked");
        }
    });
    WorkerJSPlus({
        name: "浙江考试",
        match: location.pathname === "/web-qz/moni/exam/exam_toExam.action",
        root: ".dt_tmcon",
        elements: {
            question: "div:eq(0) span:eq(1)",
            options: "div:eq(1) p",
            $options: "div:eq(1) p input"
        },
        ignore_click: $item => {
            return $item.prop("checked");
        },
        wrap: obj => {
            obj.type = getQuestionType(obj.$item.parents().find(".dt_rtitle1").eq(0).text());
            obj.options = obj.options.map(i => {
                return formatString(i.replaceAll(/[a-zA-z]\)\s+/g, "").replaceAll(/^[a-z]\s+/g, "").replaceAll(/^[a-z]、\s+/g, "").trim());
            });
            if (obj.type === 0) {
                obj.answer = [ JSON.parse($("#quesSSForm #userAnssStr_0").val()).rightAnswer ];
                uploadAnswer([ obj ]);
            }
        },
        finished: () => {
            return $(".page li input:eq(2)").attr("disabled") !== "disabled";
        },
        fillFinish: () => {
            $(".page li input:eq(2)").click();
        }
    });
    WorkerJSPlus({
        name: "在浙学考试",
        match: location.host === "www.zjooc.cn" && (location.pathname.includes("/homework/") || location.pathname.includes("/test/") || location.pathname.includes("/exam/")),
        hook: () => {
            function parseZaiZheXue(problems) {
                return problems.map(item => {
                    if (!item.rightAnswer) return undefined;
                    const subjectType = item.subjectType;
                    let type = -1;
                    const question = formatString(item.subjectName);
                    const answer = [];
                    const options = [];
                    if (subjectType === 1 || subjectType === 2) {
                        type = subjectType - 1;
                        for (let subjectOption of item.subjectOptions) {
                            const opt = formatString(subjectOption.optionContent);
                            options.push(opt);
                            if (item.rightAnswer.includes(subjectOption.optionHead)) {
                                answer.push(opt);
                            }
                        }
                    } else if (subjectType === 3) {
                        type = 3;
                        answer.push(item.rightAnswer === "yes" ? "正确" : "错误");
                    } else {
                        return undefined;
                    }
                    return {
                        question: question,
                        options: options,
                        type: type,
                        answer: answer
                    };
                }).filter(i => i && i.answer.length > 0);
            }
            if (!(location.pathname.includes("/homework/do") || location.pathname.includes("/test/do") || location.pathname.includes("/exam/do"))) {
                JSONParseHook(o => {
                    if (o.data && o.data.paperName && o.data.clazzIds && o.data.paperSubjectList) {
                        const data = parseZaiZheXue(o.data.paperSubjectList);
                        data.forEach(item => uploadQuestionBankCandidate(item, item.answer, "在浙学平台标准答案"));
                        console.log(data);
                    }
                });
                return true;
            }
        },
        root: ".questiono-item",
        elements: {
            question: "h6 .processing_img",
            options: ".questiono-main label .el-radio__label,.el-checkbox__label",
            $options: ".questiono-main label"
        },
        wrap: obj => {
            obj.type = getQuestionType(obj.$item.parent().prev().text());
            obj.options = obj.options.map(i => {
                return formatString(i.replaceAll(/[a-zA-z]\)\s+/g, "").replaceAll(/^[a-z]\s+/g, "").replaceAll(/^[a-z]、\s+/g, "").trim());
            });
        },
        ignore_click: $item => {
            return $item.hasClass("is-checked");
        }
    });
    WorkerJSPlus({
        name: "在浙学（测验/考试）",
        match: location.host === "www.zjooc.cn" && location.pathname.includes("/singleQuestion/do/"),
        intv: () => {
            return $(".settingsel-dialog").css("display") === "none";
        },
        root: ".question_content:first",
        elements: {
            question: ".question_title",
            options: ".question_content .radio_content div",
            $options: ".question_content  label"
        },
        wrap: obj => {
            obj.type = getQuestionType(obj.$item.parent().find(".question_title p").eq(0).text());
            obj.options = obj.options.map(i => {
                return formatString(i.replaceAll(/[a-zA-z]\)\s+/g, "").replaceAll(/^[a-z]\s+/g, "").replaceAll(/^[a-z]、\s+/g, "").replace(".", "").trim());
            });
        },
        ignore_click: $item => {
            return $item.hasClass("is-checked");
        },
        finished: () => {
            if ($(".question_btn .el-button:contains(下一题)").hasClass("is-disabled")) return false;
            $(".el-button:contains(下一题)").click();
            return true;
        }
    });
    WorkerJSPlus({
        name: "福建继续教育测验|作业",
        match: location.pathname === "/Web_Study/Student/Center/MyWorkOnView" || location.pathname === "/Web_Study/Student/Center/MyExamOnView",
        intv: () => {
            return $(".samllTopicNav").length;
        },
        root: ".topic-cont",
        elements: {
            question: "p",
            options: ".options li span",
            $options: ".options li"
        },
        wrap: obj => {
            obj.options = obj.options.map(i => {
                return i.replace(/选项[A-Za-z]/, "").trim();
            });
            obj.type = {
                1: 0,
                2: 1,
                3: 3,
                6: 4
            }[obj.$item.attr("itemtype")];
            if (obj.type === undefined) obj.type = 4;
        },
        ignore_click: $item => {
            return $item.hasClass("correct");
        },
        fill: (type, answer, $option) => {}
    });
    WorkerJSPlus({
        name: "湖南继续教育",
        match: () => {
            const pathMatch = location.pathname.includes("/User/Student/myhomework.aspx") || location.pathname.includes("/examing.aspx");
            const matchHostArr = [ "www.jwstudy.cn", "hdjt.wuxuekeji.com", "csjs.ynlhxy.com" ];
            return pathMatch && (matchHostArr.includes(location.host) || location.host.includes("ls365.net") || location.host.includes("ls365.com"));
        },
        root: ".exam_question",
        elements: {
            question: ".exam_question_title  div",
            options: ".question_select  .select_detail",
            $options: ".question_select li",
            type: ".exam_question_title div strong"
        },
        ignore_click: $item => {
            return $item.hasClass("cur");
        }
    });
    WorkerJSPlus({
        name: "德阳继续教育",
        match: location.href.includes("/dypx/OnlineExam/Exam.aspx"),
        root: "#divProblemArea",
        elements: {
            question: "#ulProblems li:first",
            options: "#ulProblems .answer",
            $options: "#ulProblems .answer input"
        },
        ignore_click: $item => {
            return $item.prop("checked");
        },
        wrap: obj => {
            if ($("#ulProblems .answer input").length < 3 && $("#ulProblems .answer input").eq(0).attr("type") === "radio") {
                obj.type = 3;
                obj.options = [ "正确", "错误" ];
            } else if ($("#ulProblems .answer input").length > 2 && $("#ulProblems .answer input").eq(0).attr("type") === "radio") {
                obj.type = 0;
            } else if ($("#ulProblems .answer input").length > 2 && $("#ulProblems .answer input").eq(0).attr("type") === "checkbox") {
                obj.type = 1;
            }
        },
        finished: () => {
            if ($(".dlg").length) return false;
            $("#divBtns input:eq(1)").click();
            return true;
        }
    });
    WorkerJSPlus({
        name: "淄博继续教育",
        match: location.pathname.includes("/practice/start"),
        root: ".header-left .trueorfalse .sub",
        elements: {
            question: ".mb10",
            options: ".options li",
            $options: ".options li"
        },
        ignore_click: $item => {
            return $item.hasClass("active");
        },
        wrap: obj => {
            obj.type = getQuestionType(obj.$item.parent().prev().text());
            obj.options = obj.options.map(i => {
                return formatString(i.replaceAll(/[a-zA-z]\)\s+/g, "").replaceAll(/^[a-z]\s+/g, "").replaceAll(/^[a-z]、\s+/g, "").trim());
            });
        }
    });
    WorkerJSPlus({
        name: "河北继续教育",
        match: location.pathname.includes("paperid"),
        root: ".examItem",
        elements: {
            question: ".examItemRight  .question",
            options: ".examItemRight  ul li span",
            $options: ".examItemRight  ul li"
        },
        ignore_click: $item => {
            return $item.hasClass("cur");
        },
        wrap: obj => {
            obj.type = getQuestionType(obj.$item.parent().find(".questTitle b").text());
        }
    });
    WorkerJSPlus({
        name: "保定继续教育",
        match: () => {
            const pathnameArr = [ "/cuggw/rs/olex_exam", "/hebic/rs/olex_exam", "/sjzkjxy/rs/olex_exam", "/hbfsh/rs/olex_exam", "/jxycu/rs/olex_exam", "/jlufe/rs/olex_exam", "/hbun/rs/olex_exam" ];
            return pathnameArr.includes(location.pathname);
        },
        intv: () => {
            return $(".paper_body").length;
        },
        root: ".item_li",
        elements: {
            question: ".item_title",
            options: "ul li label",
            $options: "ul li input"
        },
        ignore_click($item) {
            return $item.prop("checked");
        },
        wrap: obj => {
            if (obj.$options.length === 2) {
                obj.type = 3;
            } else if (obj.$options.length > 2 && obj.$options.eq(0).attr("type") === "radio") {
                obj.type = 0;
            } else if (obj.$options.length > 2 && obj.$options.eq(0).attr("type") !== "radio") {
                obj.type = 1;
            } else {
                obj.type = 4;
            }
        }
    });
    WorkerJSPlus({
        name: "唐山继续教育",
        match: location.pathname.includes("/exam/student/exam/"),
        intv: () => {
            return $(".ui-question-group").length;
        },
        root: ".ui-question-group .ui-question",
        elements: {
            question: ".ui-question-title .ui-question-content-wrapper",
            options: ".ui-question-options .ui-question-content-wrapper",
            $options: ".ui-question-options .ui-question-options-order"
        },
        wrap: obj => {
            obj.type = getQuestionType(obj.$item.parent().find("h2").text());
        }
    });
    WorkerJSPlus({
        name: "zzcjxy.hnzkw.org.cn",
        match: location.host.includes("hnzkw.org.cn"),
        intv: () => {
            return $(".answer").length;
        },
        hook: () => {
            JSONParseHook(o => {
                if (o.data && o.data.bookdatas) {
                    GLOBAL.json = parsehnzkwText(o.data.bookdatas);
                }
            });
        },
        root: ".examList",
        elements: {
            question: ".text",
            options: ".el-radio-group label,.el-checkbox-group label",
            $options: ".el-radio-group input,.el-checkbox-group input",
            type: ".status"
        },
        wrap: obj => {
            Object.assign(obj, GLOBAL.json[GLOBAL.index - 1]);
        },
        fill: (type, answer, $option) => {}
    });
    WorkerJSPlus({
        name: "问卷星考试",
        match: location.pathname.includes("/exam/ExamRd/Answer"),
        root: ".g-mn",
        elements: {
            question: ".m-question .tigan",
            options: ".question-block .xuanxiang",
            $options: ".question-block .xuanxiang",
            type: ".tixing"
        },
        ignore_click: ($item, type) => {
            if (type === 1) {
                return $item.parent().find(".icheckbox_square-green").hasClass("checked");
            } else {
                const isIgnore = $item.parent().find(".iradio_square-green").hasClass("checked");
                return isIgnore;
            }
        },
        wrap: obj => {
            if ($(".layui-layer-content").length) {
                iframeMsg("tip", {
                    type: "stop",
                    tip: "答题暂停，请自行通过验证"
                });
                GLOBAL.stop = true;
                return true;
            }
        },
        fillFinish: data => {
            // 增强版：多种情况下都尝试点击下一题
            const shouldClickNext = data.style === "warning-row" || 
                                   data.style === "success-row" ||
                                   $(".g-mn").parent().find(".iradio_square-green").hasClass("checked") || 
                                   data.type === 1;
            
            if (shouldClickNext) {
                // 使用多种选择器查找下一题按钮
                const nextBtnSelectors = [
                    '.u-btn-next:contains("下一题")',
                    '.btnNext',
                    '.next-btn',
                    'a:contains("下一题")',
                    'button:contains("下一题")'
                ];
                
                for (const selector of nextBtnSelectors) {
                    const $btn = $(selector);
                    if ($btn.length > 0 && $btn.is(':visible')) {
                        const btnEl = $btn.get(0);
                        // 使用增强版点击
                        if (typeof safeClick === 'function') {
                            safeClick(btnEl, { clickInner: false });
                        } else {
                            btnEl.click();
                        }
                        console.log('fillFinish: 点击下一题按钮', selector);
                        break;
                    }
                }
            }
        },
        finished: () => {
            return parseInt($(".num-dangqian:last").attr("qindex")) !== $(".num-item").length;
        }
    });

    // ══ 智慧树问答 / 平时分(pf*)══════════════════════════════════════════
    // 按当前官网 QaList / questionDetail / question-Dialog 的状态工作。
    // 发布通过原生按钮;发布次数不等于审核通过的互动问答分数。
    let pfTimer = null, pfBusy = false, pfAnswered = 0, pfRunning = false, pfHalted = false, pfEpoch = 0;
    let pfCancelAi = null, pfRunScope = "";
    let pfCardEl = null, pfCardHidden = false, pfGenBusy = false, pfManageEl = null;
    const pfSkipped = new Set(), pfHomes = new Map();
    const pfCardState = { answered: 0, cap: 15, remaining: 0, total: 0, status: "", countdown: 0, running: false };
    function pfLog(t, l) { logMsg("[问答] " + t, l); pfCardSet({ status: String(t).slice(0, 80) }); }
    function pfStop(reason) {
        pfEpoch++; pfRunning = false; pfHalted = true;
        if (pfCancelAi) pfCancelAi();
        pfLog(reason || "智慧树问答已停止", "warn");
    }
    function pfPage() {
        return location.hostname === "qah5.zhihuishu.com" && /\/qa\.html$/.test(location.pathname)
            && window.top === window.self;
    }
    function pfRoute() {
        const m = (location.hash || "").match(/^#\/web\/(home|questionDetail)\/([^/?#]+)(?:\/([^/?#]+))?\/?(?:\?([^#]*))?$/);
        if (!m || (m[1] === "questionDetail" && !m[3]) || (m[1] === "home" && m[3])) return null;
        const query = new URLSearchParams(m[4] || "");
        return { page: m[1], course: m[2], qid: m[3] || "", query: query, hash: location.hash };
    }
    function pfVue(el, match) {
        const seen = new Set();
        for (let node = el; node; node = node.parentElement) {
            let v; try { const raw = node.wrappedJSObject || node; v = raw.__vue__; } catch (e) {}
            for (let n = 0; v && n < 20 && !seen.has(v); n++, v = v.$parent) {
                seen.add(v); try { if (match(v)) return v; } catch (e) {}
            }
        }
        return null;
    }
    function pfView(route = pfRoute()) {
        if (!route) return null;
        const detail = route.page === "questionDetail";
        const vm = pfVue(document.querySelector(detail ? ".questionDetail-div" : ".qa-list-container"),
            v => detail ? !!v.questionInfo && "qid" in v : Array.isArray(v.questionList));
        if (!vm || String(vm.courseId) !== route.course || (detail && String(vm.qid) !== route.qid)) return null;
        if (detail && (!vm.questionInfo.questionId || String(vm.questionInfo.questionId) !== route.qid)) return null;
        if (route.query.has("recruitId") && String(vm.recruitId) !== route.query.get("recruitId")) return null;
        return vm;
    }
    function pfScope(route, vm) {
        const base = vm && vm.$store && vm.$store.state && vm.$store.state.baseData;
        return JSON.stringify([String(vm && vm.userId || base && base.userId || ""), route.course,
            route.query.get("recruitId") || String(vm && vm.recruitId || "")]);
    }
    function pfCap() { const n = Number(cxSet("qa_cap")); return Number.isFinite(n) ? Math.max(0, n) : 15; }
    function pfGapMs() {
        let a = Number(cxSet("qa_gap_min")), b = Number(cxSet("qa_gap_max"));
        if (!Number.isFinite(a)) a = 3; if (!Number.isFinite(b)) b = 8;
        return rand(Math.max(0, Math.min(a, b)), Math.max(0, Math.max(a, b))) * 1000;
    }
    function pfVisible(el) {
        if (!el || !el.isConnected || !el.getClientRects().length) return false;
        for (let n = el; n; n = n.parentElement) {
            const s = getComputedStyle(n);
            if (s.display === "none" || s.visibility === "hidden" || s.opacity === "0" || n.hidden) return false;
        }
        return true;
    }
    function pfBlocked() {
        const vm = pfView(), dialog = vm && vm.$refs && vm.$refs.digShow;
        return !!(vm && (vm.abnormalStatus || vm.bannedoVisible) || dialog && dialog.abnormalStatus)
            || Array.from(document.querySelectorAll(".yidun_modal,.yidun_popup,.bannedOv-dialog,.abnormal-dialog"))
                .some(pfVisible);
    }
    function pfActive(ctx) {
        return pfRunning && !pfHalted && cxSet("qa_do") && !GLOBAL.stop && pfPage()
            && ctx.epoch === pfEpoch && ctx.hash === location.hash;
    }
    function pfGuard(ctx) {
        if (!pfActive(ctx)) return false;
        if (pfBlocked()) { pfStop("网站要求验证或暂不允许回答,已暂停;处理后关闭再开启问答开关"); return false; }
        return true;
    }
    async function pfWait(ctx, probe, ms = 15000) {
        for (let left = ms; left >= 0; left -= 200) {
            if (!pfGuard(ctx)) return null;
            const value = probe(); if (value) return value;
            if (left > 0) await sleep(Math.min(200, left));
        }
        return null;
    }
    async function pfDelay(ctx, ms) {
        for (let left = ms; left > 0; left -= 200) {
            if (!pfGuard(ctx)) { pfCardSet({ countdown: 0 }); return false; }
            pfCardSet({ countdown: Math.ceil(left / 1000) });
            await sleep(Math.min(left, 200));
        }
        pfCardSet({ countdown: 0 });
        return pfGuard(ctx);
    }
    // 旧 qaData 用题目文字作键且把失败也写成已回答,不将其迁移为可靠完成记录。
    function pfRecord(ctx, value) {
        const all = GM_getValue("qaProgressV2", {});
        const data = all && typeof all === "object" && !Array.isArray(all) ? all : {};
        const rows = data[ctx.scope] && typeof data[ctx.scope] === "object" ? data[ctx.scope] : {};
        if (value === undefined) return rows[ctx.qid] || null;
        rows[ctx.qid] = Object.assign({ updated: Date.now() }, value);
        data[ctx.scope] = rows; GM_setValue("qaProgressV2", data);
    }
    function pfBackHome(ctx) {
        if (!pfGuard(ctx)) return;
        const query = new URLSearchParams(ctx.query); query.delete("aid");
        location.hash = pfHomes.get(ctx.scope) || "#/web/home/" + ctx.course + (query.toString() ? "?" + query : "");
    }
    function pfScanHome(ctx, vm) {
        const rows = Array.from(document.querySelectorAll(".qa-list-container .question-item"));
        if (rows.length !== vm.questionList.length) return null;
        let mismatch = false;
        const texts = {};
        const tasks = rows.map((row, index) => {
            const item = vm.questionList[index], sp = row.querySelector(".question-content span");
            const text = String(item.content || "").trim(), qid = String(item.questionId || "");
            if (String(item.contentShowStatus) !== "1") return null;
            if (!qid || !sp || String(sp.getAttribute("title") || sp.textContent).trim() !== text) { mismatch = true; return null; }
            texts[qid] = text;
            const record = pfRecord(Object.assign({}, ctx, { qid: qid }));
            const done = record && /^(published|answered)$/.test(record.status);
            const invalid = !done && pfIsInvalid(text);   // 无效问题(是不是/什么是…)直接跳过:不送 AI、不占发布配额
            const skip = invalid || item.createUser || String(item.contentShowStatus) !== "1" || pfSkipped.has(ctx.scope + ":" + qid);
            sp.dataset.ai6QaStatus = done ? "已确认回答" : invalid ? "无效问题·跳过" : skip ? "本轮跳过" : "待核对";
            sp.style.color = done ? "#198754" : skip ? "#888" : "";
            sp.style.textDecoration = invalid ? "line-through" : "";
            return { qid: qid, text: text, skip: skip || done };
        }).filter(Boolean);
        if (!mismatch) { pfCardSet({ total: tasks.length, remaining: tasks.filter(t => !t.skip).length }); pfSaveTexts(ctx.scope, texts); }
        return mismatch ? null : tasks;
    }
    async function pfHome(ctx, vm) {
        pfHomes.set(ctx.scope, ctx.hash);
        if (vm.loading && !await pfWait(ctx, () => !vm.loading)) {
            if (pfGuard(ctx)) pfStop("问题列表加载超时,请检查网站后重新开启"); return;
        }
        const tasks = await pfWait(ctx, () => pfScanHome(ctx, vm));
        if (!tasks) { if (pfGuard(ctx)) pfStop("问题列表尚未与课程数据对应,已暂停"); return; }
        const next = tasks.find(t => !t.skip);
        if (next) {
            if (!pfGuard(ctx)) return;
            pfLog("打开问题: " + next.text.slice(0, 36));
            // 官网 moveQaDetail 会 window.open,直接使用它的课节地址在当前标签页导航。
            const query = new URLSearchParams(ctx.query); query.delete("aid");
            location.hash = "#/web/questionDetail/" + ctx.course + "/" + encodeURIComponent(next.qid)
                + (query.toString() ? "?" + query : "");
            return;
        }
        if (vm.noMore || vm.isEmpty) { pfStop("当前列表已无待回答问题,本轮确认发布 " + pfAnswered + " 题;得分以网站审核结果为准"); return; }
        const wrap = vm.$refs && vm.$refs.listScroll && vm.$refs.listScroll.wrap;
        if (!wrap) { pfStop("未找到问题列表的加载入口,请手动下拉后重新开启"); return; }
        const count = vm.questionList.length, page = vm.pageIndex;
        if (!pfGuard(ctx)) return;
        const before = wrap.scrollTop;
        wrap.scrollTop = wrap.scrollHeight;
        // scrollTop 改变会触发原生 scroll;只有已经在底部时才补发,避免双重请求。
        if (wrap.scrollTop === before) wrap.dispatchEvent(new Event("scroll"));
        if (!await pfWait(ctx, () => !vm.loading && (vm.noMore || vm.pageIndex !== page || vm.questionList.length !== count))) {
            if (pfGuard(ctx)) pfStop("加载更多问题未成功,已暂停,避免反复请求");
        }
    }
    const PF_BAD = [/我是.{0,4}(AI|人工智能|语言模型|助手)/i, /没有实体/, /抱歉/, /无法回答/, /作为.{0,6}(AI|模型|助手)/i, /我不能/];
    // 无效问题预筛：平时分要的是有内容的开放式回答，"是不是/对不对/什么是X/X是什么"这类闭合/琐碎
    // 问题 AI 答不出好东西、还白占发布配额。命中就本轮跳过（不送 AI、不发布），参考脚本同款思路。
    const PF_INVALID = [/什么是.+/, /.+是什么$/, /.+是什么意思/, /.+的含义$/, /指什么/, /是不是/, /对不对/,
        /好不好/, /好吗$/, /对吗$/, /可以吗$/, /是否可以/, /有没有/, /能不能/, /是否应该/, /是否必须/,
        /是否需要/, /是否一定/, /是否合理/, /是否相同/, /是否不同/, /有意义吗/, /如何翻译/];
    function pfIsInvalid(text) { return PF_INVALID.some(r => r.test(String(text || ""))); }
    function pfClean(raw) {
        if (Array.isArray(raw)) raw = raw.map(p => p && p.text || "").join("");
        if (typeof raw !== "string") return "";
        return raw.replace(/<think>[\s\S]*?<\/think>/gi, "").replace(/<think>[\s\S]*$/gi, "")
            .replace(/```[^\n]*\n([\s\S]*?)```/g, "$1").replace(/[*#`>_~]/g, "").trim();
    }
    function pfValid(a) { return !!a && a.length >= 10 && a.length <= 1000 && !PF_BAD.some(r => r.test(a)); }
    function pfCallAi(question, ctx) {
        return new Promise(resolve => {
            const apiUrl = String(cxSet("ai_api_url") || "").trim(), apiKey = String(cxSet("ai_api_key") || "").trim();
            if (!apiUrl || !apiKey) { pfLog("请先在面板「AI 配置」填写接口和密钥", "error"); resolve(null); return; }
            let url; try { url = new URL(apiUrl); } catch (e) { pfLog("AI 接口地址无效", "error"); resolve(null); return; }
            if (!/^https?:$/.test(url.protocol)) { resolve(null); return; }
            const baidu = url.hostname === "aip.baidubce.com";
            if (baidu) url.searchParams.set("access_token", apiKey);
            const headers = { "Content-Type": "application/json" };
            if (!baidu) headers.Authorization = "Bearer " + apiKey;
            const body = { messages: [{ role: "user", content: "请回答这道课程开放式问题,用30至100字中文给出具体、准确的回答。只输出回答正文,不要Markdown或自我介绍。问题:" + question }], stream: false };
            if (!baidu) body.model = cxSet("ai_model");
            let request = null, retryTimer = null, watchdog = null, guardTimer = null, finished = false, tries = 0, attemptId = 0;
            function finish(value) {
                if (finished) return;
                finished = true; clearTimeout(retryTimer); clearTimeout(watchdog); clearInterval(guardTimer);
                if (pfCancelAi === cancel) pfCancelAi = null;
                if (request && request.abort) try { request.abort(); } catch (e) {}
                resolve(value);
            }
            function cancel() { finish(null); }
            function retry(reason) {
                if (!pfGuard(ctx)) { finish(null); return; }
                if (tries >= 3) { pfLog(reason + ",本题尚未发布", "error"); finish(null); return; }
                pfLog(reason + ",准备重试(" + tries + "/3)");
                retryTimer = setTimeout(attempt, 1500 * tries);
            }
            function attempt() {
                if (finished || !pfGuard(ctx)) { finish(null); return; }
                tries++; const id = ++attemptId; let settled = false;
                function receive(r, error) {
                    if (finished || settled || id !== attemptId) return;
                    settled = true; clearTimeout(watchdog);
                    const previous = request; request = null;
                    if (error && previous && previous.abort) try { previous.abort(); } catch (e) {}
                    if (!pfGuard(ctx)) { finish(null); return; }
                    if (error || r.status === 429 || r.status >= 500) { retry(error || "AI HTTP " + r.status); return; }
                    if (r.status !== 200) { pfLog("AI HTTP " + r.status + ",请检查接口配置", "error"); finish(null); return; }
                    let res; try { res = JSON.parse(r.responseText); } catch (e) { pfLog("AI 返回不是有效 JSON", "error"); finish(null); return; }
                    const answer = pfClean(res && res.choices && res.choices[0] && res.choices[0].message
                        ? res.choices[0].message.content : res && res.result);
                    if (!pfValid(answer)) { retry("AI 回答为空或无效"); return; }
                    finish(answer);
                }
                watchdog = setTimeout(() => receive(null, "AI 请求超时"), 121000);
                try {
                    request = GM_xmlhttpRequest({ method: "POST", url: baidu ? url.href : aiChatUrl(apiUrl), headers: headers,
                        data: JSON.stringify(body), timeout: 120000, onload: r => receive(r),
                        onerror: () => receive(null, "AI 请求失败"), ontimeout: () => receive(null, "AI 请求超时"),
                        onabort: () => { if (!finished && !settled) finish(null); } });
                } catch (e) { receive(null, "AI 请求无法启动"); }
            }
            pfCancelAi = cancel;
            guardTimer = setInterval(() => { if (!pfGuard(ctx)) finish(null); }, 200);
            attempt();
        });
    }
    // 进度卡(平时分):页面右下角浮层,显示本轮已发布/本页待答/当前状态/节流倒计时。参考脚本同款"看得见进度"。
    function pfCardEnsure() {
        if (pfCardHidden || typeof document === "undefined" || !document.body || !pfPage()) {
            if (pfCardEl) { pfCardEl.remove(); pfCardEl = null; }
            return null;
        }
        if (pfCardEl && !pfCardEl.isConnected) pfCardEl = null;
        if (pfCardEl) return pfCardEl;
        const card = document.createElement("div");
        card.id = "pf-card";
        card.style.cssText = "position:fixed;right:16px;bottom:16px;z-index:9999997;width:224px;" +
            "padding:12px 14px;border-radius:12px;background:#fff;color:#303133;box-sizing:border-box;" +
            "font:13px/1.6 -apple-system,'Segoe UI','Microsoft YaHei',sans-serif;" +
            "box-shadow:0 6px 24px rgba(0,0,0,.18);border:1px solid #ebeef5;";
        card.innerHTML = '<div style="font-weight:700;margin-bottom:6px;display:flex;justify-content:space-between;align-items:center;">' +
            '<span>平时分 · 自动问答</span><span id="pf-card-x" title="隐藏" style="cursor:pointer;color:#909399;font-size:16px;line-height:1;">×</span></div>' +
            '<div id="pf-card-count" style="margin:2px 0;"></div>' +
            '<div id="pf-card-page" style="margin:2px 0;color:#606266;"></div>' +
            '<div id="pf-card-status" style="margin-top:6px;color:#909399;font-size:12px;word-break:break-all;"></div>' +
            '<div id="pf-card-cd" style="margin-top:4px;color:#409eff;font-weight:600;display:none;"></div>' +
            '<div style="margin-top:8px;text-align:right;"><span id="pf-card-manage" style="cursor:pointer;color:#409eff;font-size:12px;">题目管理 ›</span></div>';
        document.body.appendChild(card);
        const x = card.querySelector("#pf-card-x");
        if (x) x.addEventListener("click", () => { pfCardHidden = true; if (pfCardEl) { pfCardEl.remove(); pfCardEl = null; } });
        const mg = card.querySelector("#pf-card-manage");
        if (mg) mg.addEventListener("click", pfManageOpen);
        pfCardEl = card;
        return card;
    }
    function pfCardRender() {
        const card = pfCardEnsure(); if (!card) return;
        const s = pfCardState, cap = s.cap > 0 ? String(s.cap) : "不限";
        card.querySelector("#pf-card-count").textContent = "本轮已发布 " + s.answered + " / " + cap;
        card.querySelector("#pf-card-page").textContent = s.total ?
            "本页待答 " + s.remaining + " · 共 " + s.total : (s.running ? "正在读取问题列表…" : "尚未读取列表");
        card.querySelector("#pf-card-status").textContent = s.status ?
            "状态:" + s.status : (s.running ? "运行中" : "未开启(在面板打开「刷智慧树问答(平时分)」开关)");
        const cd = card.querySelector("#pf-card-cd");
        if (s.countdown > 0) { cd.style.display = ""; cd.textContent = "下一步 " + s.countdown + " 秒"; }
        else cd.style.display = "none";
    }
    function pfCardSet(patch) { Object.assign(pfCardState, patch); try { pfCardRender(); } catch (e) {} }
    function pfCardTick() { pfCardSet({ running: pfRunning && !pfHalted && !!cxSet("qa_do"), cap: pfCap(), answered: pfAnswered }); }
    // 半自动"生成提问"(平时分需要既答题又提问):官网"提问"弹窗打开时注入按钮,点一下用 AI 生成一个
    // 与近期问题不重复的开放式问题填进去,由用户自己检查后手动发布(不自动发,所以是半自动)。
    // 题目管理弹窗:按 qaProgressV2(qid→状态)+ qaTextV2(qid→题干旁挂表)列出当前账号各课程的答题记录,
    // 可搜索、把某题"设为已答(不再做)/设为未答(删记录重做)"、清空整门课程。参考脚本有同类弹窗,但它用
    // "课程名→题文"当键且把失败也记成已答;这里改成按 qid 存、题干单独旁挂,不动既有答题记录结构。
    function pfEsc(s) {
        return String(s == null ? "" : s).replace(/[&<>"]/g, c => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" }[c]));
    }
    function pfStatusLabel(s) {
        return s === "published" || s === "answered" ? "已答" : s === "pending" ? "待核对" : s === "failed" ? "发布失败" : "未记录";
    }
    function pfTextStore() { const v = GM_getValue("qaTextV2", {}); return v && typeof v === "object" && !Array.isArray(v) ? v : {}; }
    function pfProgressStore() { const v = GM_getValue("qaProgressV2", {}); return v && typeof v === "object" && !Array.isArray(v) ? v : {}; }
    function pfSaveTexts(scope, map) {
        if (!scope || !map) return;
        const all = pfTextStore(), rows = all[scope] && typeof all[scope] === "object" ? all[scope] : {};
        let changed = false;
        for (const qid in map) if (map[qid] && rows[qid] !== map[qid]) { rows[qid] = map[qid]; changed = true; }
        if (changed) { all[scope] = rows; GM_setValue("qaTextV2", all); }
    }
    function pfManageData() {
        const prog = pfProgressStore(), texts = pfTextStore(), scopes = {};
        const add = s => scopes[s] || (scopes[s] = { scope: s, course: (() => { try { return JSON.parse(s)[1] || "?"; } catch (e) { return "?"; } })(), rows: {} });
        for (const s in prog) { add(s); for (const qid in prog[s]) scopes[s].rows[qid] = { qid: qid, status: prog[s][qid] && prog[s][qid].status || "", text: "" }; }
        for (const s in texts) { add(s); for (const qid in texts[s]) (scopes[s].rows[qid] || (scopes[s].rows[qid] = { qid: qid, status: "", text: "" })).text = texts[s][qid]; }
        return Object.values(scopes).map(x => ({ scope: x.scope, course: x.course, rows: Object.values(x.rows) }));
    }
    function pfManageSet(scope, qid, status) {
        const all = pfProgressStore(), rows = all[scope] && typeof all[scope] === "object" ? all[scope] : {};
        if (status) rows[qid] = { updated: Date.now(), status: status };
        else { delete rows[qid]; pfSkipped.delete(scope + ":" + qid); }
        all[scope] = rows; GM_setValue("qaProgressV2", all);
    }
    function pfManageClear(scope) {
        const prog = pfProgressStore(); delete prog[scope]; GM_setValue("qaProgressV2", prog);
        const texts = pfTextStore(); delete texts[scope]; GM_setValue("qaTextV2", texts);
    }
    function pfManageClose() { if (pfManageEl) { pfManageEl.remove(); pfManageEl = null; } }
    function pfManageOpen() {
        if (typeof document === "undefined" || !document.body) return;
        pfManageClose();
        const groups = pfManageData();
        const overlay = document.createElement("div");
        overlay.id = "pf-manage";
        overlay.style.cssText = "position:fixed;inset:0;z-index:9999998;background:rgba(0,0,0,.45);display:flex;align-items:center;justify-content:center;";
        const box = document.createElement("div");
        box.style.cssText = "width:min(680px,92vw);max-height:82vh;display:flex;flex-direction:column;background:#fff;" +
            "border-radius:12px;overflow:hidden;box-shadow:0 12px 40px rgba(0,0,0,.3);" +
            "font:13px/1.6 -apple-system,'Segoe UI','Microsoft YaHei',sans-serif;color:#303133;";
        box.innerHTML = '<div style="display:flex;justify-content:space-between;align-items:center;padding:14px 16px;background:#409eff;color:#fff;font-weight:700;">' +
            '<span>平时分 · 题目管理</span><span id="pf-manage-x" style="cursor:pointer;font-size:18px;line-height:1;">×</span></div>' +
            '<div style="display:flex;gap:8px;align-items:center;flex-wrap:wrap;padding:12px 16px;border-bottom:1px solid #ebeef5;">' +
            '<select id="pf-manage-scope" style="padding:6px 8px;border:1px solid #dcdfe6;border-radius:6px;"></select>' +
            '<input id="pf-manage-q" type="text" placeholder="搜索题目…" style="flex:1;min-width:120px;padding:6px 8px;border:1px solid #dcdfe6;border-radius:6px;">' +
            '<button id="pf-manage-clear" type="button" style="padding:6px 10px;border:none;border-radius:6px;background:#f56c6c;color:#fff;cursor:pointer;">清空本课程</button></div>' +
            '<div id="pf-manage-list" style="overflow:auto;padding:4px 16px 16px;"></div>';
        overlay.appendChild(box); document.body.appendChild(overlay); pfManageEl = overlay;
        const sel = box.querySelector("#pf-manage-scope"), q = box.querySelector("#pf-manage-q"), list = box.querySelector("#pf-manage-list");
        function fillScopes() { sel.innerHTML = ""; groups.forEach(g => { const o = document.createElement("option"); o.value = g.scope; o.textContent = "课程 " + g.course + " · " + g.rows.length + " 题"; sel.appendChild(o); }); }
        fillScopes();
        function current() { return groups.find(g => g.scope === sel.value) || groups[0]; }
        function render() {
            const g = current();
            if (!g) { list.innerHTML = '<div style="padding:24px;text-align:center;color:#909399;">还没有任何答题记录</div>'; return; }
            const kw = q.value.trim().toLowerCase();
            const rows = g.rows.filter(r => !kw || (r.text || "").toLowerCase().includes(kw));
            if (!rows.length) { list.innerHTML = '<div style="padding:24px;text-align:center;color:#909399;">无匹配题目</div>'; return; }
            list.innerHTML = rows.map(r => {
                const done = r.status === "published" || r.status === "answered";
                return '<div style="display:flex;gap:8px;align-items:center;padding:8px 0;border-bottom:1px solid #f0f0f0;">' +
                    '<div style="flex:1;word-break:break-all;">' + pfEsc(r.text || ("题目 #" + r.qid)) + '</div>' +
                    '<div style="width:72px;text-align:center;color:' + (done ? "#67c23a" : "#e6a23c") + ';">' + pfStatusLabel(r.status) + '</div>' +
                    '<button type="button" data-qid="' + pfEsc(r.qid) + '" data-act="done" style="padding:4px 8px;border:none;border-radius:6px;background:#67c23a;color:#fff;cursor:pointer;">设为已答</button>' +
                    '<button type="button" data-qid="' + pfEsc(r.qid) + '" data-act="undo" style="padding:4px 8px;border:none;border-radius:6px;background:#909399;color:#fff;cursor:pointer;">设为未答</button></div>';
            }).join("");
        }
        //PF_MANAGE_REST
        sel.addEventListener("change", render);
        q.addEventListener("input", render);
        box.querySelector("#pf-manage-x").addEventListener("click", pfManageClose);
        overlay.addEventListener("click", e => { if (e.target === overlay) pfManageClose(); });
        box.querySelector("#pf-manage-clear").addEventListener("click", () => {
            const g = current(); if (!g) return;
            pfManageClear(g.scope); groups.splice(groups.indexOf(g), 1); fillScopes(); render();
        });
        list.addEventListener("click", e => {
            const btn = e.target && e.target.closest ? e.target.closest("button[data-act]") : null;
            if (!btn) return;
            const g = current(); if (!g) return;
            const qid = btn.getAttribute("data-qid"), act = btn.getAttribute("data-act");
            const row = g.rows.find(r => r.qid === qid);
            if (act === "done") { pfManageSet(g.scope, qid, "published"); if (row) row.status = "published"; }
            else { pfManageSet(g.scope, qid, null); if (row) row.status = ""; }
            render();
        });
        render();
    }
    function pfAskDialog() {
        const dialogs = document.querySelectorAll('[role="dialog"][aria-label="提问"], .el-dialog[aria-label="提问"]');
        for (const d of dialogs) {
            if (!pfVisible(d)) continue;
            const input = d.querySelector(".dialog-question textarea") || d.querySelector("textarea");
            const bottom = d.querySelector(".dialog-bottom");
            const publish = bottom && bottom.querySelector(".up-btn");
            if (input && bottom && publish) return { dialog: d, input: input, bottom: bottom, publish: publish };
        }
        return null;
    }
    function pfAskButton() {
        try {
            const ask = pfAskDialog(); if (!ask || ask.bottom.querySelector("#pf-gen-q")) return;
            const btn = document.createElement("button");
            btn.id = "pf-gen-q"; btn.type = "button"; btn.textContent = "AI 生成问题";
            btn.style.cssText = "margin-right:12px;padding:8px 16px;border:none;border-radius:8px;" +
                "background:#409eff;color:#fff;font-weight:600;cursor:pointer;";
            btn.addEventListener("click", () => pfGenQuestion(ask));
            ask.bottom.insertBefore(btn, ask.publish);
        } catch (e) {}
    }
    function pfGenQuestion(ask) {
        if (pfGenBusy) return;
        const input = ask && ask.input;
        if (!input) { pfLog("未找到提问输入框", "error"); return; }
        const apiUrl = String(cxSet("ai_api_url") || "").trim(), apiKey = String(cxSet("ai_api_key") || "").trim();
        if (!apiUrl || !apiKey) { pfLog("请先在面板「AI 配置」填写接口和密钥", "error"); return; }
        let url; try { url = new URL(apiUrl); } catch (e) { pfLog("AI 接口地址无效", "error"); return; }
        if (!/^https?:$/.test(url.protocol)) return;
        const baidu = url.hostname === "aip.baidubce.com";
        if (baidu) url.searchParams.set("access_token", apiKey);
        const headers = { "Content-Type": "application/json" };
        if (!baidu) headers.Authorization = "Bearer " + apiKey;
        const courseEl = document.querySelector(".course-name");
        const course = courseEl ? courseEl.textContent.trim() : "本课程";
        const recent = Array.from(document.querySelectorAll(".question-content span"))
            .map(el => (el.getAttribute("title") || el.textContent || "").trim()).filter(Boolean).slice(0, 20);
        const prompt = "针对课程《" + course + "》提一个开放式讨论问题,30字以内,中文,句式新颖,不要以“如何/怎样”开头。" +
            "必须与下列已有问题完全不同、不重复句式:\n" + recent.map((t, i) => (i + 1) + ". " + t).join("\n") +
            "\n只输出问题本身一行,不要编号、引号、解释或 Markdown。";
        const body = { messages: [{ role: "user", content: prompt }], stream: false };
        if (!baidu) body.model = cxSet("ai_model");
        let tries = 0;
        function retry(reason) {
            if (tries >= 3) { done(null, reason); return; }
            pfLog(reason + ",重试(" + tries + "/3)"); setTimeout(attempt, 1500 * tries);
        }
        function done(question, err) {
            pfGenBusy = false;
            if (!question) { pfLog("提问生成失败:" + (err || "未知错误"), "error"); return; }
            const live = pfAskDialog(), target = live ? live.input : input;
            if (!target || !target.isConnected) { pfLog("提问窗口已关闭,未填入", "warn"); return; }
            const setter = Object.getOwnPropertyDescriptor(HTMLTextAreaElement.prototype, "value").set;
            setter.call(target, question); target.dispatchEvent(new Event("input", { bubbles: true }));
            pfLog("已生成提问,请检查后手动发布:" + question.slice(0, 30));
        }
        function attempt() {
            tries++;
            try {
                GM_xmlhttpRequest({ method: "POST", url: baidu ? url.href : aiChatUrl(apiUrl), headers: headers,
                    data: JSON.stringify(body), timeout: 90000,
                    onload: r => {
                        if (r.status === 429 || r.status >= 500) { retry("AI HTTP " + r.status); return; }
                        if (r.status !== 200) { done(null, "AI HTTP " + r.status); return; }
                        let res; try { res = JSON.parse(r.responseText); } catch (e) { done(null, "返回不是有效 JSON"); return; }
                        const raw = pfClean(res && res.choices && res.choices[0] && res.choices[0].message
                            ? res.choices[0].message.content : res && res.result);
                        const line = String(raw || "").split("\n").map(s => s.trim()).filter(Boolean)[0] || "";
                        if (!line) { retry("AI 返回为空"); return; }
                        done(line.slice(0, 100));
                    },
                    onerror: () => retry("AI 请求失败"), ontimeout: () => retry("AI 请求超时") });
            } catch (e) { done(null, "请求无法启动"); }
        }
        pfGenBusy = true; pfLog("正在生成提问…");
        attempt();
    }
    function pfAnswerDialog(ctx, vm) {
        const dv = vm.$refs && vm.$refs.digShow;
        if (!dv || !dv.dialogShow || String(dv.type) !== "1" || String(dv.questionId) !== ctx.qid) return null;
        const root = dv.$el && (dv.$el.wrappedJSObject || dv.$el);
        const input = root && root.querySelector(".dialog-question textarea");
        return input && pfVisible(input) ? { vm: dv, root: root, input: input } : null;
    }
    async function pfPublish(ctx, vm, dialog, answer) {
        const button = await pfWait(ctx, () => dialog.root.querySelector(".dialog-bottom .up-btn.set-btn"), 3000);
        if (!button || !pfVisible(button) || button.disabled || button.getAttribute("aria-disabled") === "true") {
            if (pfGuard(ctx)) pfStop("发布按钮不可用,答案已保留,本题未计数"); return false;
        }
        const messages = new Set(document.querySelectorAll(".el-message"));
        let success = false, failure = "";
        const inspect = () => {
            document.querySelectorAll(".el-message").forEach(el => {
                if (messages.has(el) || !pfVisible(el)) return;
                const text = el.textContent.trim();
                if (el.classList.contains("el-message--success") && /发布成功/.test(text)) success = true;
                if (el.classList.contains("el-message--error") || el.classList.contains("el-message--warning")) failure = text;
            });
        };
        const observer = new MutationObserver(inspect);
        observer.observe(document.body, { subtree: true, childList: true, characterData: true });
        try {
            if (!pfGuard(ctx) || pfAnswerDialog(ctx, vm)?.input !== dialog.input || dialog.input.value.trim() !== answer) {
                if (pfGuard(ctx)) pfStop("回答内容或弹窗已改变,已保留供手动处理"); return false;
            }
            pfRecord(ctx, { status: "pending", answer: answer });
            button.click();
            pfLog("已点击发布,等待网站确认");
            const result = await pfWait(ctx, () => {
                inspect();
                const own = Array.isArray(vm.replyList) && vm.replyList.some(a => a.isMyAnswer
                    && String(a.answerContent || "").trim() === answer);
                if ((success && !dialog.vm.dialogShow) || vm.questionInfo.isAnswer || own) return "ok";
                return failure ? "failed" : null;
            }, 15000);
            if (result !== "ok") {
                if (failure) pfRecord(ctx, { status: "failed", answer: answer });
                if (pfGuard(ctx)) pfStop(failure ? "网站未接受回答: " + failure : "发布结果未确认,保留待核对状态;请检查后再开启,不会重复发布");
                return false;
            }
            pfRecord(ctx, { status: "published" }); pfAnswered++;
            pfLog("网站已确认发布第 " + pfAnswered + " 题;是否计分以网站审核为准");
            return true;
        } finally { observer.disconnect(); }
    }
    async function pfAnswerDetail(ctx, vm) {
        const q = vm.questionInfo, text = String(q.content || "").trim();
        const record = pfRecord(ctx);
        const own = record && record.answer && Array.isArray(vm.replyList) && vm.replyList.some(a => a.isMyAnswer
            && String(a.answerContent || "").trim() === record.answer);
        if (q.isAnswer || own) {
            pfRecord(ctx, { status: record && record.status === "published" ? "published" : "answered" });
            pfLog("网站显示本题已经回答,跳过"); pfBackHome(ctx); return;
        }
        if (record && /^(published|answered)$/.test(record.status)) { pfBackHome(ctx); return; }
        if (record && record.status === "pending") { pfStop("本题有一次待核对的发布记录,请先在网站核对自己的回答,避免重复发布"); return; }
        if (!text || String(q.contentShowStatus) !== "1" || vm.questionDetial && vm.questionDetial.isMyQuestion || vm.isHistory == 1) {
            pfSkipped.add(ctx.scope + ":" + ctx.qid); pfLog("本题当前不可回答,本轮跳过"); pfBackHome(ctx); return;
        }
        if (pfAnswerDialog(ctx, vm)) { pfStop("回答窗口已打开,请先处理现有草稿后重新开启"); return; }
        const button = await pfWait(ctx, () => Array.from(document.querySelectorAll(".my-answer-btn"))
            .find(b => pfVisible(b) && b.textContent.trim() === "我来回答"), 10000);
        if (!button) { if (pfGuard(ctx)) pfStop("未找到可用的我来回答按钮,没有将本题标为完成"); return; }
        button.click();
        const dialog = await pfWait(ctx, () => pfAnswerDialog(ctx, vm), 10000);
        if (!dialog) { if (pfGuard(ctx)) pfStop("回答窗口未打开,请检查网站提示"); return; }
        if (dialog.input.value.trim()) { pfStop("回答框已有内容,请先手动处理草稿"); return; }
        pfLog("正在生成回答: " + text.slice(0, 36));
        const answer = await pfCallAi(text, ctx);
        if (!pfGuard(ctx)) return;
        if (!answer) { pfStop("本题未获得有效 AI 回答,已暂停,没有标记为完成"); return; }
        if (pfAnswerDialog(ctx, vm)?.input !== dialog.input || dialog.input.value.trim()) {
            pfStop("回答窗口或草稿已改变,已停止填入"); return;
        }
        const setter = Object.getOwnPropertyDescriptor(HTMLTextAreaElement.prototype, "value").set;
        setter.call(dialog.input, answer);
        dialog.input.dispatchEvent(new Event("input", { bubbles: true }));
        if (!await pfDelay(ctx, pfGapMs())) return;
        if (await pfPublish(ctx, vm, dialog, answer)) pfBackHome(ctx);
    }
    async function pfTick() {
        if (!pfPage()) return;
        if (!cxSet("qa_do") || GLOBAL.stop) {
            if (pfRunning) pfStop("已停止后续问答操作,当前草稿保留");
            pfHalted = false; return;
        }
        if (pfHalted || pfBusy) return;
        const route = pfRoute(); if (!route) return;
        if (!pfRunning) {
            pfRunning = true; pfEpoch++; pfAnswered = 0; pfSkipped.clear(); pfRunScope = "";
            pfLog("已启动,本轮最多 " + (pfCap() || "不限") + " 题,使用面板「AI 配置」");
        }
        const ctx = Object.assign({}, route, { epoch: pfEpoch });
        pfBusy = true;
        try {
            const vm = await pfWait(ctx, () => pfView(route));
            if (!vm) { if (pfGuard(ctx)) pfStop("课程或题目数据未加载完成,请检查页面后重新开启"); return; }
            ctx.scope = pfScope(route, vm);
            if (!ctx.query.has("recruitId") && vm.recruitId != null) ctx.query.set("recruitId", String(vm.recruitId));
            const role = vm.roleId == null ? vm.role : vm.roleId;
            if (!ctx.query.has("role") && role != null) ctx.query.set("role", String(role));
            if (pfRunScope && pfRunScope !== ctx.scope) { pfAnswered = 0; pfSkipped.clear(); }
            pfRunScope = ctx.scope;
            if (pfCap() > 0 && pfAnswered >= pfCap()) { pfStop("已达本轮发布上限 " + pfCap() + " 题,关闭再开启可开始下一轮"); return; }
            if (!pfGuard(ctx)) return;
            if (route.page === "home") await pfHome(ctx, vm);
            else await pfAnswerDetail(ctx, vm);
        } catch (e) {
            if (pfActive(ctx)) pfStop("问答流程异常: " + (e.message || e) + ",已保留现场");
        } finally { pfBusy = false; }
    }
    function pfBoot() {
        if (!pfPage()) return;
        let mounted = false;
        pfTimer = setInterval(() => {
            if (!document.body) return;
            if (!mounted) {
                mounted = true; GM_setValue("hide", false); showPanel("智慧树问答 · 平时分");
                if (!cxSet("qa_do")) pfLog("面板已就绪,开启「刷智慧树问答(平时分)」即可开始");
            }
            pfCardTick(); pfAskButton();
            pfTick();
        }, 1000);
        window.addEventListener("hashchange", () => {
            pfEpoch++;
            if (pfCancelAi) pfCancelAi();
        });
    }
    pfBoot();

})();