',
'
',
' ',
' ',
' ',
' ',
'
',
' ',
// ---- 共用筛选区 ----
'
'
].join('');
document.body.appendChild(viewEl);
// 批注轨道：脱离题目滚动容器，靠 JS 镜像其位置并跟随 scrollTop
var railEl = document.createElement('div');
railEl.id = 'gth-rail';
railEl.className = 'gth-rail';
railEl.hidden = true;
railEl.innerHTML = '';
document.body.appendChild(railEl);
var statusEl = $('#gth-status');
function setStatus(msg, kind) {
if (!msg) { statusEl.hidden = true; statusEl.textContent = ''; statusEl.className = ''; return; }
statusEl.hidden = false;
statusEl.textContent = msg;
statusEl.className = kind || '';
}
// 选中的行测模块名；空数组表示「全部模块」
var selectedModules = [];
var moduleList = [];
var SRC_NAME = { error: '错题本', favorite: '收藏夹', both: '错题+收藏' };
// 来源写进描述里：刷题进度 resumeKey 与组卷历史都靠这串字区分条件
function filterDesc(f) {
var pre = (SRC_NAME[f.src] || SRC_NAME.error) + ' · ';
if (f.mode === 'date') {
var d = DAY_RANGES.filter(function (x) { return x[0] === String(f.dayRange); })[0];
return pre + '日期：' + (d ? d[1] : f.dayRange);
}
var s = SUBJECT_NAME[f.subject] || f.subject;
if (f.subject === SUBJ_XC) {
var names = f.module_names || [];
s += names.length ? '（' + names.join('、') + '）' : '（全部模块）';
}
return pre + s;
}
function readFilter() {
var mode = $('#gth-mode').value;
var f = { mode: mode, src: $('#gth-src') ? $('#gth-src').value : 'error' };
if (mode === 'date') {
f.dayRange = $('#gth-day').value;
} else {
f.subject = Number($('#gth-subject').value);
if (f.subject === SUBJ_XC) f.module_names = selectedModules.slice();
}
return f;
}
function renderModChips() {
var box = $('#gth-mod-chips');
if (!box) return;
if (!moduleList.length) {
box.innerHTML = '',
' ',
' ',
' ',
' ',
' ',
' ',
' ',
' ',
' ',
' ',
'
',
' ',
'
',
// ---- 导出 ----
' ',
' 模块',
' ',
'
',
' ',
'
',
// ---- 重练 ----
' ',
' ',
' ',
' ',
'
',
' ',
' ',
' ',
' 首次导出会自动按当前来源与筛选载入题目',
'
',
' ',
' ',
' ',
' ',
'
',
' ',
'
',
// ---- 笔记 ----
' ',
' ',
' ',
' ',
' ',
'
',
' ',
' ',
' ',
' ',
'
',
' ',
' 最近组卷
',
' ',
' ',
'
',
' ',
' ',
' ' + icon('search') + '',
' ',
'
',
' ',
' ',
' ',
' ',
' ',
'
',
' ',
' ',
' ',
' ',
' ',
' ',
'
',
' 数据保存在本浏览器（localStorage）。清理浏览器数据或换设备前请先备份。
',
' ',
' 未获取到行测模块，可直接开始（将按全部错题处理）
';
return;
}
var allOn = selectedModules.length === 0;
var html = '' +
(allOn ? icon('checkCircle') : '') + '全部模块
';
html += moduleList.map(function (m, i) {
var on = selectedModules.indexOf(m.name) >= 0;
return '' +
(on ? icon('checkCircle') : '') + esc(m.name) + '
';
}).join('');
box.innerHTML = html;
$$('.gth-chip', box).forEach(function (chip) {
chip.addEventListener('click', function () {
var idx = Number(chip.dataset.idx);
if (idx < 0) { selectedModules = []; }
else {
var name = moduleList[idx].name;
var i = selectedModules.indexOf(name);
if (i >= 0) selectedModules.splice(i, 1);
else selectedModules.push(name);
}
invalidateLoaded();
renderModChips();
});
});
}
function syncFilterUI() {
var mode = $('#gth-mode').value;
$('.gth-date-only').hidden = mode !== 'date';
$('.gth-subject-only').hidden = mode !== 'subject';
var xc = mode === 'subject' && Number($('#gth-subject').value) === SUBJ_XC;
$('.gth-xc-only').hidden = !xc;
if (xc && !moduleList.length) loadModules();
renderPracticeHint();
}
function loadModules() {
return fetchSubcategory().then(function (list) {
moduleList = buildModuleOptions(list);
// 结构诊断：若模块 chips 仍非预期，可据此定位真实层级
console.log('[错题助手] 行测模块：', moduleList.map(function (m) { return m.name; }),
'｜原始 subcategory_list：', list.map(function (c) {
return c.name + ' × ' + (c.exampoint_list || []).length;
}).join(' / '));
renderModChips();
}).catch(function (e) {
setStatus('行测模块加载失败：' + e.message, 'err');
});
}
/* ---------- 入口：注入到左侧菜单「公安专业知识」下方，并作为原生视图切换 ---------- */
var viewOn = false;
// 助手生效的路由：错题页（#/error）与收藏页（#/shoucang）。两页模板同构，
// 左侧菜单同样是「日期 / 行政职业能力测试 / 公安专业知识」三个二级标签。
function routeKind() {
var h = location.hash || '';
if (h.indexOf('#/error') === 0) return 'error';
if (h.indexOf('#/shoucang') === 0) return 'collect';
return '';
}
function isErrorRoute() { return routeKind() === 'error'; }
function isCollectRoute() { return routeKind() === 'collect'; }
function isListRoute() { return !!routeKind(); }
// 切换助手视图：与站点原生右侧内容互斥显示，左菜单同步高亮。
// 可重复调用（AngularJS 重绘后需重新压住原生内容），因此不做「状态未变就返回」的短路。
function setView(on) {
viewOn = on;
var rc = $('.gongan2-container .right-content') || $('.right-content');
if (rc) {
// .inner-content 带 zero-flex-* 会设置 display，必须用 !important 类隐藏
$$('.second-menu, .inner-content', rc).forEach(function (el) { el.classList.toggle('gth-hide', on); });
if (viewEl.parentNode !== rc) rc.appendChild(viewEl);
}
viewEl.hidden = !on;
document.body.classList.toggle('gth-view-on', on);
var entry = $('.gth-menu-item');
if (entry) entry.classList.toggle('active', on);
if (on) {
renderHistory();
updateExportHint();
}
syncRail();
}
function injectMenuEntry() {
var menu = $('.gongan2-container .left-menu') || $('.left-menu');
var existing = $('.gth-menu-item');
var kind = routeKind();
// 非错题页 / 收藏页不注入入口，并清掉遗留的入口
if (!kind) {
if (existing && existing.parentNode) existing.parentNode.removeChild(existing);
return;
}
if (!menu) return;
var label = kind === 'collect' ? '收藏助手' : '错题助手';
var html = '' + icon('sparkles') + label + '
';
// 两页共用同一个入口按钮，路由切回来后标题要跟着换
if (existing && menu.contains(existing)) {
if (existing.dataset.kind !== kind) {
existing.dataset.kind = kind;
existing.innerHTML = html;
}
return;
}
var items = $$('.item', menu);
var anchor = null;
for (var i = 0; i < items.length; i++) {
if ((items[i].textContent || '').indexOf('公安专业知识') >= 0) { anchor = items[i]; break; }
}
if (!anchor) return;
var btn = document.createElement('div');
btn.className = 'item zero-flex-ver-center gth-menu-item';
btn.dataset.kind = kind;
btn.innerHTML = html;
btn.title = '笔记 / 导出 / 重练 / 掌握状态';
btn.addEventListener('click', function () { setView(!viewOn); });
if (anchor.nextSibling) menu.insertBefore(btn, anchor.nextSibling);
else menu.appendChild(btn);
if (viewOn) btn.classList.add('active');
}
// 点击原生二级标签（日期 / 行政职业能力测试 / 公安专业知识）时交还原生内容。
// 必须显式关闭：这些标签切换时不改变路由，仅靠 hashchange 感知不到；
// 而 viewOn 若保持为 true，观察器会持续重新隐藏原生内容，导致二级标签打不开。
document.addEventListener('click', function (e) {
if (!viewOn) return;
var it = e.target && e.target.closest && e.target.closest('.left-menu .item');
if (it && !it.classList.contains('gth-menu-item')) setView(false);
});
$$('.gth-tabs button').forEach(function (b) {
b.addEventListener('click', function () {
$$('.gth-tabs button').forEach(function (x) { x.classList.remove('on'); });
b.classList.add('on');
$$('[data-pane]').forEach(function (p) {
p.hidden = p.getAttribute('data-pane') !== b.dataset.tab;
});
if (b.dataset.tab === 'notes') renderNotesList();
if (b.dataset.tab === 'practice') { renderHistory(); renderPracticeHint(); }
});
});
// 筛选条件一变，之前缓存的题目就作废，下次导出 / 备份会按新条件重新拉
function invalidateLoaded() { loaded.filter = null; loaded.list = []; }
$('#gth-mode').addEventListener('change', function () { invalidateLoaded(); syncFilterUI(); });
$('#gth-subject').addEventListener('change', function () { invalidateLoaded(); syncFilterUI(); });
$('#gth-day').addEventListener('change', invalidateLoaded);
$('#gth-order').addEventListener('change', renderPracticeHint);
$('#gth-src').addEventListener('change', function () {
$('#gth-src').dataset.touched = '1';
invalidateLoaded();
updateExportHint();
});
// 默认来源跟随当前页面：错题页默认错题本、收藏页默认收藏夹（用户手动改过就不再自动切）
function syncSourceDefault() {
var el = $('#gth-src');
if (!el || el.dataset.touched) return;
var want = isCollectRoute() ? 'favorite' : 'error';
if (el.value !== want) { el.value = want; invalidateLoaded(); }
}
var loaded = { filter: null, list: [] };
// ---- 增量导出：本地按来源记录「已导出过的题目 id」，只导出从未导出过的题 ----
function currentSrc() { var el = $('#gth-src'); return (el && el.value) || 'error'; }
function exIds(src) { return (store.exported && store.exported[src]) || {}; }
function exAt(src) { return (store.exportAt && store.exportAt[src]) || 0; }
function newOnes(list) {
var ex = exIds(currentSrc());
return list.filter(function (q) { return !ex[q.id]; });
}
function markExported(list) {
var src = currentSrc();
if (!store.exported[src]) store.exported[src] = {};
list.forEach(function (q) { store.exported[src][q.id] = 1; });
store.exportAt[src] = Date.now();
saveStore();
updateExportHint();
}
function updateExportHint() {
var el = $('#gth-export-hint');
if (!el) return;
var src = currentSrc();
var n = Object.keys(exIds(src)).length;
el.textContent = n
? SRC_NAME[src] + ' 已导出 ' + n + ' 题 · 上次 ' + fmtAgo(exAt(src))
: SRC_NAME[src] + ' 尚未导出过任何题目';
}
var EXPORT_PREFIX = { error: '上岸村错题_', favorite: '上岸村收藏_', both: '上岸村错题收藏_' };
function runExport(list, tag) {
var fmt = $('#gth-fmt').value;
var name = (EXPORT_PREFIX[currentSrc()] || '上岸村错题_') + tag + '_' + stamp();
if (fmt === 'md') download(name + '.md', exportMarkdown(list));
else if (fmt === 'csv') download(name + '.csv', exportCsv(list));
else download(name + '.xlsx', exportXlsx(list));
}
// 首次导出时按当前筛选自动载入题目，省掉单独的「加载」按钮
function ensureLoaded() {
if (loaded.list.length) return Promise.resolve(loaded.list);
var f = readFilter();
setStatus('正在载入 ' + (SRC_NAME[f.src] || '题目') + '…');
return fetchByFilter(f).then(function (list) {
loaded.filter = f;
loaded.list = list;
$('#gth-count').textContent = SRC_NAME[f.src] + ' · 共 ' + list.length +
' 题 · 新增 ' + newOnes(list).length + ' 题';
updateExportHint();
return list;
});
}
$('#gth-export-new').addEventListener('click', function () {
ensureLoaded().then(function () {
var list = newOnes(loaded.list);
if (!list.length) { setStatus('没有新增题目（' + loaded.list.length + ' 题此前均已导出过）', ''); return; }
try {
runExport(list, '新增');
var src = currentSrc(), tag = SRC_NAME[src];
markExported(list);
setStatus('已导出新增 ' + list.length + ' 题（' + tag + ' 累计已导出 ' +
Object.keys(exIds(src)).length + ' 题）', 'ok');
} catch (e) { setStatus('导出失败：' + e.message, 'err'); }
}).catch(function (e) { setStatus('载入失败：' + e.message, 'err'); });
});
$('#gth-export-all').addEventListener('click', function () {
ensureLoaded().then(function () {
try {
runExport(loaded.list, '全量');
markExported(loaded.list);
setStatus('已导出全部 ' + loaded.list.length + ' 题', 'ok');
} catch (e) { setStatus('导出失败：' + e.message, 'err'); }
}).catch(function (e) { setStatus('载入失败：' + e.message, 'err'); });
});
$('#gth-reset-base').addEventListener('click', function () {
var src = currentSrc();
if (!Object.keys(exIds(src)).length) { setStatus(SRC_NAME[src] + ' 的增量基线本就是空的', ''); return; }
if (!confirm('重置后，下次「导出新增」会把' + SRC_NAME[src] + '当前全部题目视为新增。确定继续？')) return;
store.exported[src] = {};
store.exportAt[src] = 0;
saveStore();
updateExportHint();
setStatus(SRC_NAME[src] + ' 增量基线已重置', 'ok');
});
$('#gth-backup').addEventListener('click', function () {
download('上岸村错题_备份全部数据_' + stamp() + '.json', exportJson(loaded.list));
setStatus('已备份全部数据（' + (loaded.list.length || '0') + ' 题 + 本地笔记与掌握记录）', 'ok');
});
$('#gth-export-notes-md').addEventListener('click', function () {
var n = Object.keys(store.notes).length;
if (!n) { setStatus('暂无笔记可导出', 'err'); return; }
download('上岸村错题_笔记_' + stamp() + '.md', exportNotesMarkdown());
});
$('#gth-collect-open').addEventListener('click', function () {
openCollect(null); // 不限题：整理全部有划线或笔记的题目
});
$('#gth-restore').addEventListener('click', function () { $('#gth-file').click(); });
$('#gth-file').addEventListener('change', function (e) {
var file = e.target.files[0];
if (!file) return;
var fr = new FileReader();
fr.onload = function () {
try { setStatus(restoreJson(String(fr.result)), 'ok'); }
catch (err) { setStatus('恢复失败：' + err.message, 'err'); }
};
fr.readAsText(file);
e.target.value = '';
});
// 一键清空本脚本写入浏览器 localStorage 的全部数据
$('#gth-wipe').addEventListener('click', function () {
var nNote = Object.keys(store.notes).length;
var nStat = Object.keys(store.mastered).length;
var nExp = ['error', 'favorite', 'both'].reduce(function (a, k) {
return a + Object.keys(exIds(k)).length;
}, 0);
var nHis = (store.history || []).length;
var nRes = Object.keys(store.resume || {}).length;
if (!nNote && !nStat && !nExp && !nHis && !nRes) { setStatus('本地数据已为空', ''); return; }
if (!confirm(
'将删除本脚本存在此浏览器中的全部数据：\n' +
'· 笔记 ' + nNote + ' 条\n' +
'· 掌握记录 ' + nStat + ' 条\n' +
'· 答错次数统计\n' +
'· 增量导出记录 ' + nExp + ' 题\n' +
'· 组卷历史 ' + nHis + ' 条\n' +
'· 刷题进度 ' + nRes + ' 处\n\n' +
'此操作不可恢复。建议先点「备份全部数据」再清空。\n\n确定继续？'
)) return;
store.notes = {};
store.mastered = {};
store.wrongCount = {};
store.exported = { _v: 2, error: {}, favorite: {}, both: {} };
store.exportAt = { error: 0, favorite: 0, both: 0 };
store.history = [];
store.resume = {};
saveStore();
refreshBadges();
renderPracticeHint();
renderNotesList();
renderHistory();
updateExportHint();
setStatus('已清空本地数据', 'ok');
});
var notesSearchKey = '';
var gthNoteEditing = false; // 编辑器中途打开时，任何 renderNotesList 都跳过，避免被观察器/其他保存冲掉
var openNoteBox = null; // 当前打开的笔记编辑器（单编辑器约束，防止多个框叠加）
$('#gth-note-search').addEventListener('input', debounce(function (e) {
notesSearchKey = e.target.value;
renderNotesList();
}, 150));
function renderNotesList() {
if (gthNoteEditing) return; // 编辑中途不重绘，防止正在输入的 textarea 被冲掉
var listEl = $('#gth-notes-list');
var countEl = $('#gth-note-count');
if (!listEl) return;
// 笔记 tab 同时收纳「只有划线、还没写笔记」的题目，否则在答题页划的东西会无处可寻
var ids = Object.keys(store.notes);
Object.keys(store.highlights).forEach(function (id) {
if (getHighlights(id).length && ids.indexOf(id) < 0) ids.push(id);
});
var lastAct = function (id) {
var t = (store.notes[id] && store.notes[id].updated) || 0;
getHighlights(id).forEach(function (h) { if ((h.at || 0) > t) t = h.at; });
return t;
};
var q = notesSearchKey.trim().toLowerCase();
var filtered = ids.filter(function (id) {
if (!q) return true;
var n = store.notes[id] || {};
// 用户不认识题目 ID，搜索只针对笔记内容、题干快照与划线原文
if (((n.text || '') + ' ' + (n.snapshot || '')).toLowerCase().indexOf(q) >= 0) return true;
return getHighlights(id).some(function (h) {
return ((h.quote || '') + ' ' + (h.snap || '')).toLowerCase().indexOf(q) >= 0;
});
});
countEl.textContent = (q ? filtered.length + ' / ' : '') + ids.length + ' 题';
if (!ids.length) {
listEl.innerHTML = '' + icon('bookOpen') +
'
';
return;
}
if (!filtered.length) {
listEl.innerHTML = '暂无笔记与划线。在错题页或答题报告里选中解析文字即可划线。
' + icon('search') + '
';
return;
}
listEl.innerHTML = filtered.sort(function (a, b) {
return lastAct(b) - lastAct(a);
}).map(function (id) {
var n = store.notes[id] || {};
var hls = getHighlights(id);
var subj = SUBJECT_NAME[n.subject != null ? n.subject : (hls[0] && hls[0].subject)] || '未知科目';
var dyn = masteredLabel(id);
var dynCls = dyn === '已掌握' ? 'done' : (dyn.indexOf('待巩固') === 0 ? 'dyn' : '');
return '' +
'没有匹配的内容
' +
'
';
}).join('');
$$('.gth-note-item', listEl).forEach(function (item) {
var id = item.dataset.id;
$('[data-act="edit"]', item).addEventListener('click', function () { openNoteEditor(id, item); });
$('[data-act="del"]', item).addEventListener('click', function () {
var hasNote = !!store.notes[id], hasHl = countHighlights(id) > 0;
var what = hasNote ? (hasHl ? '笔记和划线' : '笔记') : '划线';
if (!confirm('确定删除这道题的' + what + '？此操作不可恢复。')) return;
delete store.notes[id];
delete store.highlights[id];
saveStore();
repaintHighlights();
refreshBadges();
renderNotesList();
});
$$('.gth-hlp-item .rm', item).forEach(function (rm) {
rm.addEventListener('click', function () {
hlRemove(id, Number(rm.parentNode.dataset.hl));
toast('已取消划线');
afterHlChange();
});
});
$$('.gth-hlp-item .t, .gth-hlp-item .n', item).forEach(function (node) {
node.addEventListener('click', function () {
openHlNote(id, Number(node.parentNode.dataset.hl), node.getBoundingClientRect());
});
});
});
}
// 关闭已打开的编辑器（还原被隐藏的笔记正文）。单编辑器约束：任何时候只保留一个编辑框。
function closeNoteEditor(s) {
if (!s) return;
s.box.remove();
if (s.textEl && s.textEl.isConnected) s.textEl.style.display = '';
gthNoteEditing = false;
}
function openNoteEditor(id, itemEl) {
// 同一道题再次点击「编辑」：聚焦已有框，不重复创建
if (openNoteBox && openNoteBox.itemEl === itemEl) {
var t0 = $('textarea', openNoteBox.box);
if (t0) t0.focus();
return;
}
closeNoteEditor(openNoteBox); // 切换到别的笔记前，先关掉上一个，避免叠加
blurEditors('panel'); // 同时收掉批注栏 / 划线的编辑器（焦点切换）
gthNoteEditing = true;
var n = store.notes[id] || { text: '' };
var box = document.createElement('div');
box.className = 'gth-note-edit';
box.innerHTML = '' +
'' + esc(subj) + '' +
'' + esc(dyn) + '' +
(hls.length ? '' + icon('highlighter') + esc(String(hls.length)) + ' 划' : '') +
'' + fmtAgo(lastAct(id)) + '' +
'' +
'' +
'' +
'
' +
((n.snapshot || (hls[0] && hls[0].snap)) ? '' + esc(n.snapshot || hls[0].snap) + '
' : '') +
'' +
esc(n.text || (hls.length ? '' : '（无笔记内容）')) + '
' +
(hls.length ? '' + hls.map(function (h, i) {
return '
' : '') +
'' +
'' +
'' +
'' + icon('x') + '
';
}).join('') + '' + esc(h.quote || '') + '
' +
(h.note ? '' + esc(h.note) + '
' : '') +
'' +
'' +
'
';
var ta = $('textarea', box);
ta.value = n.text || '';
var textEl = $('.gth-note-text', itemEl);
textEl.style.display = 'none';
itemEl.insertBefore(box, textEl.nextSibling);
ta.focus();
openNoteBox = { box: box, itemEl: itemEl, textEl: textEl };
$('[data-act="cancel"]', box).addEventListener('click', function () {
closeNoteEditor(openNoteBox);
openNoteBox = null;
});
$('[data-act="save"]', box).addEventListener('click', function () {
openNoteBox = null;
gthNoteEditing = false; // 解除重绘保护，否则 renderNotesList 会被拦截、列表不刷新
var newText = ta.value.trim();
if (newText) {
setNote(id, newText);
} else {
delete store.notes[id];
saveStore();
}
refreshBadges();
renderNotesList();
});
}
function getAngular() {
try { return window.angular || (typeof unsafeWindow !== 'undefined' && unsafeWindow.angular); }
catch (e) { return null; }
}
// ---- 笔记批注栏：吸附在题目右侧页边距，默认只读，点击可二次编辑 ----
var itemsById = {}; // 恢复 / 清空后据此重绘批注
function renderAside(el, item) {
var text = getNote(item.id);
var wasEditing = el.dataset.editing;
el.dataset.editing = '';
var head, body;
if (text) {
head = '' + icon('pencil') + '笔记' +
'
';
body = '' + esc(text) + '
';
} else {
head = '' + icon('pencil') + '笔记
';
body = '＋ 添加笔记
';
}
var html = head + body + asideHlHtml(item.id);
// 幂等：内容没变就一个字都不写。观察器每次唤醒都会走到这里，而重写 innerHTML
// 既会喂给 MutationObserver 形成 400ms 往复循环，又会把展开的划线清单、
// 正在编辑的批注框「一瞬间收回」。只在真的变了（或刚从编辑态退出）时才重绘
if (el.dataset.gthHtml === html && !wasEditing) return;
el.dataset.gthHtml = html;
var keepOpen = el.dataset.hlOpen === '1'; // 展开状态不在 HTML 里，重绘后要还原
el.innerHTML = html;
if (keepOpen) {
var hlList = $('.gth-aside-hl-list', el), hlT = $('.gth-aside-hl-t', el);
if (hlList) hlList.classList.add('on');
var caret = hlT && $('.caret', hlT);
if (caret) caret.textContent = '收起';
}
var ed = $('[data-act="edit"]', el), ad = $('[data-act="add"]', el);
if (ed) ed.addEventListener('click', function () { editAside(el, item); });
if (ad) ad.addEventListener('click', function () { editAside(el, item); });
bindAsideHl(el, item);
}
// 批注栏里的划线清单：内联展开，因为轨道容器 overflow:hidden 会裁掉浮层
function asideHlHtml(id) {
var list = getHighlights(id);
if (!list.length) return '';
var nr = list.filter(function (h) { return h.color === 'red'; }).length;
var ny = list.length - nr;
var desc = list.length + ' 条划线' + (ny && nr ? '（黄 ' + ny + ' · 红 ' + nr + '）' : '');
var rows = list.map(function (h, i) {
return '' +
'' +
'' +
'' + icon('x') + '
';
}).join('');
var lost = list.filter(function (h) { return h.lost; }).length;
return '' + esc(h.quote || '') + '
' +
(h.note ? '' + esc(h.note) + '
' : '') +
'' +
'
';
}
function bindAsideHl(el, item) {
var t = $('.gth-aside-hl-t', el), list = $('.gth-aside-hl-list', el);
if (!t || !list) return;
t.addEventListener('click', function () {
var on = list.classList.toggle('on');
el.dataset.hlOpen = on ? '1' : ''; // 记住展开状态，重绘后由 renderAside 还原
var c = $('.caret', t), want = on ? '收起' : '展开';
if (c && c.textContent !== want) c.textContent = want;
syncRail();
});
$$('.gth-hlp-item .t, .gth-hlp-item .n', list).forEach(function (node) {
node.addEventListener('click', function () {
openHlNote(item.id, Number(node.parentNode.dataset.hl), node.getBoundingClientRect());
});
});
$$('.gth-hlp-item .rm', list).forEach(function (rm) {
rm.addEventListener('click', function (e) {
e.stopPropagation();
hlRemove(item.id, Number(rm.parentNode.dataset.hl));
toast('已取消划线');
afterHlChange();
});
});
var cb = $('[data-act="collect"]', list);
if (cb) cb.addEventListener('click', function () { openCollect([String(item.id)]); });
}
function insertAtCursor(ta, text) {
var s = ta.selectionStart == null ? ta.value.length : ta.selectionStart;
var e = ta.selectionEnd == null ? ta.value.length : ta.selectionEnd;
ta.value = ta.value.slice(0, s) + text + ta.value.slice(e);
var p = s + text.length;
try { ta.setSelectionRange(p, p); } catch (err) { /* 某些输入类型不支持 */ }
ta.focus();
}
// 收起题目批注栏里打开的编辑器（还原成只读态）
function closeAsideEditor() {
$$('.gth-aside[data-editing="1"]').forEach(function (a) {
var it = itemsById[a.dataset.id];
if (it) renderAside(a, it);
else a.dataset.editing = '';
});
}
/* 焦点切换：三处笔记编辑器（题目批注栏 / 划线的批注浮层 / 笔记列表里的编辑框）
同一时刻只保留一个。否则划线的批注浮层会压住批注栏，两个 textarea 还会抢输入焦点。
keep 传本次要留下的那一个，其余全部收起 */
function blurEditors(keep) {
if (keep !== 'aside') closeAsideEditor();
if (keep !== 'hlnote') closeHlNote();
if (keep !== 'hlmenu') closeHlMenu();
if (keep !== 'panel') { closeNoteEditor(openNoteBox); openNoteBox = null; }
}
function editAside(el, item) {
blurEditors('aside');
el.dataset.editing = '1';
el.innerHTML = '' + icon('highlighter') + esc(desc) +
(lost ? ' · ' + lost + ' 条已失效' : '') +
'展开
' +
'' + rows +
'
' +
'
' +
'' + icon('pencil') + '编辑笔记
' +
'' +
'' +
'' +
'' +
'
' +
'';
var ta = $('textarea', el);
ta.value = getNote(item.id);
ta.focus();
var picker = $('[data-ins="1"]', el);
$('[data-act="ins"]', el).addEventListener('click', function () {
var list = getHighlights(item.id);
picker.classList.toggle('on');
if (!picker.classList.contains('on')) { picker.innerHTML = ''; return; }
if (!list.length) { picker.innerHTML = '本题还没有划线
'; return; }
picker.innerHTML = list.map(function (h, i) {
return '' +
'' +
'' + esc(h.quote || '') + '
';
}).join('');
$$('.gth-hlp-item .t', picker).forEach(function (node) {
node.addEventListener('click', function () {
var h = getHighlights(item.id)[Number(node.parentNode.dataset.hl)];
if (!h) return;
var pre = ta.value && !/\n$/.test(ta.value) ? '\n' : '';
insertAtCursor(ta, pre + '> ' + h.quote + '\n');
});
});
});
$('[data-act="save"]', el).addEventListener('click', function () {
setNote(item.id, ta.value.trim(), {
snapshot: stripHtml(item.content).slice(0, 240),
subject: item.content_type
});
renderAside(el, item);
refreshBadges();
renderNotesList();
});
$('[data-act="cancel"]', el).addEventListener('click', function () { renderAside(el, item); });
}
// 只在真的变了才写 DOM。徽章的文案/图标每次都是同一份，无脑重写会不停惊动
// MutationObserver（→ refreshPageUI → 又一轮重绘）
function setIf(el, prop, val) {
if (!el) return;
if (prop === 'hidden') { if (el.hidden !== !!val) el.hidden = !!val; return; }
if (el[prop] !== val) el[prop] = val;
}
function refreshBadges() {
$$('.gth-qbar').forEach(function (bar) {
var id = bar.dataset.id;
if (!id) return;
var badge = $('.gth-badge', bar);
var errEl = $('.gth-err', bar);
var rec = store.mastered[id];
var done = isMastered(id);
// 没做过也没标记过的题，未掌握没有信息量，弱化成幽灵样式；但它仍可点（点一下就标记已掌握）
setIf(badge, 'className', 'gth-badge' + (done ? ' done' : (!rec ? ' ghost' : (getNote(id) ? ' has' : ''))));
setIf(badge, 'textContent', done && rec.manual ? '已掌握 · 手动' : masteredLabel(id));
setIf(badge, 'title', done ? '点一下取消掌握标记' : '点一下标记为已掌握');
var n = errCountFor(id, bar.dataset.serverErr, bar.dataset.kind);
if (n) {
setIf(errEl, 'hidden', false);
var t = errTag(n);
setIf(errEl, 'className', t.cls);
setIf(errEl, 'innerHTML', t.html);
} else {
// 收藏页里从没做过的题：不谎报「答错 1 次」。错题本里的题必然错过一次，所以那边照旧从 1 起算
setIf(errEl, 'hidden', true);
setIf(errEl, 'className', 'gth-err');
setIf(errEl, 'innerHTML', '');
}
});
// 恢复 / 清空本地数据后同步刷新已渲染的批注
$$('.gth-aside').forEach(function (a) {
var it = itemsById[a.dataset.id];
if (it && !a.dataset.editing) renderAside(a, it);
});
}
function errCountFor(id, serverVal, kind) {
var s = Number(serverVal) || 0;
if (s) return s;
var local = (store.wrongCount && store.wrongCount[id]) || 0;
if (kind === 'collect') return local ? local + WRONG_BASE : 0;
return local + WRONG_BASE;
}
// 手动掌握开关：与自动判分共用同一份 mastered 记录，只是直接把连对次数顶到阈值。
// 标记时留 manual 记号，日后重练交卷仍按自动规则走（答错清零、答对递增）
function toggleMastery(id) {
var rec = store.mastered[id];
if (rec && rec.streak >= MASTER_STREAK) {
delete store.mastered[id];
toast('已取消掌握标记');
} else {
store.mastered[id] = { streak: MASTER_STREAK, updated: Date.now(), manual: 1 };
toast('已标记为已掌握');
}
saveStore();
refreshBadges();
renderNotesList();
}
// 操作条的「笔记」按钮：滚到这道题，并把右侧批注栏切到编辑态
function focusNote(item) {
if (viewOn) setView(false);
var id = String(item.id);
var aside = $('#gth-rail-in .gth-aside[data-id="' + id + '"]');
if (!aside) { toast('批注栏还没就绪，稍后再点一次'); return; }
var content = railContent(), node = qNodes[id];
if (node && node.isConnected) {
// 以「可见切片顶部」为基准滚动，错题页的内滚动盒与收藏页的页面滚动都适用
var base = railFrame ? railFrame.top : (content ? content.getBoundingClientRect().top : 0);
var delta = node.getBoundingClientRect().top - base - 8;
var sc = railScroller(content);
if (sc) sc.scrollTop += delta;
else window.scrollBy(0, delta);
}
aside.hidden = false;
editAside(aside, item);
var ta = aside.querySelector('textarea');
if (ta) { try { ta.focus(); } catch (e) {} }
syncRail();
toast('笔记栏在题目右侧');
}
/* ---------- 批注轨道：镜像题目滚动容器的位置，跟随其 scrollTop ---------- */
// 必须用子选择器：题目区里也有 .content（题干那一层），用后代选择器会在收藏页
// 误命中第一道题的题干。错题页的滚动层是 .inner-content 的直接子节点
var CONTENT_SEL = '.gongan2-container .right-content .inner-content > .content';
var qNodes = {}; // 题目 id -> ng-repeat 节点
// 错题页的列表包在 .content（height:600px;overflow:scroll）里，收藏页没有这层包裹，
// 所以滚动容器要动态解析，不能写死选择器
function railContent() {
return $(CONTENT_SEL) ||
$('.gongan2-container .right-content .inner-content') ||
$('.right-content .inner-content');
}
// 往上找真正在滚动的那个祖先；返回 null 表示列表不自己滚、跟着页面整体滚动
function railScroller(content) {
var el = content;
while (el && el !== document.body && el !== document.documentElement) {
if (el.scrollHeight - el.clientHeight > 4) {
var ov = '';
try { ov = getComputedStyle(el).overflowY; } catch (e) {}
if (ov === 'auto' || ov === 'scroll' || ov === 'overlay') return el;
}
el = el.parentElement;
}
return null;
}
/* 轨道的坐标模型：不猜「谁在滚」，只算「列表当前露出哪一段视口」。
错题页的列表在 600px 的内部滚动盒里，收藏页没有那层包裹、跟着页面滚，
两种情况下用同一套算法都能对齐：
可见切片 top = max(列表盒子 top, 0)，bottom = min(盒子 bottom, 视口高)
批注框 top = 题目矩形 top − 可见切片 top */
var railFrame = null; // {rect, top, height}
var railRaf = 0;
function railVisible() {
var content = railContent();
if (!content) return null;
var r = content.getBoundingClientRect();
if (!r.height) return null; // 切到助手视图时原生内容被隐藏
var top = Math.max(r.top, 0);
var bottom = Math.min(r.bottom, window.innerHeight);
if (bottom - top < 40) return null; // 只剩一条缝时不摆东西
return { rect: r, top: top, height: bottom - top };
}
// 只读布局 + 写 top，按 rAF 节流，可以挂在 scroll 上
function placeRailItems() {
var inner = $('#gth-rail-in');
if (railEl.hidden || !railFrame || !inner) return;
$$('.gth-aside', inner).forEach(function (a) {
var node = qNodes[a.dataset.id];
if (node && node.isConnected) {
a.hidden = false;
a.style.top = Math.round(node.getBoundingClientRect().top - railFrame.top) + 'px';
} else {
a.hidden = true; // 题目已从列表移除 / 节点还没就绪，别在轨道里留无主的「鬼影」框
}
});
syncBalloons();
}
function onRailScroll() {
if (railEl.hidden || railRaf) return;
railRaf = requestAnimationFrame(function () {
railRaf = 0;
var f = railVisible();
if (!f) { railEl.hidden = true; railFrame = null; return; }
if (!railFrame || f.top !== railFrame.top || f.height !== railFrame.height) {
// 页面整体滚动时列表盒子的 top 会变，轨道几何要跟着走
railEl.style.top = Math.round(f.top) + 'px';
railEl.style.height = Math.round(f.height) + 'px';
}
railFrame = f;
placeRailItems();
});
}
function syncRail() {
var rail = railEl, inner = $('#gth-rail-in');
if (!isListRoute() || !inner) { rail.hidden = true; railFrame = null; return; }
// 滚动可能发生在内部容器（错题页的 .content），也可能发生在页面本身（收藏页）。
// capture 阶段的监听能同时收到两者，不必再猜哪个元素在滚
if (!document.body.dataset.gthRailScroll) {
document.body.dataset.gthRailScroll = '1';
document.addEventListener('scroll', onRailScroll, { capture: true, passive: true });
}
var content = railContent();
if (content && !content.dataset.gthRailLoad) {
content.dataset.gthRailLoad = '1';
content.addEventListener('load', syncRail, true); // 图片加载后行高变化需重新对齐
}
var f = railVisible();
if (!f) { rail.hidden = true; railFrame = null; return; }
railFrame = f;
rail.hidden = false;
rail.style.left = Math.round(f.rect.right + 24) + 'px';
rail.style.top = Math.round(f.top) + 'px';
rail.style.height = Math.round(f.height) + 'px';
inner.style.transform = 'none'; // 老版本用 translate 跟随滚动，现在改按可视区算绝对坐标
placeRailItems();
}
function injectListUI() {
if (!isListRoute()) return;
var ang = getAngular();
if (!ang) return;
var railInner = $('#gth-rail-in');
if (!railInner) return;
$$('[ng-repeat="item in subjectList"]').forEach(function (node) {
if (node.dataset.gth) return;
var item = null;
try { item = ang.element(node).scope().item; } catch (e) { return; }
if (!item || !item.id) return;
// 防同一道题在轨道里出现多个批注栏：
// 节点被站点重渲染替换（带图题目常见，图片加载/布局变化触发 digest）时，旧的 aside 会残留在轨道里。
// 用 item.id 作为稳定键去重。
railInner.querySelectorAll('.gth-aside[data-id="' + item.id + '"]').forEach(function (a) { a.remove(); });
node.dataset.gth = '1';
// 划线的定位根：paintRoot 靠它把题目 id 和 DOM 子树对上
node.setAttribute('data-gth-qid', item.id);
itemsById[item.id] = item;
qNodes[item.id] = node;
if (!probed) { probed = true; probeFields([item]); }
var bar = document.createElement('div');
bar.className = 'gth-qbar';
bar.dataset.id = item.id;
bar.dataset.kind = routeKind();
bar.dataset.serverErr = serverErrCount(item);
// 节点被站点重渲染替换时，旧的 qbar 还挂在原节点上。重新挂之前先清掉同题旧 qbar，避免重复
$$('.gth-qbar[data-id="' + item.id + '"]').forEach(function (b) { b.remove(); });
bar.innerHTML =
'' +
'' +
'' +
'' +
'';
bar.querySelector('.gth-qbar-copy').addEventListener('click', function (e) {
e.stopPropagation(); // 防止站点原有点击展开/收起等行为被误触
var btn = e.currentTarget;
var it = itemsById[btn.dataset.id];
if (!it) return;
var ok = copyText(copyQuestion(it));
btn.classList.add('copied');
btn.innerHTML = (ok ? icon('check') : icon('xCircle')) + (ok ? '已复制' : '复制失败');
setTimeout(function () {
btn.classList.remove('copied');
btn.innerHTML = icon('copy') + '复制题目';
}, 1200);
});
// 掌握状态：手动开关。站点的掌握度只由重练交卷驱动，而收藏页根本没有交卷场景，
// 没有手动入口的话两处徽标就只是装饰，收藏题永远停在「未掌握」
bar.querySelector('.gth-badge').addEventListener('click', function (e) {
e.stopPropagation();
toggleMastery(item.id);
});
// 笔记入口：滚到这道题，并直接展开右侧批注栏的编辑器
bar.querySelector('.gth-qbar-note').addEventListener('click', function (e) {
e.stopPropagation();
focusNote(item);
});
var aside = document.createElement('div');
aside.className = 'gth-aside';
aside.dataset.id = item.id;
renderAside(aside, item);
// 操作条挂在 ng-repeat 节点的第一个子节点位置，也就是 .question-box（材料 + 题干）之前。
// 之前是 appendChild，落在解析之后，等于「整道题看完才看见控件」
node.insertBefore(bar, node.firstChild);
railInner.appendChild(aside);
});
refreshBadges();
}
// 错题列表与左侧菜单均由 AngularJS 异步渲染，用观察器在重绘后补回
var refreshPageUI = debounce(function () {
injectListUI();
injectMenuEntry();
// 原生内容被 AngularJS 重绘后会丢掉隐藏类，需要重新应用
if (viewOn) setView(true);
syncRail();
repaintHighlights(); // 站点重绘后按锚点把划线重新落笔（自带幂等签名，不会往复触发）
syncBalloons(); // 划线重画后，右侧页边距的批注气球要跟着重新对位
}, 400);
new MutationObserver(refreshPageUI).observe(document.body, {
childList: true, subtree: true
});
window.addEventListener('resize', syncRail);
injectListUI();
injectMenuEntry();
syncRail();
/* ================= 划线交互：选中即划 ================= */
var hlBar = document.createElement('div');
hlBar.id = 'gth-hlbar';
hlBar.innerHTML =
'' +
'' +
'' +
'' +
'';
document.body.appendChild(hlBar);
var pendingSel = null;
var toastTimer = null;
function toast(msg) {
var t = $('#gth-toast');
if (!t) { t = document.createElement('div'); t.id = 'gth-toast'; document.body.appendChild(t); }
t.textContent = msg;
t.classList.add('on');
clearTimeout(toastTimer);
toastTimer = setTimeout(function () { t.classList.remove('on'); }, 1600);
}
// 这些区域不允许划线：插件自己的 UI、输入控件、答题页的导航与答题卡
var HL_BLOCK_SEL = '#gth-hlbar,#gth-collect,#gth-toast,#gth-rail,.gth-aside,.gth-view,' +
'#gth-quiz .gthq-top,#gth-quiz .gthq-sheet,#gth-quiz .gthq-nav,textarea,input,select';
function contextOfRange(range) {
var node = range.commonAncestorContainer;
if (node.nodeType === 3) node = node.parentNode;
var el = node && node.nodeType === 1 ? node : null;
if (el && el.closest && el.closest(HL_BLOCK_SEL)) return null;
while (el) {
if (el.getAttribute && el.getAttribute('data-gth-qid')) {
return { root: el, qid: el.getAttribute('data-gth-qid') };
}
el = el.parentElement;
}
return null;
}
// 选区必须在这里就被抓成快照：一点工具条按钮，浏览器选区就没了
function captureSelection() {
var sel = window.getSelection();
if (!sel || sel.isCollapsed || !sel.rangeCount) return null;
var range = sel.getRangeAt(0);
var quote = String(sel.toString());
if (!quote.trim()) return null;
var ctx = contextOfRange(range);
if (!ctx) return null;
var start = offsetInRoot(ctx.root, range.startContainer, range.startOffset);
if (start < 0) return null;
var end = offsetInRoot(ctx.root, range.endContainer, range.endOffset);
if (end < 0 || end <= start) return null;
return { quote: quote, start: start, end: end, ctx: ctx, rect: range.getBoundingClientRect() };
}
// 取（必要时先建）选区对应的那条划线。已有一条完整覆盖选区的就复用，不重复建
function ensureHl(p, color) {
var hits = hlOverlap(p.ctx.root, p.start, p.end, null);
if (hits.length === 1) return { qid: p.ctx.qid, idx: hits[0], reused: true };
var rec = addHighlight(p.ctx.qid, p.quote, p.start, color || 'yellow');
if (!rec) return null;
var list = store.highlights[p.ctx.qid] || [];
return { qid: p.ctx.qid, idx: list.length - 1, reused: false };
}
/* Word 式切换：对选区再点一次「同色」= 取消这段的划线；点别的颜色 = 改色 */
function toggleHl(p, color) {
var same = hlOverlap(p.ctx.root, p.start, p.end, color);
if (same.length) {
same.sort(function (a, b) { return b - a; }).forEach(function (i) { hlRemove(p.ctx.qid, i); });
return { removed: same.length };
}
var other = hlOverlap(p.ctx.root, p.start, p.end, null);
if (other.length === 1) { setHighlightColor(p.ctx.qid, other[0], color); return { recolored: 1 }; }
var rec = addHighlight(p.ctx.qid, p.quote, p.start, color);
return rec ? { added: 1 } : null;
}
function hideBar() { hlBar.classList.remove('on'); pendingSel = null; }
function showBar() {
var p = captureSelection();
pendingSel = p;
if (!p) { hlBar.classList.remove('on'); return; }
hlBar.classList.add('on');
var r = p.rect, bw = hlBar.offsetWidth, bh = hlBar.offsetHeight;
var top = r.top - bh - 8;
if (top < 8) top = r.bottom + 8; // 顶部放不下就翻到选区下方
var left = Math.max(8, Math.min(r.left + r.width / 2 - bw / 2, window.innerWidth - bw - 8));
hlBar.style.left = left + 'px';
hlBar.style.top = top + 'px';
}
hlBar.addEventListener('mousedown', function (e) { e.preventDefault(); }); // 保住选区
hlBar.addEventListener('click', function (e) {
var btn = e.target.closest && e.target.closest('button');
if (!btn || !pendingSel) { hideBar(); return; }
var p = pendingSel;
if (btn.dataset.act === 'copy') { copyText(p.quote); toast('已复制'); hideBar(); return; }
if (btn.dataset.act === 'note') {
var h = ensureHl(p, 'yellow');
hideBar();
if (!h) { toast('批注失败：没能在题目里定位到这段文字'); return; }
openHlNote(h.qid, h.idx, p.rect);
return;
}
var color = btn.dataset.c === 'red' ? 'red' : 'yellow';
var r = toggleHl(p, color);
hideBar();
if (!r) { toast('划线失败：没能在题目里定位到这段文字'); return; }
if (r.removed) toast('已取消 ' + r.removed + ' 条划线');
else if (r.recolored) toast('已改为' + HL_LABEL[color]);
else toast('已标为' + HL_LABEL[color] + (r && r.added ? '' : ''));
afterHlChange();
});
document.addEventListener('mouseup', function (e) {
if (e.target && e.target.closest && e.target.closest('#gth-hlbar')) return;
setTimeout(showBar, 10);
});
document.addEventListener('mousedown', function (e) {
if (e.target && e.target.closest && e.target.closest('#gth-hlbar')) return;
hideBar();
});
window.addEventListener('scroll', hideBar, true);
window.addEventListener('resize', hideBar);
document.addEventListener('keydown', function (e) {
if (e.key === 'Escape') { hideBar(); closeHlMenu(); closeHlNote(); closeCollect(); return; }
if (!e.altKey || !/^[123]$/.test(e.key)) return;
var p = captureSelection();
if (!p) return;
e.preventDefault();
if (e.key === '3') {
var h = ensureHl(p, 'yellow');
if (!h) { toast('批注失败：没能在题目里定位到这段文字'); return; }
openHlNote(h.qid, h.idx, p.rect);
return;
}
var color = e.key === '2' ? 'red' : 'yellow';
var r = toggleHl(p, color);
hideBar();
if (!r) { toast('划线失败：没能在题目里定位到这段文字'); return; }
toast(r.removed ? '已取消 ' + r.removed + ' 条划线'
: (r.recolored ? '已改为' + HL_LABEL[color] : '已标为' + HL_LABEL[color]));
afterHlChange();
});
/* 点已划线的文字（无选区）→ 弹出这条划线的菜单：批注 / 改色 / 取消划线 */
document.addEventListener('mouseup', function (e) {
var sel = window.getSelection();
if (sel && !sel.isCollapsed) return; // 有选区时归工具条处理
var mk = e.target && e.target.closest && e.target.closest('mark.gth-hl');
if (!mk) { closeHlMenu(); return; }
var root = mk.closest('[data-gth-qid]');
if (!root || mk.dataset.gthI == null) return;
openHlMenu(root.getAttribute('data-gth-qid'), Number(mk.dataset.gthI), mk.getBoundingClientRect());
});
/* ================= 划线的批注与取消（Word 式） ================= */
var hlMenuEl = null, hlMenuAnchor = null;
var hlNoteEl = null, hlNoteCtx = null;
function placeFloating(el, rect) {
el.hidden = false;
var bw = el.offsetWidth, bh = el.offsetHeight;
var top = rect.bottom + 8;
if (top + bh > window.innerHeight - 8) top = Math.max(8, rect.top - bh - 8);
var left = Math.max(8, Math.min(rect.left || 0, window.innerWidth - bw - 8));
el.style.left = left + 'px';
el.style.top = top + 'px';
}
function flashMark(qid, idx) {
var root = $('[data-gth-qid="' + String(qid).replace(/"/g, '') + '"]');
if (!root) return;
$$('mark.gth-hl[data-gth-i="' + idx + '"]', root).forEach(function (m) {
m.classList.add('gth-hl-flash');
setTimeout(function () { m.classList.remove('gth-hl-flash'); }, 900);
});
}
function buildHlMenu() {
hlMenuEl = document.createElement('div');
hlMenuEl.id = 'gth-hlmenu';
hlMenuEl.hidden = true;
document.body.appendChild(hlMenuEl);
hlMenuEl.addEventListener('mousedown', function (e) { e.preventDefault(); });
hlMenuEl.addEventListener('click', function (e) {
var btn = e.target.closest && e.target.closest('button');
if (!btn || !hlMenuEl.dataset.q) return;
var qid = hlMenuEl.dataset.q, idx = Number(hlMenuEl.dataset.i);
var rect = hlMenuAnchor || { left: 0, top: 0, bottom: 0 };
if (btn.dataset.act === 'note') { closeHlMenu(); openHlNote(qid, idx, rect); return; }
if (btn.dataset.act === 'del') {
closeHlMenu();
hlRemove(qid, idx);
toast('已取消划线');
afterHlChange();
return;
}
if (btn.dataset.c) {
setHighlightColor(qid, idx, btn.dataset.c);
closeHlMenu();
toast('已改为' + HL_LABEL[btn.dataset.c]);
afterHlChange();
}
});
}
function openHlMenu(qid, idx, rect) {
var rec = (store.highlights[qid] || [])[idx];
if (!rec) return;
blurEditors('hlmenu'); // 焦点切换：先收起别的编辑器
if (!hlMenuEl) buildHlMenu();
hlMenuAnchor = rect;
hlMenuEl.dataset.q = qid;
hlMenuEl.dataset.i = String(idx);
var txt = rec.quote || '';
if (txt.length > 26) txt = txt.slice(0, 26) + '…';
hlMenuEl.innerHTML =
'' +
esc(txt) + '
' +
'' +
'' +
'' +
'' +
'
' +
'';
placeFloating(hlMenuEl, rect);
flashMark(qid, idx);
}
function closeHlMenu() { if (hlMenuEl) hlMenuEl.hidden = true; }
function buildHlNote() {
hlNoteEl = document.createElement('div');
hlNoteEl.id = 'gth-hlnote';
hlNoteEl.hidden = true;
hlNoteEl.innerHTML = [
'',
'
'
].join('');
document.body.appendChild(hlNoteEl);
hlNoteEl.addEventListener('click', function (e) {
var btn = e.target.closest && e.target.closest('button[data-act]');
if (!btn || !hlNoteCtx) return;
var act = btn.dataset.act;
if (act === 'close' || act === 'cancel') { closeHlNote(); return; }
var ta = $('textarea', hlNoteEl);
if (act === 'save') {
hlNoteSet(hlNoteCtx.qid, hlNoteCtx.idx, ta ? ta.value.trim() : '');
closeHlNote();
toast('批注已保存');
afterHlChange();
return;
}
if (act === 'del-note') {
hlNoteSet(hlNoteCtx.qid, hlNoteCtx.idx, '');
closeHlNote();
toast('批注已删除');
afterHlChange();
}
});
}
function openHlNote(qid, idx, rect) {
var rec = (store.highlights[qid] || [])[idx];
if (!rec) return;
blurEditors('hlnote'); // 焦点切换：批注栏的笔记框同时只留一个
if (!hlNoteEl) buildHlNote();
hlNoteCtx = { qid: qid, idx: idx };
$('.gth-hln-q', hlNoteEl).innerHTML =
'' + esc(rec.quote || '');
var ta = $('textarea', hlNoteEl);
ta.value = rec.note || '';
placeFloating(hlNoteEl, rect || { left: 0, top: 0, bottom: 0 });
ta.focus();
flashMark(qid, idx);
}
function closeHlNote() { if (hlNoteEl) { hlNoteEl.hidden = true; hlNoteCtx = null; } }
// 一处划线变动后，把所有「看到划线」的界面一起刷新
function afterHlChange() {
refreshBadges();
renderNotesList();
$$('.gth-aside').forEach(function (a) {
var it = itemsById[a.dataset.id];
if (it && !a.dataset.editing) renderAside(a, it);
});
refreshQuizHl();
syncBalloons();
}
function quizHlHtml(qid) {
var list = getHighlights(qid);
if (!list.length) return '';
return '' + icon('quote') + '批注',
'
',
'',
'',
'',
'',
'',
'',
'',
'
' + icon('highlighter') + list.length + ' 条划线
' +
list.map(function (h, i) {
return '' +
'' +
'' +
'' + icon('x') + '
';
}).join('');
}
function refreshQuizHl() {
$$('#gth-quiz [data-hls]').forEach(function (box) {
box.innerHTML = quizHlHtml(box.getAttribute('data-hls'));
});
}
// 答题报告页里的划线清单：点文字写批注，点 ✕ 取消划线
document.addEventListener('click', function (e) {
if (!e.target || !e.target.closest) return;
var box = e.target.closest('#gth-quiz [data-hls]');
if (!box) return;
var item = e.target.closest('.gth-hlp-item');
if (!item) return;
var qid = box.getAttribute('data-hls'), idx = Number(item.dataset.hl);
if (e.target.closest('.rm')) { hlRemove(qid, idx); toast('已取消划线'); afterHlChange(); return; }
if (e.target.closest('.t') || e.target.closest('.n')) {
openHlNote(qid, idx, item.getBoundingClientRect());
}
});
/* ---- 右侧页边距的批注气球：只在错题页，锚定到划线所在的那一行 ---- */
var balloonEls = {};
function syncBalloons() {
var inner = $('#gth-rail-in');
// 助手视图打开 / 不在列表页时轨道没有可见切片，批注气球一并收起
if (!inner || !isListRoute() || !railFrame) return;
var want = {};
Object.keys(store.highlights).forEach(function (qid) {
if (!qNodes[qid]) return; // 这道题不在当前列表里，没必要摆气球（也让滚动时的开销只跟当前列表有关）
(store.highlights[qid] || []).forEach(function (rec, i) {
if (rec.note) want[qid + ':' + i] = { qid: qid, idx: i, rec: rec };
});
});
Object.keys(balloonEls).forEach(function (k) {
if (!want[k]) { balloonEls[k].remove(); delete balloonEls[k]; }
});
var rows = [];
Object.keys(want).forEach(function (k) {
var w = want[k], el = balloonEls[k];
if (!el) {
el = document.createElement('div');
el.className = 'gth-balloon';
el.dataset.k = k;
inner.appendChild(el);
balloonEls[k] = el;
}
// 只在内容真的变了才写 innerHTML，否则会不停触发观察器造成往复重绘
var q = w.rec.quote || '';
if (q.length > 40) q = q.slice(0, 40) + '…';
var sig = (w.rec.color || 'yellow') + '|' + q + '|' + (w.rec.note || '');
if (el.dataset.sig !== sig) {
el.dataset.sig = sig;
el.innerHTML =
'' + esc(h.quote || '') + '
' +
(h.note ? '' + esc(h.note) + '
' : '') +
'' +
'' + esc(q) + '
' +
'' + esc(w.rec.note || '') + '
';
}
rows.push({ el: el, qid: w.qid, idx: w.idx });
});
if (!rows.length) return;
// 用 rect 相减得到「划线相对可见切片顶部」的偏移，与滚动位置无关
rows.forEach(function (row) {
row.top = null;
var node = qNodes[row.qid];
if (!node || !node.isConnected) return;
var mk = $('mark.gth-hl[data-gth-i="' + row.idx + '"]', node);
if (!mk) return;
row.top = mk.getBoundingClientRect().top - railFrame.top;
row.h = row.el.offsetHeight || 60; // 先量高度，避免写 top 再读高度来回触发重排
});
rows.sort(function (a, b) {
return (a.top == null ? 1e9 : a.top) - (b.top == null ? 1e9 : b.top);
});
var last = -1e9;
rows.forEach(function (row) {
if (row.top == null) { row.el.hidden = true; return; } // 题目不在当前列表里
row.el.hidden = false;
var t = Math.max(row.top, last + 8); // 简单纵向避让：紧跟上一条，不互相压住
row.el.style.top = Math.round(t) + 'px';
last = t + row.h;
});
}
/* ================= 一键整理为笔记 ================= */
var collectEl = null;
var collectState = { qids: null, src: 'both', onlyAnalysis: true, group: 'q' };
function collectIds() {
var ids = Object.keys(store.notes);
Object.keys(store.highlights).forEach(function (id) {
if (getHighlights(id).length && ids.indexOf(id) < 0) ids.push(id);
});
if (collectState.qids) {
var want = collectState.qids.map(String);
ids = ids.filter(function (id) { return want.indexOf(String(id)) >= 0; });
}
return ids;
}
function collectItems() {
var out = [];
collectIds().forEach(function (id) {
var note = store.notes[id];
var hls = [];
if (collectState.src !== 'note') {
hls = getHighlights(id).filter(function (h) {
return !collectState.onlyAnalysis || h.block === 'analysis';
});
}
var noteText = (collectState.src === 'hl' || !note) ? '' : (note.text || '');
if (!noteText && !hls.length) return;
var at = (note && note.updated) || 0;
hls.forEach(function (h) { if ((h.at || 0) > at) at = h.at; });
out.push({
id: id,
subject: (note && note.subject != null) ? note.subject : (hls[0] ? hls[0].subject : null),
snap: (note && note.snapshot) || (hls[0] && hls[0].snap) || '',
note: noteText, hls: hls, at: at
});
});
out.sort(function (a, b) { return b.at - a.at; });
return out;
}
function tagOf(it) { return '［' + (SUBJECT_NAME[it.subject] || '题目') + ' #' + it.id + '］'; }
function collectMarkdown() {
var items = collectItems();
var nHl = items.reduce(function (s, it) { return s + it.hls.length; }, 0);
var L = ['# 上岸村划线笔记', '',
'> 生成时间：' + new Date().toLocaleString() + ' 共 ' + items.length + ' 题 ' + nHl + ' 条划线', ''];
if (!items.length) { L.push('（没有可整理的内容）'); return L.join('\n'); }
// 按颜色归拢：把散在各题里的红色易错点收成一节，这才是划线真正的复习价值
if (collectState.group === 'color') {
var red = [], yel = [], notes = [];
items.forEach(function (it) {
it.hls.forEach(function (h) {
(h.color === 'red' ? red : yel).push(tagOf(it) + ' ' + (h.quote || '') +
(h.note ? ' （批注：' + h.note.replace(/\s*\n\s*/g, ' ') + '）' : ''));
});
if (it.note) notes.push(tagOf(it) + ' ' + it.note.replace(/\s*\n\s*/g, ' '));
});
if (red.length) { L.push('## 易错（' + red.length + ' 条）'); L.push(''); red.forEach(function (s) { L.push('- ' + s); }); L.push(''); }
if (yel.length) { L.push('## 重点（' + yel.length + ' 条）'); L.push(''); yel.forEach(function (s) { L.push('- ' + s); }); L.push(''); }
if (notes.length) { L.push('## 我的笔记（' + notes.length + ' 条）'); L.push(''); notes.forEach(function (s) { L.push('- ' + s); }); L.push(''); }
return L.join('\n');
}
items.forEach(function (it, i) {
L.push('## ' + (i + 1) + '. ' + tagOf(it));
L.push('');
if (it.snap) { L.push('> ' + it.snap); L.push(''); }
if (it.note) { L.push('**我的笔记**'); L.push(''); L.push(it.note); L.push(''); }
if (it.hls.length) {
L.push('**划线摘录**'); L.push('');
it.hls.forEach(function (h) {
L.push('- [' + (HL_LABEL[h.color] || '重点') + '] ' + (h.quote || '') +
(h.lost ? ' （原文已变更，未能重新定位）' : ''));
if (h.note) L.push(' - 批注：' + h.note.replace(/\s*\n\s*/g, ' '));
});
L.push('');
}
L.push('---'); L.push('');
});
return L.join('\n');
}
function collectPlain() {
return collectMarkdown()
.replace(/^> /gm, '')
.replace(/^#{1,6} /gm, '')
.replace(/\*\*/g, '')
.replace(/^- \[(重点|易错)\] /gm, '$1：');
}
function buildCollectEl() {
collectEl = document.createElement('div');
collectEl.id = 'gth-collect';
collectEl.hidden = true;
collectEl.innerHTML = [
'',
'
'
].join('');
document.body.appendChild(collectEl);
collectEl.addEventListener('click', function (e) {
if (e.target === collectEl) { closeCollect(); return; }
var chip = e.target.closest && e.target.closest('.gth-chip');
if (chip) {
collectState[chip.parentNode.dataset.g] = chip.dataset.v;
renderCollect();
return;
}
var btn = e.target.closest && e.target.closest('button[data-act]');
if (!btn) return;
var act = btn.dataset.act;
if (act === 'close') { closeCollect(); return; }
if (act === 'copy') { copyText($('#gthc-pre').textContent); toast('已复制到剪贴板'); return; }
if (act === 'txt') {
download('上岸村划线笔记_' + stamp() + '.txt', new Blob([collectPlain()], { type: 'text/plain;charset=utf-8' }));
return;
}
if (act === 'md') {
download('上岸村划线笔记_' + stamp() + '.md',
new Blob([collectMarkdown()], { type: 'text/markdown;charset=utf-8' }));
}
});
$('#gthc-only-analysis').addEventListener('change', function (e) {
collectState.onlyAnalysis = e.target.checked;
renderCollect();
});
}
function renderCollect() {
if (!collectEl) return;
$$('.gth-chip', collectEl).forEach(function (c) {
c.classList.toggle('on', c.dataset.v === collectState[c.parentNode.dataset.g]);
});
var cb = $('#gthc-only-analysis');
if (cb) {
cb.checked = collectState.onlyAnalysis;
cb.disabled = collectState.src === 'note';
}
$('#gthc-pre').textContent = collectMarkdown();
var items = collectItems();
var nh = items.reduce(function (s, it) { return s + it.hls.length; }, 0);
var nn = items.filter(function (it) { return it.note; }).length;
$('#gthc-meta').textContent = items.length + ' 题 · 划线 ' + nh + ' 条' +
(nn ? ' · 笔记 ' + nn + ' 条' : '');
}
function openCollect(qids) {
collectState.qids = (qids && qids.length) ? qids : null;
if (!collectEl) buildCollectEl();
renderCollect();
collectEl.hidden = false;
}
function closeCollect() { if (collectEl) collectEl.hidden = true; }
var quizEl = document.createElement('div');
quizEl.id = 'gth-quiz';
quizEl.hidden = true;
document.body.appendChild(quizEl);
var quiz = null;
function shuffled(arr) {
var a = arr.slice();
for (var i = a.length - 1; i > 0; i--) {
var j = Math.floor(Math.random() * (i + 1));
var t = a[i]; a[i] = a[j]; a[j] = t;
}
return a;
}
// 随机组卷：按答错次数加权抽样，错得越多越容易被抽中（Efraimidis-Spirakis）
// 权值为「答错次数 + 1」，全为 0 时退化为等概率随机，与改造前一致
function weightedPick(arr, k) {
var n = (k && k < arr.length) ? k : arr.length; // k=0 视为「全部」，仍按加权顺序打乱
return arr.map(function (q) {
return { q: q, key: Math.pow(Math.random(), 1 / errCountOf(q)) };
}).sort(function (a, b) { return b.key - a.key; })
.slice(0, n)
.map(function (x) { return x.q; });
}
// ---- 顺序刷题进度（从上次继续）----
// 键 = 筛选描述 + 顺序，值 = 该题在「完整有序列表」中的下标（0 起）
function resumeKey(f, order) { return filterDesc(f) + '|' + order; }
function saveResume(key, idx, id, answered) {
if (!key) return;
store.resume[key] = { idx: idx, id: id || '', at: Date.now(), answered: answered || {} };
saveStore();
}
// 优先按题目 id 定位（列表变动时下标会漂移），找不到才退回记录的下标
function resumeOffset(key, list) {
var r = key && store.resume[key];
if (!r) return 0;
for (var i = 0; i < list.length; i++) {
if (String(list[i].id) === String(r.id)) return i;
}
return Math.min(Math.max(r.idx || 0, 0), list.length);
}
$('#gth-start').addEventListener('click', function () {
var f = readFilter();
var num = Math.max(0, parseInt($('#gth-num').value, 10) || 0);
var order = $('#gth-order').value;
var seq = order !== 'random'; // 只有顺序刷题记录 / 续用进度
var key = seq ? resumeKey(f, order) : '';
var r = seq ? store.resume[key] : null;
// 续刷时要拉到「上次位置 + 题量」，否则只取到第一页会拿不到后面的题
var want = !num ? 0 : ((r && r.idx) ? r.idx + num + 1 : num);
setStatus('正在组卷…');
fetchByFilter(f, want).then(function (all) {
if (!all.length) { setStatus('该条件下没有题目（来源：' + SRC_NAME[f.src] + '）', 'err'); return; }
var ordered = order === 'desc' ? all.slice().reverse() : all;
var offset = seq ? resumeOffset(key, ordered) : 0;
var restarted = false;
if (offset >= ordered.length) { // 已刷到末尾，从头再来
offset = 0;
if (key) { delete store.resume[key]; saveStore(); }
restarted = true;
}
var picked = order === 'random'
? weightedPick(ordered, num)
: (num ? ordered.slice(offset, offset + num) : ordered.slice(offset));
if (!picked.length) { setStatus('没有可练习的题目', 'err'); return; }
loaded.filter = f; // 供组卷历史复用同一筛选
// 顺序刷题：若上次有「未作答」的题，这次先跳到第一道未作答的题接着做
var startIdx = 0;
if (seq && r && r.answered && picked.length) {
for (var fu = 0; fu < picked.length; fu++) {
if (!r.answered[String(picked[fu].id)]) { startIdx = fu; break; }
}
}
var note = restarted ? '（已刷完，从头开始）'
: ((offset + startIdx) ? '（从第 ' + (offset + startIdx + 1) + ' 题继续）' : '');
setStatus('组卷完成，共 ' + picked.length + ' 题' + note, 'ok');
startQuiz(picked, filterDesc(f), false, seq ? (r && r.answered) : null);
if (seq) {
quiz.resumeKey = key;
quiz.resumeBase = offset;
quiz.idx = startIdx;
// 立刻记录起始位置；沿用上次已作答记录，作为本次续刷的基准
saveResume(key, offset + startIdx, picked[startIdx] && picked[startIdx].id, quiz.answeredIds);
}
renderQuiz(); // 用更新后的 idx 重新渲染，确保直接显示第一道未作答的题
renderPracticeHint();
}).catch(function (e) { setStatus('组卷失败：' + e.message, 'err'); });
});
// ---- 组卷历史：滚动保留最近三次 ----
function pushHistory(desc, list) {
store.history.unshift({
at: Date.now(),
desc: desc,
n: list.length,
filter: loaded.filter,
ids: list.map(function (q) { return q.id; })
});
store.history = store.history.slice(0, 3);
saveStore();
renderHistory();
}
function renderHistory() {
var box = $('#gth-history');
if (!box) return;
var h = store.history || [];
if (!h.length) {
box.innerHTML = '' + icon('highlighter') + '整理为笔记',
'
',
'',
'
',
'内容
',
'',
'
仅划线
',
'仅笔记
',
'划线 + 笔记
',
'分组
',
'',
'
按题目
',
'按颜色归拢
',
'',
'',
'
',
'',
'',
'',
'',
'',
'
',
'' + icon('play') +
'
';
return;
}
box.innerHTML = h.map(function (it, i) {
return '还没有组卷记录。设置题量后点「开始重练」即可。
' +
'' + esc(it.desc) + '' +
'' +
'' +
'
';
}).join('');
$$('[data-his]', box).forEach(function (b) {
b.addEventListener('click', function () { replayHistory(store.history[Number(b.dataset.his)]); });
});
}
// 重练面板的引导文案：随机提示加权规则，顺序提示续刷位置并可重置
function renderPracticeHint() {
var el = $('#gth-practice-hint'), btn = $('#gth-resume-reset');
if (!el) return;
var order = $('#gth-order').value;
if (order === 'random') {
el.textContent = '随机组卷会优先抽「答错次数多」的题目';
if (btn) btn.hidden = true;
return;
}
// r.idx 是「下次从第几题开始」的下标：中途退出=重做该题，交卷后=接着下一题
var r = store.resume[resumeKey(readFilter(), order)];
el.textContent = r
? '下次从第 ' + (r.idx + 1) + ' 题继续'
: '顺序刷题会自动记录进度，下次可从上次继续';
if (btn) btn.hidden = !r;
}
$('#gth-resume-reset').addEventListener('click', function () {
delete store.resume[resumeKey(readFilter(), $('#gth-order').value)];
saveStore();
renderPracticeHint();
setStatus('已清除该条件下的刷题进度，下次从头开始', 'ok');
});
// 按历史记录的筛选条件重新拉题，再与当时的题目 id 快照取交集
function replayHistory(h) {
if (!h || !h.filter) return;
setStatus('正在按历史条件重新拉取题目…');
fetchByFilter(h.filter).then(function (list) {
var want = {};
(h.ids || []).forEach(function (id) { want[id] = 1; });
var picked = list.filter(function (q) { return want[q.id]; });
if (!picked.length) { setStatus('这套卷的题目已不在当前来源中，无法重练', 'err'); return; }
var miss = h.ids.length - picked.length;
if (miss) setStatus('已找回 ' + picked.length + '/' + h.ids.length + ' 题，其余已移出列表', 'err');
else setStatus('');
startQuiz(picked, h.desc, true);
}).catch(function (e) { setStatus('重练失败：' + e.message, 'err'); });
}
function startQuiz(list, desc, fromHistory, seedAnswered) {
quiz = {
list: list, desc: desc, idx: 0,
answers: {}, submitted: false,
answeredIds: seedAnswered || {}, // 续刷时沿用上次已作答记录，避免被首次渲染清空
startAt: Date.now(), timer: null
};
if (!fromHistory) pushHistory(desc, list);
quizEl.hidden = false;
document.body.style.overflow = 'hidden';
quiz.timer = setInterval(function () {
var el = $('#gth-timer');
if (el && quiz && !quiz.submitted) el.textContent = fmtTime(Date.now() - quiz.startAt);
}, 1000);
renderQuiz();
}
function closeQuiz() {
if (quiz && quiz.timer) clearInterval(quiz.timer);
quiz = null;
quizEl.hidden = true;
quizEl.innerHTML = '';
document.body.style.overflow = '';
refreshBadges();
renderPracticeHint(); // 退出重练后刷新「上次刷到第几题」
}
function toggleAnswer(id, label, multi) {
var cur = quiz.answers[id] || [];
if (!multi) { quiz.answers[id] = [label]; }
else {
var i = cur.indexOf(label);
if (i >= 0) cur.splice(i, 1); else cur.push(label);
quiz.answers[id] = cur.slice().sort();
}
if ((quiz.answers[id] || []).length) quiz.answeredIds[id] = true; // 只要作答过就记一笔
renderQuiz();
}
function answeredCount() {
return Object.keys(quiz.answers).filter(function (k) {
return (quiz.answers[k] || []).length > 0;
}).length;
}
function renderQuiz() {
if (!quiz) return;
// 顺序刷题：实时记录刷到第几题 + 已作答集合，中途退出后可从「第一道未作答」继续
if (quiz.resumeKey && !quiz.submitted && quiz.list[quiz.idx]) {
saveResume(quiz.resumeKey, quiz.resumeBase + quiz.idx, quiz.list[quiz.idx].id, quiz.answeredIds);
}
quizEl.innerHTML = quiz.submitted ? reportHtml() : doingHtml();
bindQuiz();
repaintHighlights(); // 报告页每道题都是新 DOM，渲染完立刻把划线画回去
}
function doingHtml() {
var q = quiz.list[quiz.idx];
var multi = ansKey(q.correct_answer).length > 1;
var sel = quiz.answers[q.id] || [];
var opts = (q.opt || []).map(function (o) {
return '' +
'' + esc(o.label) + '.' +
'' + wakeImgs(o.content || '') + '
';
}).join('');
var cells = quiz.list.map(function (item, i) {
var cls = 'gthq-cell';
if (i === quiz.idx) cls += ' cur';
else if ((quiz.answers[item.id] || []).length) cls += ' answered';
return '' + (i + 1) + '
';
}).join('');
return '' +
'' +
'' + icon('listChecks') + '第 ' + (quiz.idx + 1) + ' / ' + quiz.list.length + ' 题' +
'已答 ' + answeredCount() + '' +
'' + icon('clock') + fmtTime(Date.now() - quiz.startAt) + '' +
'' +
'' +
'' +
'
' +
'' +
'
';
}
function reportHtml() {
var right = 0;
var items = quiz.list.map(function (q, i) {
var ans = quiz.answers[q.id] || [];
var answered = ans.length > 0;
var mine = ansKey(ans);
var ok = answered && mine === ansKey(q.correct_answer);
if (ok) right++;
var opts = (q.opt || []).map(function (o) {
var isRight = ansKey(q.correct_answer).indexOf(o.label) >= 0;
var isMine = (quiz.answers[q.id] || []).indexOf(o.label) >= 0;
var mark = isRight ? '（正确）' : (isMine ? '（你选的）' : '');
var style = isRight ? ' style="color:#16a34a;font-weight:600"' : (isMine ? ' style="color:var(--gth-destructive)"' : '');
return '' +
'' +
(q.material ? '
' +
'' + wakeImgs(q.material) + '
' : '') +
'' + wakeImgs(q.content || '') + '
' +
'' + (opts || '
' +
(multi ? '该题型无选项
') + '多选题，共 ' + ansKey(q.correct_answer).length + ' 个正确选项
' : '') +
'' + cells + '
' +
'' +
'' +
'' +
'
' +
'' +
'' +
(analysisOf(q) ? '
';
}).join('');
var pct = quiz.list.length ? Math.round(right / quiz.list.length * 100) : 0;
// 错题数只统计「答过且答错」的，未作答不计入错题
var wrongCount = quiz.list.filter(function (q) {
var a = quiz.answers[q.id] || [];
return a.length > 0 && ansKey(a) !== ansKey(q.correct_answer);
}).length;
return '' +
'' +
'' +
(ok ? icon('checkCircle') : (answered ? icon('xCircle') : icon('warn'))) +
(ok ? '正确' : (answered ? '错误' : '未作答')) + '' +
'第 ' + (i + 1) + ' 题' +
'·' + esc(SUBJECT_NAME[q.content_type] || '') + '' +
'·#' + esc(q.id) + '' +
(function () { var t = errTag(errCountOf(q));
return '' + t.html + ''; })() +
'
' +
(q.material ? '' + wakeImgs(q.material) + '
' : '') +
'' + wakeImgs(q.content || '') + '
' +
'' + opts + '
' +
'你的答案：' + (mine || '未作答') + '
' +
'正确答案：' + ansKey(q.correct_answer) + '
解析
' : '') +
'' + wakeImgs(analysisOf(q)) + '
' +
'
' +
'' +
'' +
'
' +
'' +
'' +
'' + icon('checkCircle') + '得分 ' + right + ' / ' + quiz.list.length + '' +
'正确率 ' + pct + '%' +
'' + icon('clock') + '用时 ' + fmtTime(Date.now() - quiz.startAt) + '' +
'' +
'' +
'' +
'' +
'
' +
'' +
(wrongCount ? '
';
}
function bindQuiz() {
var q = quiz.list[quiz.idx];
$$('.gthq-opt', quizEl).forEach(function (el) {
el.addEventListener('click', function () {
toggleAnswer(q.id, el.dataset.label, ansKey(q.correct_answer).length > 1);
});
});
$$('.gthq-cell', quizEl).forEach(function (el) {
el.addEventListener('click', function () { quiz.idx = Number(el.dataset.i); renderQuiz(); });
});
var prev = $('#gth-prev', quizEl);
if (prev) prev.addEventListener('click', function () {
if (quiz.idx > 0) { quiz.idx--; renderQuiz(); }
});
var next = $('#gth-next', quizEl);
if (next) next.addEventListener('click', function () {
if (quiz.idx < quiz.list.length - 1) { quiz.idx++; renderQuiz(); }
});
var submit = $('#gth-submit', quizEl);
if (submit) submit.addEventListener('click', function () {
var un = quiz.list.length - answeredCount();
if (un > 0 && !confirm('还有 ' + un + ' 题未作答，确定交卷吗？')) return;
clearInterval(quiz.timer);
quiz.timer = null;
applyMastery();
quiz.submitted = true;
// 交卷：未作答的不算「做过」。全部作答 -> 整套完成（下次从头开始）；
// 否则下次从「第一道未作答」继续，而不是径直跳到这套之后
if (quiz.resumeKey) {
var fu = 0;
for (; fu < quiz.list.length; fu++) {
if (!quiz.answeredIds[String(quiz.list[fu].id)]) break;
}
if (fu >= quiz.list.length) saveResume(quiz.resumeKey, quiz.resumeBase + quiz.list.length, '', {});
else saveResume(quiz.resumeKey, quiz.resumeBase + fu, quiz.list[fu].id, quiz.answeredIds);
}
renderQuiz();
quizEl.querySelector('.gthq-main').scrollTop = 0;
});
var ow = $('#gth-onlywrong', quizEl);
if (ow) ow.addEventListener('click', function () {
$$('#gth-report .gthq-r-item').forEach(function (el) {
el.hidden = !el.classList.contains('wrong');
});
});
var al = $('#gth-all', quizEl);
if (al) al.addEventListener('click', function () {
$$('#gth-report .gthq-r-item').forEach(function (el) { el.hidden = false; });
});
var exit = $('#gth-exit', quizEl);
if (exit) exit.addEventListener('click', closeQuiz);
$$('textarea[data-note]', quizEl).forEach(function (ta) {
ta.addEventListener('input', debounce(function () {
var q2 = null;
for (var i = 0; i < quiz.list.length; i++) if (String(quiz.list[i].id) === ta.dataset.note) { q2 = quiz.list[i]; break; }
setNote(ta.dataset.note, ta.value.trim(), {
snapshot: q2 ? stripHtml(q2.content || '').slice(0, 240) : '',
subject: q2 ? q2.content_type : null
});
}, 400));
});
// 报告页：划线清单（点文字写批注 / 点 ✕ 取消）由 document 上的委托统一处理
var cb = $('#gth-report');
if (cb) refreshQuizHl();
$$('.gthq-r-item[data-gth-qid] [data-act="collect"]', quizEl).forEach(function (btn) {
var item = btn.closest('.gthq-r-item');
btn.addEventListener('click', function () {
openCollect([String(item.getAttribute('data-gth-qid'))]);
});
});
}
// 交卷时统计对错：未作答的题目既不计入对错，也不累计答错次数、不改变掌握度
function applyMastery() {
quiz.list.forEach(function (q) {
var ans = quiz.answers[q.id];
if (!ans || !ans.length) return; // 未作答：直接跳过，当作「没做过」处理
var ok = ansKey(ans) === ansKey(q.correct_answer);
var prev = (store.mastered[q.id] && store.mastered[q.id].streak) || 0;
store.mastered[q.id] = { streak: ok ? prev + 1 : 0, updated: Date.now() };
bumpWrongCount(q, ok);
});
saveStore();
}
document.addEventListener('keydown', function (e) {
if (quizEl.hidden) return;
if (e.key === 'Escape') { closeQuiz(); return; }
if (quiz && !quiz.submitted) {
if (e.key === 'ArrowLeft' && quiz.idx > 0) { quiz.idx--; renderQuiz(); }
if (e.key === 'ArrowRight' && quiz.idx < quiz.list.length - 1) { quiz.idx++; renderQuiz(); }
}
});
// 批注栏在错题页与收藏页都生效，用 body 上的标记类限定样式作用域
// （类名沿用 gth-error，改名会牵动一批 CSS 选择器，没必要）
function syncRouteClass() {
document.body.classList.toggle('gth-error', isListRoute());
syncSourceDefault();
}
window.addEventListener('hashchange', function () {
syncRouteClass();
invalidateLoaded(); // 换了路由，缓存的题目列表跟着作废
// 离开错题页 / 收藏页时收起助手视图，避免它跟着显示到别的界面上
if (!isListRoute() && viewOn) setView(false);
refreshPageUI();
});
if (!getToken()) {
setStatus('未检测到登录 token，请先登录站点后再使用。', 'err');
}
syncRouteClass();
syncFilterUI();
renderHistory();
updateExportHint();
})();' + icon('warn') + '错题 ' + wrongCount + ' 道
' : '') +
'' + items + '
' +
'