包裹
// 真实 DOM 的 pre 只有语法高亮 span，没有 ，需要自己合成。
const CODE_OP_LABEL = /^(复制|下载|展开|收起|编辑|运行|预览|copy|download|expand|collapse|edit|run)$/i;
function normalizeCodeBlocks(root) {
root.querySelectorAll(SEL.CODE_BLOCK).forEach(block => {
const banner = block.querySelector(SEL.CODE_BANNER);
let lang = '';
if (banner) {
// 双 Tab（代码/图表）→ mermaid
const tabs = [...banner.querySelectorAll('div[role="tab"], .ds-segmented-button')]
.map(e => String(e.textContent || '').trim().toLowerCase())
.filter(Boolean);
if (tabs.includes('图表') && tabs.includes('代码')) lang = 'mermaid';
// 否则取 banner 内首个非操作按钮的短文本（banner 文案 = "语言\n复制\n下载\n展开"）
if (!lang) {
for (const sp of banner.querySelectorAll('span')) {
const s = String(sp.textContent || '').trim();
if (!s || s.length > 40 || CODE_OP_LABEL.test(s)) continue;
lang = s.split(/\s+/)[0].trim().toLowerCase();
if (lang) break;
}
}
banner.remove();
}
[...block.children].forEach(c => { if (tag(c) === 'svg') c.remove(); });
const pre = block.querySelector('pre');
if (!pre) return;
[...pre.children].forEach(c => { if (tag(c) === 'svg') c.remove(); });
let code = pre.querySelector('code');
if (!code) {
code = document.createElement('code');
code.innerHTML = pre.innerHTML;
pre.innerHTML = '';
pre.appendChild(code);
}
if (lang) code.setAttribute(ATTR.LANG, lang);
});
}
// 只保留 start（其余属性归零），- 去掉 value
function normalizeLists(root) {
root.querySelectorAll('ol').forEach(ol => {
let start = 1;
const n = Number.parseInt(String(ol.getAttribute('start') ?? '').trim(), 10);
if (Number.isFinite(n)) start = n;
[...ol.attributes].forEach(a => ol.removeAttribute(a.name));
ol.setAttribute('start', String(start));
});
root.querySelectorAll('li').forEach(li => li.removeAttribute('value'));
}
// 纯文本 div →
（用户消息体没有
，不补则得不到段落换行）
// 注意排除自有标记元素：section 容器必须保持
，否则模板装饰的 insertBefore 会产出
// 非法的 嵌套（浏览器会重排，装饰失效）。
const BLOCKISH = 'table, pre, ul, ol, blockquote, hr, h1, h2, h3, h4, h5, h6, .md-code-block';
function isSimpleTextDiv(el) {
if (tag(el) !== 'div') return false;
try {
if ([...el.attributes].some(a => a.name.startsWith(OWN_ATTR_PREFIX))) return false;
} catch (e) { /* 忽略 */ }
try {
if (el.querySelector(BLOCKISH)) return false;
if (el.querySelector('div')) return false;
return !!String(el.textContent || '').trim();
} catch (e) { return false; }
}
function divToParagraph(root) {
// 自内向外替换，避免上层判定被下层替换结果影响
[...root.querySelectorAll('div')].reverse().forEach(d => {
if (!isSimpleTextDiv(d)) return;
const p = document.createElement('p');
p.innerHTML = d.innerHTML;
try { d.replaceWith(p); } catch (e) { /* 忽略 */ }
});
}
// 行内图标标记（引用角标 / 联网标识）
// 实测结构：
// - ← 隐藏占位，撑宽度
// …14×14 svg… ← 悬浮图标层
//
// 判据用「样式特征」而非哈希类名：含 absolute 或 opacity:0 的装饰子层，且剥掉装饰后仅剩
// 极短编号（或空）。这样官网改版换类名也不失效。
const ABS_RE = /position\s*:\s*absolute/i;
const ZERO_RE = /opacity\s*:\s*0(?:\.0+)?/i;
const styleOf = (el) => String((el && el.getAttribute && el.getAttribute('style')) || '');
function isCitationBadge(el) {
const t = tag(el);
if (t !== 'span' && t !== 'a') return false;
if (isInside(el, ['pre', 'code', 'katex'])) return false;
const kids = [...el.children];
const hasAbs = kids.some(c => ABS_RE.test(styleOf(c)));
const hasZero = kids.some(c => ZERO_RE.test(styleOf(c)));
if (!hasAbs && !hasZero) return false;
// 剥掉装饰子层后，剩余文本必须为空或极短的引用编号
const clone = el.cloneNode(true);
clone.querySelectorAll('svg').forEach(s => s.remove());
clone.querySelectorAll('*').forEach(c => {
const st = styleOf(c);
if (ABS_RE.test(st) || ZERO_RE.test(st)) { try { c.remove(); } catch (e) { /* 忽略 */ } }
});
const rest = String(clone.textContent || '').replace(/[\s\u200b\ufeff\u200c\u200d]+/g, '');
return rest.length <= 3;
}
// 噪音清理：引用角标 → 按钮/图标 → 装饰 svg → 空 span 解包
// 注意顺序：角标判据依赖「绝对定位层 + 装饰 svg」，必须先于删 svg 执行。
function stripNoise(root) {
[...root.querySelectorAll('a, span')].forEach(n => {
if (!n.parentNode) return;
if (!isCitationBadge(n)) return;
try { n.remove(); } catch (e) { /* 忽略 */ }
});
// 角标剥离后可能留下空链接（只剩 href）→ 一并清掉
[...root.querySelectorAll('a')].forEach(n => {
if (!n.parentNode) return;
if (String(n.textContent || '').trim()) return;
if (n.querySelector('img')) return;
try { n.remove(); } catch (e) { /* 忽略 */ }
});
root.querySelectorAll('button, [role="button"], .ds-icon').forEach(n => {
try { n.remove(); } catch (e) { /* 忽略 */ }
});
// 数学已抽成自有 span，其余 svg 均为装饰
root.querySelectorAll('svg').forEach(n => {
if (isInside(n, ['katex'])) return;
try { n.remove(); } catch (e) { /* 忽略 */ }
});
[...root.querySelectorAll('span')].forEach(n => {
if (!n.parentNode) return;
if (n.closest('.katex, .katex-display')) return;
const attrs = [...n.attributes].map(a => a.name);
if (attrs.some(a => a.startsWith(OWN_ATTR_PREFIX))) return; // 自有标记不展开
if (attrs.includes('class')) return; // 带 class 的 span 保守保留
if (String(n.textContent || '').trim()) return; // 有文字则保留
try { // 无 class 无属性的空 span → 解包
while (n.firstChild) n.parentNode.insertBefore(n.firstChild, n);
n.remove();
} catch (e) { /* 忽略 */ }
});
}
// 八步规范化（各自容错，单点失败不阻断其余）
function normalizeContent(doc, root, opts) {
const steps = [
() => unwrapTableShell(root),
() => normalizeMath(root),
() => normalizeCodeBlocks(root),
() => normalizeLists(root),
() => divToParagraph(root),
() => stripNoise(root),
];
steps.forEach(fn => { try { fn(); } catch (e) { console.warn('[deepseektool] 导出规范化步骤失败：', e); } });
}
// ---------- 提取：DeepSeek DOM → 语义消息 ----------
// AI 答案根：取消息内第一个「不在思考区里」的 .ds-markdown。
// 陷阱：思考过程正文自身也是 .ds-markdown，且在文档顺序上位于答案之前，
// 直接 querySelector('.ds-markdown') 会错拿到思考内容。
// 用显式过滤（`closest('.ds-think-content')`）而非 CSS `:not(.a .b)`，兼容性更好。
function resolveAiContent(msgEl) {
let all = [];
try { all = [...msgEl.querySelectorAll(SEL.AI_CONTENT)]; } catch (e) { return null; }
for (const el of all) {
let inThink = false;
try { inThink = !!el.closest(SEL.THINK_CONTENT); } catch (e) { inThink = false; }
if (!inThink) return el;
}
return null;
}
// 思考过程正文：直接取 .ds-think-content（语义类名，实测稳定）。
// 注意结构陷阱：思考正文并不在折叠条的兄弟层，而是挂在折叠条容器（._245c867）的祖父层
// （._74c0879）下 —— 一条消息可能有多个 .ds-think-content（分片流式输出），需全部收集。
// 另需排除「已阅读 N 个网页」这类联网标识（同为 .ds-think-content，但不是思考过程）。
const WEB_READ_RE = /^已阅读\s*\d+\s*个网页$/;
function collectReasoningNodes(msgEl) {
let nodes = [];
try { nodes = [...msgEl.querySelectorAll(SEL.THINK_CONTENT)]; } catch (e) { return []; }
return nodes.filter(n => {
const txt = String(n.textContent || '').trim();
if (!txt) return false;
return !WEB_READ_RE.test(txt);
});
}
// 用户文本根：优先语义类名 .ds-collapsible-text，回退「直接子级中文本最长且无 AI 内容/媒体/按钮」
function resolveUserRoot(msgEl) {
const collapsible = msgEl.querySelector(SEL.COLLAPSIBLE);
if (collapsible) return collapsible;
let best = null, bestLen = 0;
[...msgEl.children].forEach(c => {
if (!isEl(c)) return;
try {
if ([...c.querySelectorAll(SEL.AI_CONTENT)].some(x => !x.closest(SEL.THINK_CONTENT))) return;
} catch (e) { /* 忽略 */ }
if (c.querySelector('img, video, canvas, figure, button, [role="button"]')) return;
const len = String(c.textContent || '').trim().length;
if (len > bestLen) { bestLen = len; best = c; }
});
return best;
}
// 只保留「思考体 + 答案体」，其余（折叠条 / 操作栏 / 引用来源 / 附件缩略图 / 头像）一律丢弃。
// 这比逐个枚举待删选择器稳健得多 —— 官网加任何新的装饰层都不会污染输出。
// 产出的是**语义 DOM**（不做字符串转换），以便模板装饰阶段在其上插入 h1/p/blockquote。
//
// 拆成「来源 → 语义 DOM」两步，是因为长对话必须靠快照导出（虚拟列表会把滚过的消息卸载）：
// 快照存的是原始素材（HTML 串），导出时用同一个函数还原，保证两条路径产出一致。
function wrapFromSource(role, src, opts) {
if (!src) return null;
const wrap = document.createElement('div');
const fill = (host, html) => {
if (!html) return;
const tmp = document.createElement('div');
tmp.innerHTML = html;
while (tmp.firstChild) host.appendChild(tmp.firstChild);
};
if (role === 'assistant') {
if (opts.includeReasoning && src.reasoningHTML) {
const bq = document.createElement('blockquote');
fill(bq, src.reasoningHTML);
if (bq.firstChild) wrap.appendChild(bq);
}
if (!src.answerHTML) return null;
const sec = document.createElement('div');
sec.setAttribute(ATTR.SECTION, 'answer');
fill(sec, src.answerHTML);
wrap.appendChild(sec);
} else {
if (!src.questionHTML) return null;
const sec = document.createElement('div');
sec.setAttribute(ATTR.SECTION, 'question');
fill(sec, src.questionHTML);
wrap.appendChild(sec);
}
normalizeContent(document, wrap, opts);
return wrap;
}
const toMarkdown = (wrap) => {
const md = converter.convert(wrap);
return md.trim() ? md.trim() : null;
};
// ==================== 内容模板 ====================
// 模板清单与装饰实现。
// 装饰产出语义 DOM（h1/h2/p/blockquote），正好喂给上面的转换引擎直接得到 Markdown。
// 模板清单里多加一项「原样输出」（无装饰），它也是本工具此前的默认行为。
const TEMPLATE_PLAIN = { id: 'plain', name: '原样输出', desc: '不加任何标识前缀，原样导出问答内容' };
const TEMPLATES = [
{ id: 'conversation', name: '简洁对话', desc: '简洁的问答格式，用「提问」与「回答」标识每轮对话' },
{ id: 'structured', name: '结构化笔记', desc: '以序号标题概括问题，附完整问题详情与标注前缀的回答' },
{ id: 'knowledgeDoc', name: '知识文档', desc: '将问题作为章节标题，回答作为正文，适合整理成文档' },
{ id: 'rolePlay', name: '角色对话', desc: '用「我说」与「DeepSeek说」标识每轮对话，适合还原真实交流场景' },
];
const QUESTION_TEMPLATES = [
{ id: 'qPlainText', name: '问题清单（纯文本）', desc: '以纯文本序号列出问题，便于复制到聊天或笔记' },
{ id: 'qStructured', name: '问题清单（结构化）', desc: '以序号标题概括提问，附完整问题详情，适合整理问题清单' },
{ id: 'qOutline', name: '问题大纲', desc: '以每个提问作为章节标题，适合梳理需求与待解决问题' },
{ id: 'qCards', name: '问题卡片', desc: '以 Q1/Q2 卡片形式整理提问，适合快速回顾' },
];
const secOf = (wrap, name) => wrap.querySelector('[' + ATTR.SECTION + '="' + name + '"]');
// 全量问题文本：**保留换行**（仅归一 CRLF）。对应插件 module 1845 的 p()。
// 注意不要在这个函数里压空白 —— 换行要留给调用方转成
，否则多段提问会被挤成一行。
const fullText = (el) => String((el && (el.innerText || el.textContent)) || '').replace(/\r\n?/g, '\n').trim();
// 单行化：连续空白压成一个空格。对应插件的 m()，仅用于「摘要」与「长度判断」。
const oneLine = (s) => String(s || '').replace(/\s+/g, ' ').trim();
const shorten = (s, n) => { s = String(s || ''); return s.length > n ? s.slice(0, n) + '...' : s; };
// 用新节点替换元素内容，但保留其 class / id / 其余属性
function replaceInner(el, nodes) {
const cls = el.className, id = el.id;
const attrs = [];
try { [...el.attributes].forEach(a => { if (a.name !== 'class' && a.name !== 'id') attrs.push([a.name, a.value]); }); } catch (e) { /* 忽略 */ }
el.innerHTML = '';
el.className = cls;
if (id) el.id = id;
attrs.forEach(([k, v]) => { try { el.setAttribute(k, v); } catch (e) { /* 忽略 */ } });
(Array.isArray(nodes) ? nodes : [nodes]).forEach(n => { if (n) el.appendChild(n); });
}
function injectBefore(el, node) {
if (!node) return;
if (el.firstChild) el.insertBefore(node, el.firstChild);
else el.appendChild(node);
}
// 问题正文折叠成单段（`
` 分节），不保留原有块级结构。对应插件的 a()
function collapseToParagraph(sec) {
const text = fullText(sec);
const p = document.createElement('p');
p.setAttribute('style', 'margin:0');
String(text).split('\n').forEach((line, i) => {
if (i > 0) p.appendChild(document.createElement('br'));
p.appendChild(document.createTextNode(line));
});
replaceInner(sec, p);
}
// 内容标题整体降一级（h1→h2 …），仅当内容里存在 h1 时才降
// 目的：让正文标题层级落在模板插入的 h1 之下
function demoteHeadings(sec) {
let hasH1 = false;
try { hasH1 = !!sec.querySelector('h1'); } catch (e) { hasH1 = false; }
if (!hasH1) return;
let list = [];
try { list = [...sec.querySelectorAll('h1, h2, h3, h4, h5, h6')]; } catch (e) { return; }
for (let i = list.length - 1; i >= 0; i--) {
const h = list[i];
if (!h || !h.parentNode) continue;
const lv = headingLevel(tag(h));
if (!lv || lv >= 6) continue;
const nh = document.createElement('h' + Math.min(lv + 1, 6));
try { [...h.attributes].forEach(a => nh.setAttribute(a.name, a.value)); } catch (e) { /* 忽略 */ }
while (h.firstChild) nh.appendChild(h.firstChild);
try { h.parentNode.replaceChild(nh, h); } catch (e) { /* 忽略 */ }
}
}
const boldLabel = (text) => {
const p = document.createElement('p');
p.setAttribute('style', 'margin:0;margin-bottom:8px');
const s = document.createElement('strong');
s.textContent = text;
p.appendChild(s);
return p;
};
// 结构化笔记 / 问题清单（结构化）：序号 h1 + 摘要，超长时补「问题详情」。对应插件的 c()
// 摘要用**单行化文本**判断长度与截断；「问题详情」用**保留换行**的全文（换行转
）
function structuredHeader(sec, index, hLevel) {
const level = Math.min(Math.max(hLevel || 1, 1), 6);
const full = fullText(sec);
const sum = oneLine(full);
const box = document.createElement('div');
box.setAttribute('style', 'margin-bottom:8px');
const h = document.createElement('h' + level);
h.textContent = index + '、' + shorten(sum, 15);
box.appendChild(h);
if (sum.length > 15) {
const detail = document.createElement('div');
detail.setAttribute('style', 'margin-top:4px;margin-bottom:12px;color:#666');
const p = document.createElement('p');
p.setAttribute('style', 'margin:0');
const s = document.createElement('strong');
s.textContent = '问题详情：';
p.appendChild(s);
p.appendChild(document.createElement('br'));
const lines = full.split('\n');
lines.forEach((line, i) => {
p.appendChild(document.createTextNode(line));
if (i < lines.length - 1) p.appendChild(document.createElement('br'));
});
detail.appendChild(p);
box.appendChild(detail);
}
replaceInner(sec, box);
}
// 知识文档（h1）/ 问题大纲（h2）：序号标题。对应插件的 h()，标题层级由调用方传入
function outlineHeader(sec, index, hLevel, maxLen) {
const level = Math.min(Math.max(hLevel || 2, 1), 6);
const h = document.createElement('h' + level);
h.textContent = index + '. ' + shorten(oneLine(fullText(sec)), maxLen);
replaceInner(sec, h);
}
const TEMPLATE_DECORATORS = {
conversation: {
onUser: (wrap) => { const s = secOf(wrap, 'question'); if (s) { collapseToParagraph(s); injectBefore(s, boldLabel('提问：')); } },
onAi: (wrap) => { const s = secOf(wrap, 'answer'); if (s) injectBefore(s, boldLabel('回答：')); },
},
structured: {
onUser: (wrap, n) => { const s = secOf(wrap, 'question'); if (s) structuredHeader(s, n, 1); },
onAi: (wrap) => { const s = secOf(wrap, 'answer'); if (!s) return; injectBefore(s, boldLabel('回答（Answer）：')); demoteHeadings(s); },
},
knowledgeDoc: {
// 插件：h(e, idx, 1) → h1（章节标题与 structured 同级）
onUser: (wrap, n) => { const s = secOf(wrap, 'question'); if (s) outlineHeader(s, n, 1, 60); },
onAi: (wrap) => { const s = secOf(wrap, 'answer'); if (s) demoteHeadings(s); },
},
rolePlay: {
// 插件：rolePlay.onUser = a(e) 折叠 + 「我说：」。折叠不可省，否则多段提问会破坏格式
onUser: (wrap) => { const s = secOf(wrap, 'question'); if (s) { collapseToParagraph(s); injectBefore(s, boldLabel('我说：')); } },
onAi: (wrap) => { const s = secOf(wrap, 'answer'); if (s) injectBefore(s, boldLabel('DeepSeek说：')); },
},
qStructured: {
onUser: (wrap, n) => { const s = secOf(wrap, 'question'); if (s) structuredHeader(s, n, 1); },
onAi: () => { },
},
qOutline: {
// 插件：h(e, idx) → 默认 n=2 → h2
onUser: (wrap, n) => { const s = secOf(wrap, 'question'); if (s) outlineHeader(s, n, 2, 60); },
onAi: () => { },
},
qCards: {
onUser: (wrap, n) => {
const s = secOf(wrap, 'question');
if (!s) return;
const box = document.createElement('div');
box.setAttribute('style', 'margin-bottom:8px');
const h = document.createElement('h1');
h.setAttribute('style', 'margin:0;margin-bottom:4px;color:#4f46e5');
h.textContent = 'Q' + n + '：';
box.appendChild(h);
const bq = document.createElement('blockquote');
bq.setAttribute('style', 'margin:0 0 8px 0;padding:8px 16px;border-left:3px solid #4f46e5;color:#555;background:rgba(79,70,229,0.04);border-radius:0 6px 6px 0');
const p = document.createElement('p');
p.setAttribute('style', 'margin:0');
fullText(s).split('\n').forEach((line, i, arr) => {
p.appendChild(document.createTextNode(line));
if (i < arr.length - 1) p.appendChild(document.createElement('br'));
});
bq.appendChild(p);
box.appendChild(bq);
replaceInner(s, box);
},
onAi: () => { },
},
qPlainText: {
onUser: (wrap, n) => {
const s = secOf(wrap, 'question');
if (!s) return;
const p = document.createElement('p');
p.setAttribute('style', 'margin:0');
p.appendChild(document.createTextNode(n + '. '));
fullText(s).split('\n').forEach((line, i) => {
if (i > 0) p.appendChild(document.createElement('br'));
p.appendChild(document.createTextNode(line));
});
replaceInner(s, p);
},
onAi: () => { },
},
};
// ==================== 模板预览 ====================
// 插件每张模板卡上方都有一段 132px 的「缩微排版预览」，用真实选中内容渲染，
// 让用户在点之前就看懂模板长什么样。这里按同样思路实现，但复用自己的标准化 DOM。
// 采集预览素材：既有问答时最多 2 组；只选提问时最多 8 条（与插件一致）
// 入参是记录数组 [{role, src}]，因此**已滚出视野的消息也能参与预览**。
function extractPreview(recs) {
const questions = [], answers = [];
const hasAi = recs.some(r => r.role === 'assistant');
for (const rec of recs) {
let wrap = null;
try { wrap = wrapFromSource(rec.role, rec.src, { includeReasoning: false }); } catch (e) { wrap = null; }
if (!wrap) continue;
// 剥掉自有属性与 style/class/id，只留语义标签（strong/code/table…），交给预览 CSS 接管
try {
[...wrap.querySelectorAll('*')].forEach(n => {
[...n.attributes].forEach(a => {
if (a.name.startsWith(OWN_ATTR_PREFIX) || a.name === 'style' || a.name === 'class' || a.name === 'id') {
n.removeAttribute(a.name);
}
});
});
} catch (e) { /* 忽略 */ }
const html = String(wrap.innerHTML || '').trim();
if (!html) continue;
if (rec.role === 'assistant') answers.push(html); else questions.push(html);
if (hasAi) {
if (questions.length >= 2 && answers.length >= 2) break;
} else if (questions.length >= 8) break;
}
return { questions, answers };
}
// 按纯文本长度截断但**保留 DOM 结构**（对应插件 getPreviewHtml 里的 u()）
function clipHtml(html, limit) {
if (!html) return '';
const holder = document.createElement('div');
holder.innerHTML = html;
if (String(holder.textContent || '').length <= limit) return html;
let used = 0;
const out = document.createElement('div');
const walk = (node, parent) => {
if (used >= limit) return false;
if (node.nodeType === Node.TEXT_NODE) {
const room = limit - used;
const text = node.textContent || '';
if (text.length > room) {
parent.appendChild(document.createTextNode(text.slice(0, room) + '...'));
used = limit;
return false;
}
parent.appendChild(node.cloneNode(true));
used += text.length;
} else if (node.nodeType === Node.ELEMENT_NODE) {
const el = node.cloneNode(false);
parent.appendChild(el);
for (const child of node.childNodes) if (!walk(child, el)) return false;
}
return true;
};
for (const child of holder.childNodes) if (!walk(child, out)) break;
return out.innerHTML;
}
// 取纯文本摘要并转义（对应插件的 h()）
function plainHtml(html, limit) {
if (!html) return '';
const holder = document.createElement('div');
holder.innerHTML = html;
const text = String(holder.textContent || '').replace(/\s+/g, ' ').trim();
if (!text) return '';
const cut = text.length > limit ? text.slice(0, limit) + '...' : text;
const esc = document.createElement('div');
esc.textContent = cut;
return esc.innerHTML;
}
const pvC = (inner, mod) => (inner ? `
${inner}` : '');
// 每套模板的缩微预览骨架（结构对齐插件，类名改用自己的 ds-md-pv-* 前缀）
function previewHtml(id, texts) {
const q = (texts && texts.questions) || [];
const a = (texts && texts.answers) || [];
const n = q[0] || '', o = q[1] || '', r = q[2] || '', i = q[3] || '', s4 = q[4] || '', s5 = q[5] || '';
const l = a[0] || '', d = a[1] || '';
const line = (cls, html) => `${html}`;
const H1 = 'ds-md-pv-line--h1', BOLD = 'ds-md-pv-line--bold', ACC = 'ds-md-pv-line--accent';
const MUTED = 'ds-md-pv-c--muted';
const div = '';
const gap = '';
const sec = (inner) => `${inner}`;
const maps = {
plain: () => sec(pvC(clipHtml(n, 200))) +
(l ? gap + sec(pvC(clipHtml(l, 200))) : ''),
structured: () => sec(
line(H1, '1、' + plainHtml(n, 15)) +
line(BOLD, '问题详情：') +
pvC(clipHtml(n, 100), MUTED) + gap +
line(BOLD, '回答（Answer）：') + pvC(clipHtml(l, 150))
) + (o ? div + sec(
line(H1, '2、' + plainHtml(o, 15)) +
line(BOLD, '问题详情：') +
pvC(clipHtml(o, 100), MUTED) + gap +
line(BOLD, '回答（Answer）：') + pvC(clipHtml(d, 150))
) : ''),
conversation: () => sec(
line(BOLD, '提问：') + pvC(clipHtml(n, 100), MUTED) + gap +
line(BOLD, '回答：') + pvC(clipHtml(l, 200))
) + (o ? div + sec(
line(BOLD, '提问：') + pvC(clipHtml(o, 100), MUTED) + gap +
line(BOLD, '回答：') + pvC(clipHtml(d, 200))
) : ''),
knowledgeDoc: () => sec(
line(H1, '1. ' + plainHtml(n, 40)) + pvC(clipHtml(l, 250))
) + (o ? gap + sec(
line(H1, '2. ' + plainHtml(o, 40)) + pvC(clipHtml(d, 250))
) : ''),
rolePlay: () => sec(
line(BOLD, '我说：') + pvC(clipHtml(n, 100), MUTED) + gap +
line(BOLD, 'DeepSeek说：') + pvC(clipHtml(l, 200))
) + (o ? div + sec(
line(BOLD, '我说：') + pvC(clipHtml(o, 100), MUTED) + gap +
line(BOLD, 'DeepSeek说：') + pvC(clipHtml(d, 200))
) : ''),
qStructured: () => sec(
line(H1, '1、' + plainHtml(n, 15)) +
line(BOLD, '问题详情：') + pvC(clipHtml(n, 160), MUTED)
) + (o ? div + sec(
line(H1, '2、' + plainHtml(o, 15)) +
line(BOLD, '问题详情：') + pvC(clipHtml(o, 160), MUTED)
) : ''),
qOutline: () => sec(line(H1, '1. ' + plainHtml(n, 60))) +
(o ? sec(line(H1, '2. ' + plainHtml(o, 60))) : '') +
(r ? sec(line(H1, '3. ' + plainHtml(r, 60))) : '') +
(i ? sec(line(H1, '4. ' + plainHtml(i, 60))) : '') +
(s4 ? sec(line(H1, '5. ' + plainHtml(s4, 60))) : ''),
qCards: () => `` +
line(ACC + ' ' + BOLD, 'Q1：') +
`${pvC(clipHtml(n, 140))}` +
(o ? `` +
line(ACC + ' ' + BOLD, 'Q2：') +
`${pvC(clipHtml(o, 140))}` : ''),
qPlainText: () => sec(
line('', '1. ' + plainHtml(n, 92)) +
(o ? line('', '2. ' + plainHtml(o, 92)) : '') +
(r ? line('', '3. ' + plainHtml(r, 92)) : '') +
(i ? line('', '4. ' + plainHtml(i, 92)) : '') +
(s4 ? line('', '5. ' + plainHtml(s4, 92)) : '') +
(s5 ? line('', '6. ' + plainHtml(s5, 92)) : '')
),
};
const fn = maps[id];
return fn ? fn() : '';
}
// 按选中内容返回可选模板清单：
// 只有提问（无回答）→ 问题清单类；否则 → 问答类
function templatesFor(hasUser, hasAi) {
const base = (hasUser && !hasAi) ? QUESTION_TEMPLATES : TEMPLATES;
return [TEMPLATE_PLAIN].concat(base);
}
// 采集当前对话的记录（键驱动）。虚拟列表下会先刷新可见消息的来源快照，
// 已滚过的消息保留早先的快照 —— 两者合起来才是「整段对话」。
function collectRecords() {
rememberMessages();
// pending：已虚拟化但尚未扫描时，窗口外还有消息（扫描后即为 0）
let pending = 0;
try {
if (isVirtualized() && !scanDone) {
const sc = findScrollContainer();
if (sc && maxScrollTop(sc) > 40) pending = -1; // -1 = 数量未知
}
} catch (e) { pending = 0; }
return { keys: orderedKeys(), pending };
}
// ---------- 文件名生成 ----------
const FALLBACK_TITLE = 'DeepSeek对话';
function resolveTitle() {
let t = String(document.title || '').trim();
const SUFFIX = ' - DeepSeek';
if (t.endsWith(SUFFIX)) t = t.slice(0, -SUFFIX.length).trim();
return t || FALLBACK_TITLE;
}
const pad2 = (n) => String(n).padStart(2, '0');
// 插件格式：YYYY-MM-DD-HH-mm（带时分，避免同日多次导出互相覆盖）
function formatExportDate(d) {
const t = (d instanceof Date && !Number.isNaN(d.getTime())) ? d : new Date();
return `${t.getFullYear()}-${pad2(t.getMonth() + 1)}-${pad2(t.getDate())}-${pad2(t.getHours())}-${pad2(t.getMinutes())}`;
}
// 空格→下划线、Windows 非法字符→下划线、截断 50 字（与插件一致）
function sanitizeFilename(name) {
return (String(name == null ? '' : name).trim() || FALLBACK_TITLE)
.replace(/\s+/g, '_')
.replace(/[<>:"/\\|?*]/g, '_')
.substring(0, 50);
}
function buildFilename(ext) {
const base = resolveTitle();
const stamp = mdExportAppendDate ? formatExportDate() : '';
return sanitizeFilename(stamp ? `${base}-${stamp}` : base) + '.' + ext;
}
function download(md, filename) {
const blob = new Blob([md], { type: 'text/markdown;charset=utf-8' }); // 注意：Markdown 不写 BOM
const url = URL.createObjectURL(blob);
const a = document.createElement('a');
a.href = url;
a.download = filename;
a.style.display = 'none';
document.body.appendChild(a);
a.click();
document.body.removeChild(a);
setTimeout(() => URL.revokeObjectURL(url), 100);
}
// opts: { includeReasoning, templateId, selectedKeys(Set|null) }
// 注意：**没有**「仅导出 AI 回答」这类选项 —— 导出哪些消息由勾选态决定
//（对应插件第 ① 步的「全选提问 / 全选AI回答」）。在弹窗里再放一个同类开关会与之打架。
function buildMarkdown(opts) {
const o = opts && typeof opts === 'object' ? opts : {};
const includeReasoning = o.includeReasoning === true;
const templateId = o.templateId || null;
const sel = o.selectedKeys instanceof Set ? o.selectedKeys : null;
const { keys, pending } = collectRecords();
if (!keys.length) return { ok: false, error: '未找到对话消息，请确认已打开一个对话。' };
const list = sel ? keys.filter(k => sel.has(k)) : keys;
if (!list.length) return { ok: false, error: '没有选中的消息。' };
const recs = list.map(k => sourceCache.get(k)).filter(Boolean);
if (!recs.length) return { ok: false, error: '没有可导出的内容。' };
const hasUser = recs.some(r => r.role === 'user');
const hasAi = recs.some(r => r.role === 'assistant');
const dec = templateId && TEMPLATE_DECORATORS[templateId] ? TEMPLATE_DECORATORS[templateId] : null;
const parts = [];
let aiCount = 0, userCount = 0, reasoningFound = 0;
recs.forEach(rec => {
const wrap = wrapFromSource(rec.role, rec.src, { includeReasoning });
if (!wrap) return;
// 模板装饰：用户消息序号自增（供模板编号使用）
if (rec.role === 'user') userCount++;
if (dec) {
const fn = rec.role === 'user' ? dec.onUser : dec.onAi;
try { if (typeof fn === 'function') fn(wrap, userCount); } catch (e) { console.warn('[deepseektool] 模板装饰失败：', e); }
}
const md = toMarkdown(wrap);
if (!md) return;
if (rec.role === 'assistant') {
aiCount++;
// 「勾了导出思考过程却什么都没多」是高频困惑点 —— 统计实际命中数，交给提示层回显
if (includeReasoning && rec.src && rec.src.reasoningHTML) reasoningFound++;
}
parts.push(md);
});
if (!parts.length) return { ok: false, error: '对话内容为空。' };
const head = '# ' + resolveTitle() + '\n\n';
const body = parts.join('\n\n---\n\n');
return { ok: true, md: head + body + '\n', count: parts.length, aiCount, pending, hasUser, hasAi, reasoningFound };
}
// ---------- 稳定键 / 来源快照 / 全对话扫描 ----------
// 三者配合才能把长对话导全：
//
// 为什么必须这样做：DeepSeek 用虚拟列表渲染，**只渲染可视窗口内的消息**；
// 一旦滚过去，React 会卸载这些节点。所以
// ① 选择状态必须按「稳定键」而非元素引用保存（否则滚出视野就丢选中）；
// ② 必须在消息可见的当下就**快照**其原始素材，导出时才有东西可用。
// 稳定键：优先虚拟列表项 key（跨滚动不变），回退 DOM 序号
function stableKeyOf(msgEl, index) {
try {
const item = msgEl && msgEl.closest ? msgEl.closest(SEL.VIRTUAL_ITEM) : null;
const k = item && item.getAttribute('data-virtual-list-item-key');
if (k && String(k).trim()) return 'vk:' + String(k).trim();
} catch (e) { /* 忽略 */ }
const i = typeof index === 'number' ? index : msgsInDom().indexOf(msgEl);
return 'ix:' + (i >= 0 ? i : 0);
}
// 稳定键排序（对齐插件 7448 compareStableKeys：同前缀按数字，否则中文序）
function compareStableKeys(a, b) {
const parse = (s) => {
const m = /^([a-z]+):(-?\d+)$/i.exec(String(s == null ? '' : s).trim());
return m ? { p: m[1].toLowerCase(), n: Number(m[2]) } : null;
};
const x = parse(a), y = parse(b);
if (x && y && x.p === y.p) return x.n - y.n;
return String(a).localeCompare(String(b), 'zh-Hans-CN');
}
// 来源快照：只存**原始素材**（问题体 / 思考体 / 答案体的 HTML），与导出选项解耦，
// 这样「包含思考过程」等选项在导出时才生效，不污染快照。
function snapshotSource(msgEl, role) {
if (!msgEl) return null;
if (role === 'assistant') {
const ai = resolveAiContent(msgEl);
if (!ai) return null;
let reasoningHTML = '';
try {
const nodes = collectReasoningNodes(msgEl);
if (nodes.length) reasoningHTML = nodes.map(n => n.outerHTML).join('');
} catch (e) { /* 忽略 */ }
return { role, reasoningHTML, answerHTML: ai.outerHTML };
}
const root = resolveUserRoot(msgEl);
if (!root) return null;
return { role, questionHTML: root.outerHTML };
}
const sourceCache = new Map(); // key -> { key, role, src }
let orderList = []; // 已发现的键，按对话顺序
let scanDone = false;
const noteOrder = (keys) => { keys.forEach(k => { if (k && !orderList.includes(k)) orderList.push(k); }); };
const orderedKeys = () => orderList.filter(k => sourceCache.has(k));
// 把当前 DOM 里的可见消息写入缓存（可见的重取，保证流式内容最新；已滚过的保留旧快照）
function rememberMessages() {
const list = msgsInDom();
const keys = [];
list.forEach((el, i) => {
const key = stableKeyOf(el, i);
const role = resolveAiContent(el) ? 'assistant' : 'user';
let src = null;
try { src = snapshotSource(el, role); } catch (e) { src = null; }
if (!src) return;
sourceCache.set(key, { key, role, src });
keys.push(key);
});
noteOrder(keys);
return keys;
}
// 找出承载消息列表的滚动容器
// 对齐插件 module 1996 findVirtualListScrollContainer：从虚拟列表容器出发**沿祖先链向上**
// 找第一个 overflowY ∈ {auto,scroll} 且确实可滚动的元素。
// ⚠ 绝不能全页扫 .ds-scroll-area —— 实测页面上有 30+ 个（代码块横向滚动区、侧栏、以及
// 装饰性的 .ds-scroll-area__gutters），"第一个可滚动的"往往**根本不含消息**；
// 一旦滚错容器，扫描会静默地一条也采集不到。
function findScrollContainer() {
let list = null;
try { list = document.querySelector(SEL.VIRTUAL_LIST); } catch (e) { list = null; }
if (list) {
let node = list.parentElement;
while (node && node !== document.body) {
let oy = '';
try { oy = String(getComputedStyle(node).overflowY || ''); } catch (e) { oy = ''; }
if ((oy === 'auto' || oy === 'scroll') && node.scrollHeight > node.clientHeight + 4) return node;
node = node.parentElement;
}
}
// 回退：整页滚动（非虚拟化或列表未用内层滚动时）
try {
const se = document.scrollingElement;
if (se && se.scrollHeight > se.clientHeight) return se;
} catch (e) { /* 忽略 */ }
return null;
}
const isVirtualized = () => !!document.querySelector(SEL.VIRTUAL_LIST);
const maxScrollTop = (sc) => (sc ? Math.max(0, sc.scrollHeight - sc.clientHeight) : 0);
const nextPaint = (n) => new Promise(res => {
const tick = (k) => (k <= 0 ? res() : requestAnimationFrame(() => tick(k - 1)));
tick(Math.max(1, n || 1));
});
// 窗口签名：当前渲染出来的消息键序列（不变即视为稳定）
const windowSignature = () => msgsInDom().map((el, i) => stableKeyOf(el, i)).join(',');
// 等待窗口稳定：连续两次签名一致即返回（上限 24 次，对齐插件）
async function waitWindowStable(sc, maxTries) {
const tries = maxTries || 24;
let prev = '';
for (let i = 0; i < tries; i++) {
await nextPaint(1);
const sig = windowSignature();
if (sig && sig === prev) return true;
prev = sig;
}
return !!prev;
}
// 单步采集：滚到指定位置 → 等稳定 → 记录窗口内消息
async function captureAt(sc, top) {
sc.scrollTop = Math.max(0, Math.min(maxScrollTop(sc), Math.round(top)));
await waitWindowStable(sc);
// 图表态代码块先切回代码视图，保证快照里 pre 有内容
try { if (needsCodeViewSwitch(document)) await ensureCodeView(document); } catch (e) { /* 忽略 */ }
// 内容还没渲染出来时，多给几次机会
let keys = rememberMessages();
for (let i = 0; i < 3 && !keys.length; i++) {
await new Promise(r => setTimeout(r, 40));
await waitWindowStable(sc);
keys = rememberMessages();
}
return keys;
}
// 全对话扫描：逐步滚过整段对话，边滚边快照（对齐插件 discover() 的主循环）
async function scanAll() {
if (scanDone) return true;
const sc = findScrollContainer();
if (!sc || maxScrollTop(sc) < 40) { scanDone = true; rememberMessages(); return true; }
const original = sc.scrollTop;
const step = Math.max(240, Math.floor(0.45 * sc.clientHeight));
orderList = []; // 按滚动顺序重建对话顺序
showNotice('正在扫描整段对话，请稍候…');
if (controlsEl) controlsEl.classList.add(CLS.SCANNING);
document.body.classList.add(CLS.SCANNING);
try {
let pos = 0, guard = 0;
while (guard < 400) {
guard++;
const keys = await captureAt(sc, pos);
if (!keys.length && pos >= maxScrollTop(sc)) break;
if (pos >= maxScrollTop(sc)) break;
const next = Math.min(maxScrollTop(sc), pos + step);
if (next <= pos + 1) break;
pos = next;
}
// 再冲几次底部，确保末尾消息被渲染
for (let i = 0; i < 3; i++) await captureAt(sc, maxScrollTop(sc));
// 兜底：把缓存里剩下没进顺序表的键按稳定键排序补到末尾
[...sourceCache.keys()].forEach(k => { if (!orderList.includes(k)) orderList.push(k); });
orderList.sort((a, b) => {
const ia = orderList.indexOf(a), ib = orderList.indexOf(b);
return ia - ib;
});
scanDone = true;
return true;
} finally {
sc.scrollTop = original;
await waitWindowStable(sc);
rememberMessages(); // 恢复视野后刷新一次可见消息
hideNotice();
if (controlsEl) controlsEl.classList.remove(CLS.SCANNING);
document.body.classList.remove(CLS.SCANNING);
}
}
// ---------- 图表态代码块切回「代码」视图 ----------
// 对齐插件 module 230：双 Tab（代码/图表）且当前不在代码视图 → 需要切换。
// **不需要主世界注入**：DOM 在两个 world 间共享，React 的委托监听挂在 document 上，
// 沙箱内 click() 派发的真实事件它能收到 —— 顺带绕开页面 CSP 拦截内联脚本的风险。
const TAB_SEL = 'div[role="tab"], .ds-segmented-button';
function getSwitchTabs(block) {
let tabs = [];
try { tabs = [...block.querySelectorAll(TAB_SEL)]; } catch (e) { return { hasCode: false, hasDiagram: false, codeSelected: false, codeTab: null }; }
let hasCode = false, hasDiagram = false, codeSelected = false, codeTab = null;
tabs.forEach(t => {
const text = String(t.textContent || '').trim();
if (!text) return;
const low = text.toLowerCase();
const sel = t.getAttribute('aria-selected') === 'true' ||
(t.classList && t.classList.contains('ds-segmented-button--selected'));
if (text.includes('代码') || low.includes('code')) { hasCode = true; codeTab = t; if (sel) codeSelected = true; }
if (text.includes('图表') || low.includes('chart') || low.includes('diagram')) hasDiagram = true;
});
return { hasCode, hasDiagram, codeSelected, codeTab };
}
function needsCodeViewSwitch(scope) {
let blocks = [];
try { blocks = [...scope.querySelectorAll(SEL.CODE_BLOCK)]; } catch (e) { return false; }
for (const b of blocks) {
const t = getSwitchTabs(b);
if (!t.hasCode || !t.hasDiagram) continue;
if (!t.codeSelected) return true;
let hasPre = false;
try { hasPre = !!(b.querySelector('pre code') || b.querySelector('pre')); } catch (e) { hasPre = false; }
if (!hasPre) return true;
}
return false;
}
// 切回代码视图并轮询等待（对齐插件 6 × 30ms）
async function ensureCodeView(scope) {
if (!scope) return false;
let blocks = [];
try { blocks = [...scope.querySelectorAll(SEL.CODE_BLOCK)]; } catch (e) { return false; }
let clicked = false;
blocks.forEach(b => {
const t = getSwitchTabs(b);
if (!t.hasCode || !t.hasDiagram || t.codeSelected) return;
try { if (t.codeTab) { t.codeTab.click(); clicked = true; } } catch (e) { /* 忽略 */ }
});
if (!clicked) return false;
for (let i = 0; i < 6; i++) {
await new Promise(r => setTimeout(r, 30));
if (!needsCodeViewSwitch(scope)) return true;
}
return false;
}
// ---------- 右上角提示条（对齐插件 components/feedback/notice.css） ----------
let noticeEl = null;
function showNotice(text) {
hideNotice();
noticeEl = document.createElement('div');
noticeEl.className = 'ds-md-notice';
noticeEl.innerHTML = '' +
'' +
'';
noticeEl.querySelector('.ds-md-notice-message').textContent = text;
document.body.appendChild(noticeEl);
}
function hideNotice() {
if (!noticeEl) return;
const el = noticeEl;
noticeEl = null;
try {
el.classList.add('closing');
setTimeout(() => { try { el.remove(); } catch (e) { /* 忽略 */ } }, 200);
} catch (e) { try { el.remove(); } catch (e2) { /* 忽略 */ } }
}
// ---------- 选择模式 ----------
// 勾选态：复选框注入 + 控制条 + 选中高亮。
const CLS = {
ACTIVE: 'ds-md-selection-active',
SCANNING: 'ds-md-selection-scanning',
CB_WRAP: 'ds-md-cb-wrap',
CB_USER: 'ds-md-cb-user',
CB_AI: 'ds-md-cb-ai',
CB: 'ds-md-checkbox',
SELECTED: 'ds-md-msg-selected',
SEL_USER: 'ds-md-msg-user',
SEL_AI: 'ds-md-msg-ai',
CONTROLS: 'ds-md-controls',
SELECT_ALL: 'ds-md-select-all',
SELECT_USER: 'ds-md-select-user',
SELECT_AI: 'ds-md-select-ai',
EXPORT_SEL: 'ds-md-export-selected',
CANCEL: 'ds-md-cancel-sel',
HINT: 'ds-md-sel-hint',
MODAL: 'ds-md-modal',
DIALOG: 'ds-md-dialog',
STEP_CONTENT: 'ds-md-step-content',
STEP_TEMPLATE: 'ds-md-step-template',
FMT_BTN: 'ds-md-fmt-btn',
TPL_CARD: 'ds-md-template-card',
REMEMBER: 'ds-md-remember',
BACK: 'ds-md-back',
ACTIONS: 'ds-md-dlg-actions',
CANCEL_DLG: 'ds-md-dlg-cancel',
TITLE: 'ds-md-dlg-title',
SUB: 'ds-md-dlg-sub',
};
const selectedKeys = new Set(); // 选中的**稳定键**（不是元素引用）
let selectionActive = false;
let selObserver = null;
let controlsEl = null;
let syncTimer = null;
let dialogEl = null;
let dialogCleanup = null;
const msgsInDom = () => [...document.querySelectorAll(SEL.MESSAGE)];
function attachCheckbox(msgEl, isUser, key) {
if (!msgEl) return;
const k = key || stableKeyOf(msgEl);
let wrap = null, cb = null;
try { wrap = msgEl.querySelector('.' + CLS.CB_WRAP); } catch (e) { wrap = null; }
if (wrap) {
cb = wrap.querySelector('.' + CLS.CB);
wrap.classList.toggle(CLS.CB_USER, isUser);
wrap.classList.toggle(CLS.CB_AI, !isUser);
} else {
wrap = document.createElement('div');
wrap.className = CLS.CB_WRAP + ' ' + (isUser ? CLS.CB_USER : CLS.CB_AI);
cb = document.createElement('input');
cb.type = 'checkbox';
cb.className = CLS.CB;
cb.setAttribute('aria-label', '选择此条消息');
cb.addEventListener('change', (e) => {
e.stopPropagation();
// 每次现算键：React 会重建节点，闭包里捕获的旧节点可能已脱离文档
const live = stableKeyOf(msgEl);
if (e.target.checked) selectedKeys.add(live); else selectedKeys.delete(live);
applyHighlight(msgEl);
updateControls();
});
wrap.appendChild(cb);
// 挂载前确保定位上下文（否则 absolute 复选框会跑到页面左上角）
if (getComputedStyle(msgEl).position === 'static') msgEl.style.position = 'relative';
msgEl.appendChild(wrap);
}
if (cb) { cb.dataset.mdKey = k; cb.checked = selectedKeys.has(k); }
}
function syncCheckboxes() {
rememberMessages(); // 先刷新可见消息的来源快照（键驱动的前提）
const list = msgsInDom();
list.forEach((el, i) => {
const key = stableKeyOf(el, i);
attachCheckbox(el, !resolveAiContent(el), key);
});
list.forEach(applyHighlight);
}
function removeCheckboxes() {
document.querySelectorAll('.' + CLS.CB_WRAP).forEach(el => {
try {
const msg = el.closest ? el.closest(SEL.MESSAGE) : null;
if (msg) msg.style.position = '';
} catch (e) { /* 忽略 */ }
el.remove();
});
document.querySelectorAll('.' + CLS.SELECTED).forEach(el => {
el.classList.remove(CLS.SELECTED, CLS.SEL_USER, CLS.SEL_AI);
el.style.position = '';
});
}
function highlightTarget(msgEl, isUser) {
if (!msgEl || !isUser) return msgEl;
try {
const r = resolveUserRoot(msgEl);
if (r && r !== msgEl) return r;
} catch (e) { /* 忽略 */ }
return msgEl;
}
function clearHighlight(msgEl, keep) {
if (!msgEl || !msgEl.querySelectorAll) return;
const clear = (n) => {
if (!n || n === keep) return;
try { n.classList.remove(CLS.SELECTED, CLS.SEL_USER, CLS.SEL_AI); } catch (e) { /* 忽略 */ }
};
clear(msgEl);
try { msgEl.querySelectorAll('.' + CLS.SELECTED).forEach(clear); } catch (e) { /* 忽略 */ }
}
function applyHighlight(msgEl) {
if (!msgEl) return;
const isUser = !resolveAiContent(msgEl);
const on = selectedKeys.has(stableKeyOf(msgEl));
try {
const cb = msgEl.querySelector('.' + CLS.CB);
if (cb) cb.checked = on;
} catch (e) { /* 忽略 */ }
const t = highlightTarget(msgEl, isUser);
clearHighlight(msgEl, t);
if (!t) return;
t.classList.toggle(CLS.SELECTED, on);
t.classList.remove(CLS.SEL_USER, CLS.SEL_AI);
if (on) t.classList.add(isUser ? CLS.SEL_USER : CLS.SEL_AI);
}
function createControls() {
const box = document.createElement('div');
box.className = CLS.CONTROLS;
const mk = (cls, text, onClick) => {
const b = document.createElement('button');
b.type = 'button';
b.className = cls;
b.textContent = text;
b.addEventListener('click', e => { e.stopPropagation(); onClick(); });
return b;
};
const all = mk(CLS.SELECT_ALL, '全选', () => { void selectAll(); });
const user = mk(CLS.SELECT_USER, '全选提问', () => { void selectByRole('user'); });
const ai = mk(CLS.SELECT_AI, '全选AI回答', () => { void selectByRole('assistant'); });
const exp = mk(CLS.EXPORT_SEL, '导出选中 (0)', () => { void exportSelected(); });
const cancel = mk(CLS.CANCEL, '取消', () => stopSelection());
const hint = document.createElement('div');
hint.className = CLS.HINT;
hint.textContent = '可手动勾选想要导出的内容';
const tail = document.createElement('div');
tail.className = 'ds-md-cancel-wrap';
tail.appendChild(cancel);
tail.appendChild(hint);
box.appendChild(all);
box.appendChild(user);
box.appendChild(ai);
box.appendChild(exp);
box.appendChild(tail);
return box;
}
let busyCount = 0; // 进行中的扫描次数（>0 时禁用控制条按钮）
function updateControls() {
if (!controlsEl) return;
const total = orderedKeys().length;
const n = selectedKeys.size;
const q = (s) => controlsEl.querySelector('.' + s);
const expBtn = q(CLS.EXPORT_SEL);
const allBtn = q(CLS.SELECT_ALL);
const userBtn = q(CLS.SELECT_USER);
const aiBtn = q(CLS.SELECT_AI);
const hint = q(CLS.HINT);
const busy = busyCount > 0;
if (hint) {
hint.textContent = n > 0 ? '可手动勾选想要导出的内容' : '当前页无对话内容';
hint.classList.toggle('is-ok', n > 0); // 有选中 → 灰字提示；无选中 → 红字警告
}
[allBtn, userBtn, aiBtn].forEach(b => { if (b) b.disabled = busy || total === 0; });
if (expBtn) {
expBtn.textContent = `导出选中 (${n})`;
expBtn.disabled = busy || n <= 0;
}
if (allBtn) allBtn.textContent = (n > 0 && n === total) ? '取消全选' : '全选';
}
// 需要时先扫全对话（虚拟列表下才真正滚动；短对话直接标记完成）
async function ensureScanned() {
if (scanDone) return true;
if (!isVirtualized()) { scanDone = true; rememberMessages(); return true; }
busyCount++;
updateControls();
try {
return await scanAll();
} catch (e) {
console.warn('[deepseektool] 扫描对话失败：', e);
return false;
} finally {
busyCount = Math.max(0, busyCount - 1);
syncCheckboxes();
updateControls();
}
}
async function selectAll() {
await ensureScanned();
const keys = orderedKeys();
const willSelect = selectedKeys.size < keys.length;
selectedKeys.clear();
if (willSelect) keys.forEach(k => selectedKeys.add(k));
syncCheckboxes();
updateControls();
}
async function selectByRole(role) {
await ensureScanned();
selectedKeys.clear();
orderedKeys().forEach(k => {
const rec = sourceCache.get(k);
if (rec && rec.role === role) selectedKeys.add(k);
});
syncCheckboxes();
updateControls();
}
function startObserver() {
stopObserver();
selObserver = new MutationObserver(muts => {
let need = false;
for (const m of muts) {
if (m.type !== 'childList' || !m.addedNodes.length) continue;
for (const node of m.addedNodes) {
if (node.nodeType !== Node.ELEMENT_NODE) continue;
// 只认「新增了消息或含消息的子树」；复选框自身注入不会命中 → 不自激
if ((node.matches && node.matches(SEL.MESSAGE)) ||
(node.querySelector && node.querySelector(SEL.MESSAGE))) { need = true; break; }
}
if (need) break;
}
if (!need) return;
clearTimeout(syncTimer);
syncTimer = setTimeout(() => { if (selectionActive) { syncCheckboxes(); updateControls(); } }, 150);
});
selObserver.observe(document.body, { childList: true, subtree: true });
}
function stopObserver() {
clearTimeout(syncTimer);
syncTimer = null;
if (selObserver) { try { selObserver.disconnect(); } catch (e) { /* 忽略 */ } selObserver = null; }
}
function startSelection() {
if (selectionActive) return true;
if (!msgsInDom().length) { showToast('当前页无对话内容'); return false; }
selectionActive = true;
// 每次进入都是全新会话：清空上轮的键、顺序与快照（避免跨对话残留）
selectedKeys.clear();
sourceCache.clear();
orderList = [];
scanDone = false;
busyCount = 0;
document.body.classList.add(CLS.ACTIVE);
syncCheckboxes();
controlsEl = createControls();
document.body.appendChild(controlsEl);
updateControls();
startObserver();
document.addEventListener('keydown', onSelectionKey, true);
return true;
}
function onSelectionKey(e) {
if (!selectionActive) return;
if (e.key !== 'Escape') return;
if (document.querySelector('.' + CLS.MODAL)) return; // 模态框打开时 Esc 归模态框处理
e.stopPropagation();
stopSelection();
}
function stopSelection() {
if (!selectionActive) return;
selectionActive = false;
selectedKeys.clear();
document.body.classList.remove(CLS.ACTIVE, CLS.SCANNING);
document.removeEventListener('keydown', onSelectionKey, true);
stopObserver();
hideNotice();
removeCheckboxes();
if (controlsEl) { try { controlsEl.remove(); } catch (e) { /* 忽略 */ } controlsEl = null; }
}
// ---------- 模态框（两步：导出内容 → 内容模板） ----------
// 两步弹窗。本工具只有 Markdown 一种格式，故步 1 只列格式
// 不作为分叉条件（点格式即进入步 2），并把「记住我的选择」用于**预填**而非跳过模板步。
// 弹窗选项的唯一来源：用户上次勾了「记住我的选择」才生效；否则一律走硬编码默认值。
// 绝不回落读旧设置键 —— 那会让一个已从设置面板移除的开关继续隐形生效。
// 默认「导出思考过程 = 开」。
const DEFAULT_INCLUDE_REASONING = true;
const ALL_TEMPLATE_IDS = new Set(
[TEMPLATE_PLAIN.id].concat(TEMPLATES.map(t => t.id), QUESTION_TEMPLATES.map(t => t.id))
);
function currentPrefs() {
let saved = null;
try { saved = JSON.parse(GM_getValue(STORAGE_MD_EXPORT_PREFS, '') || 'null'); } catch (e) { saved = null; }
// 只有用户真的勾过「记住我的选择」才会有落库值；没有就用默认
const hasSaved = !!saved && typeof saved === 'object';
const s = hasSaved ? saved : {};
return {
includeReasoning: typeof s.includeReasoning === 'boolean' ? s.includeReasoning : DEFAULT_INCLUDE_REASONING,
templateId: ALL_TEMPLATE_IDS.has(s.templateId) ? s.templateId : TEMPLATE_PLAIN.id,
remember: s.remember === true,
};
}
function savePrefs(p) {
try { GM_setValue(STORAGE_MD_EXPORT_PREFS, JSON.stringify(p)); } catch (e) { /* 忽略 */ }
}
// 清除记忆 = 清掉「记住我的选择」+ 一并归零 v1 遗留键（否则老用户会一直被隐形开关影响）
function clearPrefs() {
try { GM_setValue(STORAGE_MD_EXPORT_PREFS, ''); } catch (e) { /* 忽略 */ }
LEGACY_MD_KEYS.forEach(k => { try { GM_setValue(k, false); } catch (e) { /* 忽略 */ } });
}
const templateNameOf = (id) => {
if (!id) return '';
if (id === TEMPLATE_PLAIN.id) return TEMPLATE_PLAIN.name;
const hit = TEMPLATES.concat(QUESTION_TEMPLATES).find(t => t.id === id);
return hit ? hit.name : '';
};
function openDialog() {
// 从缓存取记录（可能包含已滚出视野的消息）—— 这正是长对话能导全的原因
const recs = orderedKeys().filter(k => selectedKeys.has(k)).map(k => sourceCache.get(k)).filter(Boolean);
if (!recs.length) { showToast('请先选择要导出的消息'); return; }
closeDialog();
const hasUser = recs.some(r => r.role === 'user');
const hasAi = recs.some(r => r.role === 'assistant');
const nUser = recs.filter(r => r.role === 'user').length;
const nAi = recs.length - nUser;
const prefs = currentPrefs();
const tplList = templatesFor(hasUser, hasAi);
const previewTexts = extractPreview(recs); // 模板卡缩微预览的素材（最多 2 组问答）
const modal = document.createElement('div');
modal.className = CLS.MODAL;
modal.innerHTML = `
选择导出内容
即将导出 ${recs.length} 条消息（提问 ${nUser} 条 · 回答 ${nAi} 条）：
导出格式
`;
const q = (s) => modal.querySelector('.' + s);
const stepContent = q(CLS.STEP_CONTENT);
const stepTemplate = q(CLS.STEP_TEMPLATE);
const titleEl = q(CLS.TITLE);
const subEl = q(CLS.SUB);
const tplSub = modal.querySelector('.ds-md-tpl-sub');
const tplBox = modal.querySelector('.ds-md-template-options');
const rememberWrap = q(CLS.REMEMBER);
const rememberChk = modal.querySelector('.ds-md-chk-remember');
const actions = q(CLS.ACTIONS);
const reasoningChk = modal.querySelector('.ds-md-chk-reasoning');
const backBtn = q(CLS.BACK);
// 预填（来自上次「记住我的选择」）
reasoningChk.checked = prefs.includeReasoning;
rememberChk.checked = prefs.remember;
const readOpts = () => ({
includeReasoning: !!reasoningChk.checked,
templateId: null,
});
const persist = (templateId) => {
if (!rememberChk.checked) return;
const o = readOpts();
savePrefs({ includeReasoning: o.includeReasoning, templateId, remember: true });
};
const finish = (templateId) => {
const o = readOpts();
o.templateId = templateId;
persist(templateId);
// 必须先快照选中键：stopSelection() 会 clear() 掉 selectedKeys
const snapshot = new Set(selectedKeys);
closeDialog();
stopSelection();
runExport(o, snapshot);
};
const showContentStep = (animate) => {
stepContent.style.display = '';
stepTemplate.style.display = 'none';
titleEl.textContent = '选择导出内容';
subEl.textContent = `即将导出 ${recs.length} 条消息（提问 ${nUser} 条 · 回答 ${nAi} 条）：`;
actions.hidden = false;
rememberWrap.hidden = true; // 与插件一致：步 1 还没选模板，无可记住的内容
modal.querySelector('.' + CLS.DIALOG).classList.remove('is-template-step');
// 仅「从模板步返回」时播滑入动画（首次打开不播）
if (animate) {
stepContent.classList.add('step-slide-back');
requestAnimationFrame(() => stepContent.classList.remove('step-slide-back'));
}
};
const showTemplateStep = () => {
stepContent.style.display = 'none';
stepTemplate.style.display = '';
titleEl.textContent = '选择内容模板';
if (tplSub) tplSub.textContent = '点击所需模板即可导出：';
actions.hidden = true;
rememberWrap.hidden = false;
modal.querySelector('.' + CLS.DIALOG).classList.add('is-template-step');
// 模板清单已按选中内容（是否只有提问）确定，与步 1 的选项无关
renderTemplates();
stepTemplate.classList.add('step-slide-in');
requestAnimationFrame(() => stepTemplate.classList.remove('step-slide-in'));
};
function renderTemplates() {
tplBox.innerHTML = '';
tplList.forEach(t => {
const card = document.createElement('button');
card.type = 'button';
card.className = CLS.TPL_CARD;
card.dataset.template = t.id;
if (t.id === prefs.templateId) card.classList.add('is-remembered');
// 结构对齐插件：上半 = 132px 缩微预览，下半 = 名称 + 描述
const pv = document.createElement('div');
pv.className = 'ds-md-pv';
pv.innerHTML = previewHtml(t.id, previewTexts);
const info = document.createElement('div');
info.className = 'ds-md-tpl-info';
const nm = document.createElement('span');
nm.className = 'ds-md-tpl-name';
nm.textContent = t.name;
const ds = document.createElement('span');
ds.className = 'ds-md-tpl-desc';
ds.textContent = t.desc;
info.appendChild(nm);
info.appendChild(ds);
card.appendChild(pv);
card.appendChild(info);
card.addEventListener('click', () => finish(t.id));
tplBox.appendChild(card);
});
}
modal.querySelectorAll('.' + CLS.FMT_BTN).forEach(btn => {
btn.addEventListener('click', () => showTemplateStep());
});
backBtn.addEventListener('click', () => showContentStep(true));
q(CLS.CANCEL_DLG).addEventListener('click', () => { closeDialog(); }); // 回到选择态（不退出）
modal.querySelector('.ds-md-dlg-close').addEventListener('click', () => { closeDialog(); });
modal.addEventListener('click', (e) => { if (e.target === modal) closeDialog(); });
const onKey = (e) => { if (e.key === 'Escape') closeDialog(); };
document.addEventListener('keydown', onKey);
dialogCleanup = () => document.removeEventListener('keydown', onKey);
var _dialogInner = modal.querySelector('.' + CLS.DIALOG);
showContentStep();
document.body.appendChild(modal);
dialogEl = modal;
return true;
}
function closeDialog() {
if (dialogCleanup) { try { dialogCleanup(); } catch (e) { /* 忽略 */ } dialogCleanup = null; }
if (dialogEl) { try { dialogEl.remove(); } catch (e) { /* 忽略 */ } dialogEl = null; }
}
async function exportSelected() {
if (!selectedKeys.size) { showToast('请先选择要导出的消息'); return false; }
// 导出前确保已扫全（长对话下窗口外的消息只有扫过才有内容）
await ensureScanned();
// 图表态代码块切回代码视图并刷新快照 —— 否则 pre 为空，导出会丢代码
try {
if (needsCodeViewSwitch(document)) {
showNotice('正在切换代码视图…');
await ensureCodeView(document);
hideNotice();
rememberMessages();
}
} catch (e) { hideNotice(); }
if (!selectedKeys.size) { showToast('请先选择要导出的消息'); return false; }
return openDialog();
}
function runExport(o, selSet) {
let r;
try {
r = buildMarkdown({
includeReasoning: o.includeReasoning,
templateId: o.templateId,
selectedKeys: selSet instanceof Set ? selSet : new Set(selectedKeys),
});
} catch (e) {
console.error('[deepseektool] 导出 Markdown 失败：', e);
showToast('导出失败：' + (e && e.message ? e.message : '未知错误'));
return false;
}
if (!r.ok) { showToast(r.error); return false; }
download(r.md, buildFilename('md'));
// 把实际生效的选项写进提示 —— 「怎么少了内容」这类疑问必须一眼可见，而不是静默发生
let tip = `已导出 ${r.count} 条消息为 Markdown`;
const extras = [];
if (o.includeReasoning) extras.push('含思考过程');
const tplName = templateNameOf(o.templateId);
if (tplName) extras.push('模板：' + tplName);
if (extras.length) tip += `（${extras.join(' · ')}）`;
// 勾了「导出思考过程」但一条都没取到 → 明确告知原因，不要静默无声
if (o.includeReasoning && !r.reasoningFound) {
tip += '；未发现「已思考」内容，需先在页面上展开过才会被导出';
}
if (r.pending < 0) tip += '；对话较长，建议先点「全选」扫描后再导出';
showToast(tip, (o.includeReasoning && !r.reasoningFound) || r.pending < 0 ? 5200 : 4200);
return true;
}
// 菜单命令入口：直接进入勾选态
function beginExportFlow() {
if (!mdExportEnabled) { showToast('对话导出已关闭，请在「脚本设置 → 对话导出」中开启'); return false; }
return startSelection();
}
return {
beginExportFlow, startSelection, stopSelection, exportSelected, clearPrefs,
buildMarkdown, isSelecting: () => selectionActive,
SEL, ATTR,
};
})();
// ==================== 代码块导出为图片 ====================
// 把单个代码块渲染成「窗口卡片」样式的图片：背景 + 窗口 chrome + 代码体（可选行号）。
//
// 关键设计（依据真实页面实测，见 .workbuddy/research/code-export-image-trace.md）：
// 1. 官网高亮是 Prism token class（无内联色）→「浅色底 / 深色底」通过注入 CSS 覆盖实现；
// 2. 官网 .token / .md-code-block 规则读不到 cssRules → 必须自建完整样式与 token 色板；
// 3. 折叠态只是 max-height/overflow 的视觉裁剪，内容完整留在 DOM → 克隆后清样式即可拿全文，
// **绝不在原 DOM 上改动**（与表格导出同一条「克隆 + 隔离」原则）；
// 4. 官网 pre 计算样式为 white-space:pre-wrap，但实测最宽行 829px < 内容宽 858px、未触发折行；
// 导出统一强制 white-space:pre（不折行，卡片按最长行自适应宽），逻辑行 = 视觉行，行号 counter 1:1；
// 5. 复用既有 html2canvas（@require）与「离屏 iframe 隔离」渲染手法，零新增依赖 / 零新增权限。
const codeImageUnit = (() => {
const MONO_STACK = 'Menlo, Monaco, Consolas, "Cascadia Mono", "Ubuntu Mono", "DejaVu Sans Mono", "Liberation Mono", "JetBrains Mono", "Fira Code", Courier, monospace';
// 背景预设：渐变 / 纯色 / 透明
const BG_PRESETS = [
{ id: 'grad-indigo', css: 'linear-gradient(135deg, #667eea 0%, #764ba2 100%)', label: '靛蓝渐变' },
{ id: 'grad-sunset', css: 'linear-gradient(135deg, #fa709a 0%, #fee140 100%)', label: '日落渐变' },
{ id: 'grad-mint', css: 'linear-gradient(135deg, #43e97b 0%, #38f9d7 100%)', label: '薄荷渐变' },
{ id: 'grad-ocean', css: 'linear-gradient(135deg, #4facfe 0%, #00f2fe 100%)', label: '海洋渐变' },
{ id: 'grad-night', css: 'linear-gradient(135deg, #232526 0%, #414345 100%)', label: '深空渐变' },
{ id: 'solid-gray', css: '#e9edf2', label: '浅灰' },
{ id: 'solid-dark', css: '#1e1e24', label: '墨黑' },
{ id: 'transparent', css: 'transparent', label: '透明' },
];
const bgCssOf = (id) => {
const hit = BG_PRESETS.filter(p => p.id === id)[0];
return hit ? hit.css : BG_PRESETS[0].css;
};
// 浅色 / 深色代码色板。
// 取值来源：官网真机实测（comment / keyword / function / operator / constant / punctuation）
// + 标准 One Light / One Dark 对剩余 token 类型的约定。
// ⚠️ 这份色板只负责「导出底色与页面当前底色**不一致**」的跨主题场景；
// 底色一致时以 harvestTokenColors() 采到的页面实测色为准（见 buildShotCss）。
const THEME_LIGHT = {
name: 'light', bg: '#f3f4f6', text: '#383a42',
comment: '#a0a1a7', prolog: '#a0a1a7', cdata: '#a0a1a7',
keyword: '#a626a4', boolean: '#b76b01',
string: '#50a14f', 'template-string': '#50a14f', 'template-punctuation': '#50a14f',
'attr-value': '#50a14f', char: '#50a14f', regex: '#50a14f', variable: '#50a14f', inserted: '#50a14f',
number: '#b76b01', constant: '#b76b01', symbol: '#b76b01', 'attr-name': '#b76b01',
'class-name': '#b76b01', deleted: '#b76b01',
tag: '#e45649', selector: '#e45649',
function: '#4078f2', 'function-variable': '#4078f2', atrule: '#4078f2', operator: '#4078f2',
property: '#e45649', 'literal-property': '#e45649',
url: '#0184bc',
parameter: '#383a42', punctuation: '#383a42',
};
const THEME_DARK = {
name: 'dark', bg: '#282c34', text: '#abb2bf',
comment: '#5c6370', prolog: '#5c6370', cdata: '#5c6370',
keyword: '#c678dd',
string: '#98c379', 'template-string': '#98c379', 'template-punctuation': '#98c379',
'attr-value': '#98c379', char: '#98c379', regex: '#98c379', variable: '#98c379',
inserted: '#98c379', selector: '#98c379', builtin: '#98c379',
number: '#d19a66', constant: '#d19a66', boolean: '#d19a66',
'attr-name': '#d19a66', 'class-name': '#d19a66', atrule: '#d19a66',
function: '#61afef', 'function-variable': '#61afef',
property: '#e06c75', 'literal-property': '#e06c75', tag: '#e06c75', symbol: '#e06c75',
deleted: '#e06c75', important: '#e06c75',
operator: '#56b6c2', url: '#56b6c2',
parameter: '#abb2bf', punctuation: '#abb2bf',
};
const DEFAULT_OPTS = {
bg: 'grad-indigo', window: 'macos', padding: 32, shadow: true,
fontSize: 13, lineHeight: 22, lineNumbers: false, scale: 2, theme: '',
};
// ---------- 样式偏好读写（记住上次选择） ----------
function loadPrefs() {
try {
if (codeImagePrefs) return typeof codeImagePrefs === 'string' ? JSON.parse(codeImagePrefs) : codeImagePrefs;
} catch (_) { /* 数据损坏则忽略，回落默认 */ }
return {};
}
function savePrefs(p) {
codeImagePrefs = p;
try { GM_setValue(STORAGE_CODE_IMAGE_PREFS, JSON.stringify(p)); } catch (_) { /* 忽略 */ }
}
// ---------- 语言提取（来自 banner 文案，排除操作按钮文字） ----------
const OP_LABEL = /^(复制|下载|展开|收起|编辑|运行|预览|导出|copy|download|expand|collapse|edit|run)$/i;
function extractLang(block) {
const banner = block.querySelector('.md-code-block-banner-wrap');
if (!banner) return '';
for (const sp of banner.querySelectorAll('span')) {
const s = String(sp.textContent || '').trim();
if (!s || s.length > 40 || OP_LABEL.test(s)) continue;
return s.split(/\s+/)[0].toLowerCase();
}
return '';
}
// ---------- 克隆清洗（绝不改原 DOM） ----------
function cloneCodeBlockPre(block) {
if (!block) return null;
const clone = block.cloneNode(true);
const stripSvg = (root) => {
[...root.children].forEach(c => { if (c.tagName && c.tagName.toLowerCase() === 'svg') c.remove(); });
};
// 整条 banner（语言标签 + 官网按钮 + 折叠/导出按钮）与装饰 svg 一并剔除
clone.querySelectorAll('.md-code-block-banner-wrap').forEach(el => el.remove());
clone.querySelectorAll('.ds-fold-btn, .ds-code-export-btn, .table-internal-buttons').forEach(el => el.remove());
clone.removeAttribute('data-fold-processed');
stripSvg(clone);
const pre = clone.querySelector('pre');
if (!pre) return null;
// 清折叠态（仅在克隆体上操作）
pre.style.maxHeight = '';
pre.style.overflow = '';
pre.style.display = '';
pre.classList.remove('ds-fold-preview');
delete pre.dataset.origMaxHeight;
delete pre.dataset.origOverflow;
delete pre.dataset.origDisplay;
stripSvg(pre);
return pre;
}
function resolveTheme(opts) {
if (opts.theme === 'light') return THEME_LIGHT;
if (opts.theme === 'dark') return THEME_DARK;
return document.body.classList.contains('dark') ? THEME_DARK : THEME_LIGHT;
}
const isPageDark = () => document.body.classList.contains('dark');
// ---------- 页面实测 token 颜色采集 ----------
// 为什么需要它：官网高亮色定义在跨域样式表 / CSS-in-JS 里，cssRules 读不到，
// 自建色板又只能覆盖「我们想得到的」token 类型 —— 实测真机 html 代码块用的是
// tag / attr-name / attr-value，一度全部落在色板之外，导致 1264/1270 个
// 本来有颜色的 token 在导出图上掉回纯文字色。
// 但「当前页面正在渲染的 token」其计算色一定读得到：就地按类名采集，
// 既不依赖任何外部定义，也能自动覆盖官网后续新增的 token 类型。
// 仅用于「导出底色 == 页面当前底色」；跨主题时仍走自建色板，否则明暗会串味。
const TOKEN_CLS_OK = /^[A-Za-z_][\w-]*$/;
const RESERVED_KEYS = ['name', 'bg', 'text'];
function harvestTokenColors(root) {
const map = {};
if (!root || !root.querySelectorAll) return map;
root.querySelectorAll('.token').forEach(el => {
const color = getComputedStyle(el).color;
if (!color) return;
String(el.className).split(/\s+/).forEach(c => {
if (!c || c === 'token' || RESERVED_KEYS.indexOf(c) >= 0) return;
if (!TOKEN_CLS_OK.test(c) || c in map) return;
map[c] = color;
});
});
return map;
}
// ---------- 组装合成 DOM（背景 / 卡片 / 窗口 chrome / 代码体） ----------
function buildShotDom(pre, opts, theme) {
const root = document.createElement('div');
root.className = 'ds-shot-root';
root.style.cssText = `display:inline-block;padding:${opts.padding}px;background:${bgCssOf(opts.bg)};`;
const card = document.createElement('div');
card.className = 'ds-shot-card';
// position:relative 是必需的，不是装饰：
// html2canvas@1.4.1 在分层渲染时，会把「未定位的 inline-block」元素的背景归到
// 靠后的绘制分组，导致卡片底色排到子元素背景之后 —— 卡片底色会把 macOS 三点
// 整块反盖掉（实测红点像素 424 → 0），且与代码长短无关。
// 让卡片成为定位元素即可把它归入 positioned 分组，保证「先卡片底色、后子元素」，
// 同时不改变任何布局与尺寸（实测节点盒与画布尺寸与修复前逐像素一致）。
card.style.cssText = 'display:inline-block;min-width:300px;border-radius:12px;overflow:hidden;position:relative;'
+ `background:${theme.bg};`
+ (opts.shadow ? 'box-shadow:0 14px 36px rgba(0,0,0,.30),0 3px 10px rgba(0,0,0,.18);' : '');
if (opts.window === 'macos') {
const bar = document.createElement('div');
bar.className = 'ds-shot-bar';
bar.style.cssText = 'display:flex;align-items:center;gap:8px;padding:12px 16px;';
['#ff5f57', '#febc2e', '#28c840'].forEach(c => {
const dot = document.createElement('span');
dot.style.cssText = `width:12px;height:12px;border-radius:50%;display:block;background:${c};`;
bar.appendChild(dot);
});
card.appendChild(bar);
}
const body = document.createElement('div');
body.className = 'ds-shot-body';
body.appendChild(pre);
card.appendChild(body);
root.appendChild(card);
return root;
}
// ---------- 组装样式（自建，不依赖官网规则） ----------
// liveColors：由 harvestTokenColors() 在**原 DOM** 上采到的「类名 → 计算色」。
// 只有「导出底色 == 页面当前底色」时才用它（完全还原官网观感）；
// 跨主题时忽略，改用自建色板，否则浅色 token 会被搬到深色底上。
function buildShotCss(opts, theme, liveColors) {
const palette = Object.assign({}, theme);
if (liveColors && (theme.name === 'dark') === isPageDark()) {
Object.keys(liveColors).forEach(k => { palette[k] = liveColors[k]; });
}
const tokenRules = Object.keys(palette)
.filter(k => RESERVED_KEYS.indexOf(k) === -1)
.map(k => `.ds-shot-root .token.${k}{color:${palette[k]} !important;}`)
.join('');
const gutter = opts.lineNumbers ? `
.ds-shot-root pre{counter-reset:ds-shot-line;}
.ds-shot-root pre > span{counter-increment:ds-shot-line;}
.ds-shot-root pre > span::before{
content:counter(ds-shot-line);display:inline-block;min-width:2.1em;padding-right:1em;
text-align:right;opacity:.4;
}` : '';
return `
*{box-sizing:border-box;}
html,body{margin:0;padding:0;}
body{display:inline-block;}
.ds-shot-root{display:inline-block;}
.ds-shot-root pre{
margin:0;padding:16px;display:block;
font-family:${MONO_STACK};
font-size:${opts.fontSize}px;line-height:${opts.lineHeight}px;
color:${theme.text};background:transparent;
white-space:pre;overflow:visible;tab-size:4;
}
.ds-shot-root .token{color:${theme.text};}
${tokenRules}
${gutter}
`;
}
// ---------- 渲染为 canvas（离屏 iframe 隔离，复用既有表格导出手法） ----------
async function renderToCanvas(preEl, opts) {
if (!window.html2canvas) throw new Error('html2canvas 未加载');
const block = preEl.closest('.md-code-block') || preEl;
// 采色必须发生在**原 DOM** 上：克隆体已脱离文档，getComputedStyle 取不到值
const liveColors = harvestTokenColors(block);
const cleanPre = cloneCodeBlockPre(block);
if (!cleanPre) throw new Error('未找到代码内容');
const theme = resolveTheme(opts);
const css = buildShotCss(opts, theme, liveColors);
const dom = buildShotDom(cleanPre, opts, theme);
const iframe = document.createElement('iframe');
iframe.style.cssText = 'position:fixed;left:-99999px;top:0;width:1400px;height:900px;border:0;';
iframe.srcdoc = `${dom.outerHTML}`;
document.body.appendChild(iframe);
try {
await new Promise(resolve => { iframe.onload = resolve; setTimeout(resolve, 2000); });
const doc = iframe.contentDocument;
const node = doc && doc.querySelector('.ds-shot-root');
if (!node) throw new Error('渲染节点缺失');
return await window.html2canvas(node, { scale: opts.scale, backgroundColor: null, logging: false });
} finally {
setTimeout(() => iframe.remove(), 120);
}
}
// ---------- 输出 ----------
function canvasToBlob(canvas) {
return new Promise(res => canvas.toBlob(res, 'image/png'));
}
function downloadBlob(blob, filename) {
const url = URL.createObjectURL(blob);
const a = document.createElement('a');
a.href = url; a.download = filename;
document.body.appendChild(a); a.click(); a.remove();
setTimeout(() => URL.revokeObjectURL(url), 200);
}
const canCopyImage = () => !!(navigator.clipboard && navigator.clipboard.write && window.ClipboardItem);
function copyBlob(blob) {
return navigator.clipboard.write([new window.ClipboardItem({ 'image/png': blob })]);
}
function makeFilename(lang) {
const d = new Date();
const p = (n) => String(n).padStart(2, '0');
const ts = `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`;
return `code-${lang || 'snippet'}-${ts}.png`;
}
// ---------- 弹窗 ----------
let _activeModal = null;
let _busy = false;
function closeDialog() {
if (_activeModal) {
if (_activeModal._previewHost && _activeModal._previewHost.shadowRoot) _activeModal._previewHost.shadowRoot.innerHTML = '';
_activeModal.remove();
_activeModal = null;
}
document.removeEventListener('keydown', onDialogKeydown, true);
}
function onDialogKeydown(e) {
if (e.key === 'Escape') { e.stopPropagation(); closeDialog(); }
}
function openDialog(preEl) {
if (!codeExportEnabled) { showToast('代码块导出已关闭，请在「脚本设置 → 代码块外观」中开启'); return; }
const block = preEl.closest('.md-code-block');
if (!block) return;
closeDialog();
const lang = extractLang(block);
const opts = Object.assign({}, DEFAULT_OPTS, loadPrefs());
if (!opts.theme) opts.theme = document.body.classList.contains('dark') ? 'dark' : 'light';
const modal = document.createElement('div');
modal.className = 'ds-ci-modal';
const dialog = document.createElement('div');
dialog.className = 'ds-ci-dialog';
// ----- 头部 -----
const header = document.createElement('div');
header.className = 'ds-ci-header';
const title = document.createElement('h3');
title.className = 'ds-ci-title';
title.textContent = '导出代码为图片';
const closeBtn = document.createElement('button');
closeBtn.type = 'button';
closeBtn.className = 'ds-ci-close';
closeBtn.setAttribute('aria-label', '关闭');
closeBtn.textContent = '✕';
closeBtn.addEventListener('click', closeDialog);
header.appendChild(title);
header.appendChild(closeBtn);
// ----- 主体 -----
const body = document.createElement('div');
body.className = 'ds-ci-body';
const previewWrap = document.createElement('div');
previewWrap.className = 'ds-ci-preview-wrap';
body.appendChild(previewWrap);
const options = document.createElement('div');
options.className = 'ds-ci-options';
body.appendChild(options);
// ----- 页脚 -----
const footer = document.createElement('div');
footer.className = 'ds-ci-footer';
const copyBtn = document.createElement('button');
copyBtn.type = 'button';
copyBtn.className = 'ds-ci-btn';
copyBtn.textContent = '复制图片';
const dlBtn = document.createElement('button');
dlBtn.type = 'button';
dlBtn.className = 'ds-ci-btn primary';
dlBtn.textContent = '下载 PNG';
footer.appendChild(copyBtn);
footer.appendChild(dlBtn);
dialog.appendChild(header);
dialog.appendChild(body);
dialog.appendChild(footer);
modal.appendChild(dialog);
// ----- 选项控件辅助 -----
const field = (labelText, controlEl, wide) => {
const f = document.createElement('div');
f.className = 'ds-ci-field' + (wide ? ' is-wide' : '');
const l = document.createElement('div');
l.className = 'ds-ci-label';
l.textContent = labelText;
f.appendChild(l);
f.appendChild(controlEl);
return f;
};
const seg = (items, current, onPick) => {
const wrap = document.createElement('div');
wrap.className = 'ds-ci-seg';
items.forEach(it => {
const b = document.createElement('button');
b.type = 'button';
b.className = 'ds-ci-seg-btn' + (it.value === current ? ' is-active' : '');
b.textContent = it.label;
b.addEventListener('click', () => {
wrap.querySelectorAll('.ds-ci-seg-btn').forEach(x => x.classList.remove('is-active'));
b.classList.add('is-active');
onPick(it.value);
});
wrap.appendChild(b);
});
return wrap;
};
const slider = (min, max, step, value, unit, onInput) => {
const wrap = document.createElement('div');
wrap.className = 'ds-ci-range';
const input = document.createElement('input');
input.type = 'range';
input.min = min; input.max = max; input.step = step; input.value = value;
const val = document.createElement('span');
val.className = 'ds-ci-range-val';
val.textContent = value + (unit || '');
input.addEventListener('input', () => { val.textContent = input.value + (unit || ''); onInput(Number(input.value)); });
wrap.appendChild(input);
wrap.appendChild(val);
return wrap;
};
const toggle = (labelText, checked, onChange) => {
const l = document.createElement('label');
l.className = 'ds-ci-switch';
const input = document.createElement('input');
input.type = 'checkbox';
input.checked = !!checked;
input.addEventListener('change', () => onChange(input.checked));
const s = document.createElement('span');
s.textContent = labelText;
l.appendChild(input);
l.appendChild(s);
return l;
};
// ----- 选项（8 项） -----
// 1) 背景（色板，整行）
const swRow = document.createElement('div');
swRow.className = 'ds-ci-sw-row';
BG_PRESETS.forEach(p => {
const b = document.createElement('button');
b.type = 'button';
b.className = 'ds-ci-sw' + (p.id === opts.bg ? ' is-active' : '') + (p.id === 'transparent' ? ' is-transparent' : '');
b.title = p.label;
b.setAttribute('aria-label', '背景：' + p.label);
if (p.id !== 'transparent') b.style.background = p.css;
b.addEventListener('click', () => {
swRow.querySelectorAll('.ds-ci-sw').forEach(x => x.classList.remove('is-active'));
b.classList.add('is-active');
opts.bg = p.id;
refreshPreview();
});
swRow.appendChild(b);
});
options.appendChild(field('背景', swRow, true));
// 2) 窗口样式 / 8) 底色
options.appendChild(field('窗口样式', seg(
[{ value: 'macos', label: 'macOS 三点' }, { value: 'none', label: '无框' }],
opts.window, v => { opts.window = v; refreshPreview(); }
)));
options.appendChild(field('代码底色', seg(
[{ value: 'light', label: '浅色底' }, { value: 'dark', label: '深色底' }],
opts.theme, v => { opts.theme = v; refreshPreview(); }
)));
// 3) 内边距 / 5) 字号
options.appendChild(field('内边距', slider(16, 80, 2, opts.padding, 'px', v => { opts.padding = v; refreshPreview(); })));
options.appendChild(field('字号', slider(12, 18, 1, opts.fontSize, 'px', v => { opts.fontSize = v; refreshPreview(); })));
// 行高 / 7) 导出倍率
options.appendChild(field('行高', slider(16, 30, 1, opts.lineHeight, 'px', v => { opts.lineHeight = v; refreshPreview(); })));
options.appendChild(field('导出倍率', seg(
[{ value: 1, label: '1x' }, { value: 2, label: '2x' }, { value: 3, label: '3x' }],
opts.scale, v => { opts.scale = v; refreshPreview(); }
)));
// 4) 投影 / 6) 行号
const toggles = document.createElement('div');
toggles.className = 'ds-ci-toggles';
toggles.appendChild(toggle('投影', opts.shadow, v => { opts.shadow = v; refreshPreview(); }));
toggles.appendChild(toggle('行号', opts.lineNumbers, v => { opts.lineNumbers = v; refreshPreview(); }));
options.appendChild(field('其他', toggles, true));
// ----- 预览（Shadow DOM 隔离，与导出共用同一套样式） -----
let previewTimer = null;
function refreshPreview() {
clearTimeout(previewTimer);
previewTimer = setTimeout(() => {
try {
renderPreview(previewWrap, preEl, opts);
savePrefs(opts);
} catch (err) {
console.error('[代码导图] 预览失败:', err);
}
}, 30);
}
function renderPreview(host, srcPre, o) {
const theme = resolveTheme(o);
const liveBlock = srcPre.closest('.md-code-block') || srcPre;
const shadow = host.shadowRoot || host.attachShadow({ mode: 'open' });
shadow.innerHTML = '';
const style = document.createElement('style');
style.textContent = buildShotCss(o, theme, harvestTokenColors(liveBlock));
const cleanPre = cloneCodeBlockPre(liveBlock);
const dom = buildShotDom(cleanPre, o, theme);
const wrap = document.createElement('div');
wrap.style.cssText = 'display:inline-block;overflow:hidden;';
wrap.appendChild(dom);
shadow.appendChild(style);
shadow.appendChild(wrap);
requestAnimationFrame(() => {
const availW = Math.max(120, host.clientWidth - 36);
const w = dom.offsetWidth || 1;
const k = Math.min(1, availW / w);
dom.style.transformOrigin = 'top left';
dom.style.transform = `scale(${k})`;
wrap.style.width = Math.round(w * k) + 'px';
wrap.style.height = Math.round((dom.offsetHeight || 1) * k) + 'px';
});
}
// ----- 导出动作 -----
async function runExport(mode) {
if (_busy) return;
_busy = true;
copyBtn.disabled = true;
dlBtn.disabled = true;
const oldText = dlBtn.textContent;
dlBtn.textContent = '生成中…';
try {
const canvas = await renderToCanvas(preEl, opts);
const blob = await canvasToBlob(canvas);
if (!blob) throw new Error('无法生成图片数据');
if (mode === 'copy') {
await copyBlob(blob);
showToast('图片已复制到剪贴板');
} else {
downloadBlob(blob, makeFilename(lang));
showToast('图片已下载');
}
closeDialog();
} catch (err) {
console.error('[代码导图] 导出失败:', err);
showToast('导出失败：' + ((err && err.message) || '未知错误'));
} finally {
_busy = false;
copyBtn.disabled = false;
dlBtn.disabled = false;
dlBtn.textContent = oldText;
}
}
dlBtn.addEventListener('click', () => runExport('download'));
copyBtn.addEventListener('click', () => runExport('copy'));
if (!canCopyImage()) { copyBtn.disabled = true; copyBtn.title = '当前环境不支持复制图片'; }
document.body.appendChild(modal);
_activeModal = modal;
_activeModal._previewHost = previewWrap;
modal.addEventListener('click', (e) => { if (e.target === modal) closeDialog(); });
document.addEventListener('keydown', onDialogKeydown, true);
refreshPreview();
}
return { open: openDialog };
})();
// ==================== 统一 DOM 监听（合并多个 observer，添加节流） ====================
let _domObserver = null;
function observeDOM() {
if (_domObserver) return;
_domObserver = new MutationObserver(mutations => {
let hasNewCodeBlocks = false;
let hasNewTables = false;
let hasNewThinking = false;
let folderNeedsRescan = false; // 对话文件夹：出现新的会话链接/三点菜单时刷新
for (const m of mutations) {
if (m.type !== 'childList' || !m.addedNodes.length) continue;
for (const node of m.addedNodes) {
if (node.nodeType !== Node.ELEMENT_NODE) continue;
// 代码块检测
if (!hasNewCodeBlocks) {
if (node.matches && node.matches('pre')) { hasNewCodeBlocks = true; }
else if (node.querySelectorAll) {
if (node.querySelector('pre')) hasNewCodeBlocks = true;
// 只查直接子级 pre，深度遍历留给具体处理
}
}
// 表格检测（含增量行/列，防范流式输出中仅新增 tr/td/th 的情况）
if (!hasNewTables) {
if (node.matches && node.matches('table,tbody,thead,tfoot,tr,td,th,.ds-markdown')) hasNewTables = true;
else if (node.querySelectorAll && (node.querySelector('table') || node.querySelector('.ds-markdown'))) hasNewTables = true;
}
// 思考区域检测（排除代码块内的文本）
if (!hasNewThinking && autoCollapseThinking) {
if (node.closest && node.closest('pre, .md-code-block')) continue;
if (node.classList && node.classList.contains('ds-think-content')) {
hasNewThinking = true;
} else if (node.querySelectorAll && node.querySelector('.ds-think-content')) {
hasNewThinking = true;
}
}
// 对话文件夹：用于纠偏官网虚拟列表/菜单复用等不一定会 emit 匹配文件的情况，与原独立脚本一致、
// 使用宽触发——任何 ELEMENT 新增都计划重扫。schedule 自带 120ms 节流，且 ensurePanel/refreshTags/
// applyHiding/标签注入都是幂等操作（不产生新的 childList），面板自身的插入也只多触发一次自稳 tick，不会自循环。
if (folderManagerEnabled && !folderNeedsRescan) folderNeedsRescan = true;
}
}
if (hasNewCodeBlocks) {
document.querySelectorAll('pre').forEach(pre => {
if (!pre.hasAttribute(processedAttr)) addFoldButtonToCodeBlock(pre);
});
}
if (hasNewTables) scheduleTableProcess();
if (hasNewThinking) setTimeout(processAllThinkingSections, 150);
if (folderNeedsRescan) folderUnit.schedule();
});
_domObserver.observe(document.body, { childList: true, subtree: true });
}
// ==================== 初始化 ====================
function init() {
applyTableThemeClass(tableThemeMode);
applyWideScreen(wideScreen);
setTableButtonsAlways(tableButtonsAlways);
applyCodeBlockBg(codeBgEnhance, codeBgLevel);
cleanupLegacyWrappers();
deduplicateButtons();
processAllExistingCodeBlocks();
processAllTables();
if (autoCollapseThinking) {
setupThinkContentHiding();
processAllThinkingSections();
}
if (folderManagerEnabled) {
folderUnit.on();
folderUnit.schedule(); // 页面加载即应用（不等会话链接出现前的首轮 DOM 变化）
}
observeDOM();
// resize 节流处理表格
window.addEventListener('resize', () => {
clearTimeout(window._resizeFix);
window._resizeFix = setTimeout(processAllTables, 100);
});
}
if (document.readyState === 'loading') {
document.addEventListener('DOMContentLoaded', init);
} else {
init();
}
})();