dsh-happy-reader 0.3.1 → 0.3.3

package/README.md

@@ -16,14 +16,17 @@
 组件挂载、不直接改写页面结构；取色只用官方主题变量（自动跟随明暗与品牌色）；文案走
 官方语言服务（随界面语言切换中/英）；开关采用官方无障碍规范（`role="switch"`，
 键盘与读屏可用）；正文字体的中/西两行也注册进官方「通用设置」页（`settings.general.item`），
-两处入口共用同一份设置；不修改任何官方文件。与官方叠加层共存：右键菜单、提示条
+两处入口共用同一份设置；不修改任何官方文件。浅色主题下为白底深字，深色主题跟随
+官方菜单色；保留毛玻璃观感，同时打开路径不再做多余的自然高度测量、
+观察器接线也不抢首帧。与官方叠加层共存：右键菜单、提示条
 始终显示在插件之上；Esc 在官方对话框/菜单里让位，在插件自己的输入框里只取消输入。
 
 ## 功能详解
 
 ### 1. 隐藏输入区
 一键收起底部的输入框，把屏幕还给内容。
-- 收起后官方聊天的滚动与阅读位置不受影响（是收起高度，不是粗暴隐藏）
+- 收起后官方聊天的滚动与阅读位置不受影响（保留座位几何，是收起而非 display:none）
+- 隐藏态输入区不可聚焦：官方“引用文本”仍会写入草稿，但不会再带动会话滚动
 - 随时再点一下开关即恢复；状态自动记住
 
 ### 2. 隐藏上边栏
@@ -93,9 +96,17 @@
   （直接粘贴到论文、笔记里就是可编辑的公式源码，不会再是一团乱码）
 - **含公式的复制会同时写入富文本格式**（与 Cherry Studio 的 copy-tex 同策略）：
   粘贴到 Word、WPS 等支持富文本的地方，公式仍以可显示的样子出现
-- **代码块**转为 \`\`\` 围栏、行内代码保留反引号
+- **代码块**转为 \`\`\` 围栏，并保留 DSH 代码横幅里的语言（如 \`\`\`python）；
+  横幅与复制按钮不会混进正文；行内代码保留反引号
 - **加粗/斜体/删除线/链接/图片/标题/列表/引用**按 Markdown 语法保留；
   **表格**转为 GFM 表格（`| 列 |` + 分隔行）、**任务列表**转为 `- [x] / - [ ]`
+- **引用/标题**内选区补回 `>` / `#`；**表格**选区自动补整行、原表头和分隔行；
+  单格/单项内部按格内/项内内容复制。DSH 聊天只渲染 GFM 表（raw HTML 按文本显示）；
+  跨格/整表选择时，合并单元格/无表头等非 GFM 结构整段交还原生复制，不伪造表格
+- 跨代码块、列表、表格、引用/标题的混合选区保留各自结构：代码围栏、列表符号、
+  行内代码和表格不会因为一端落在某类结构里就整段退化成纯文本；边界表补完整表头/
+  整行，有序列表中段续接真实序号，嵌套列表不出现双项目符号，任务项 `[x]/[ ]`
+  状态保留；只选中代码块顶部语言/复制按钮时交还系统原生复制
 - 只在消息区域生效；复制界面其它地方（如设置、输入框）保持系统默认行为
 - **与官方「引用文本」不冲突（v0.3.0 核对）**：官方引用是选中文字后出现的按钮，
   把纯文本插入输入框；本功能只接管消息区内的 `copy` 事件（Ctrl+C）改写剪贴板，
@@ -114,6 +125,19 @@
 - 位置与高度自动记住；只有真正拖动过才会记住（点一下不受影响）；
   **双击标题栏**一键复位回自动布局
 
+### 10. 快捷键（官方通用设置）
+- 通过官方 `ctx.shortcuts` 注册两条命令，自动出现在**设置 → 通用 → 快捷键**
+  （官方“编辑快捷键”入口）里：**隐藏输入框**、**隐藏上边栏**
+- 桌面端默认键位：Windows/Linux `Ctrl+Shift+I` / `Ctrl+Shift+T`，
+  macOS `⌘+Shift+I` / `⌘+Shift+T`；Web 端默认不绑定
+- 在速查里可以直接录制、清除或恢复默认；如果默认键位被注册服务拒绝（与已注册
+  命令冲突），插件会自动改为“未绑定”命令；若被固定操作占用，速查会标出冲突，
+  仍可自行改键
+- 面板里的“隐藏输入框 / 隐藏上边栏”行会在悬停或键盘聚焦时显示圆角整行高亮，
+  并在标题行右侧显示与官方新会话按钮同款的键帽提示；键位随官方设置实时刷新，
+  清除绑定后自动隐藏
+- 命令随插件停用/卸载移除；弹窗打开时快捷键让位，不会误触发
+
 > 推荐组合：**隐藏输入框 + 隐藏上边栏 + 全屏** —— 一键进入沉浸阅读模式。
 
 ## 安装
@@ -147,7 +171,7 @@ dsh plugin --profile <profile> add dsh-happy-reader
   （面板避让的是 Windows 系统按钮条，字体候选为 Windows 常用字体）。
 - 依赖官方客户端界面结构，DSH 版本升级后可能需要跟随更新。
 - 运行时按事件工作：无常驻定时轮询；宽度观察器只在面板打开或扩展宽度生效时挂载，
-  字体 token 晚就绪用有限次退避重试（成功后停止）。
+  纯高度变化不触发宽度逻辑；字体 token 晚就绪用有限次退避重试（成功后停止）。
 
 ## 许可
 

package/lib/client.js

@@ -6,7 +6,8 @@
 // 面板拖动/拉高、复制为 Markdown。
 //
 // 关键约束：
-//   · 隐藏输入区用 height:0（官方滚动锚定依赖几何），不用 display:none
+//   · 隐藏输入区用 height:0（官方滚动锚定依赖几何）+ visibility:hidden（阻止聚焦），
+//     不用 display:none
 //   · <style>.disabled 必须挂载后再设（未连接时设置会被 CSSOM 静默丢弃）
 //   · 文本 UI 只走官方 shell.overlay / settings.general.item 槽位、locale 与主题 token
 //   · 官方字号/字体走 theme.setFontSize / setFontFamily 角色接口；中英分字用
@@ -20,7 +21,7 @@ window.__ModuleLoader__.load({
     var exports = module.exports
 
     // ── 常量 ────────────────────────────────────────────────────────────
-    const VERSION = '0.3.1'
+    const VERSION = '0.3.3'
     const INSTANCE_TOKEN = {}
     const GROUPS_VERSION = 3
     const STATE_KEY = 'dsh.reader-boost.v1'
@@ -107,11 +108,19 @@ window.__ModuleLoader__.load({
 .dsrb-x:hover{background:var(--dsw-alias-interactive-bg-hover,rgba(255,255,255,.16))}
 .dsrb-row{display:flex;align-items:flex-start;gap:10px;padding:8px 0;
   border-top:1px solid var(--dsw-alias-border-l1,rgba(128,128,128,.14))}
-.dsrb-row-click{cursor:pointer}
-.dsrb-row-click:hover{background:var(--dsw-alias-interactive-bg-hover,rgba(255,255,255,.045))}
-.dsrb-rowMain{flex:1;min-width:0}
+/* 点击行：悬停底色铺满整行（含面板内边距），圆角，避免只盖住内容区的方形小框 */
+.dsrb-row-click{margin:0 -14px;padding:8px 14px;border-radius:8px;cursor:pointer;transition:background .12s,border-color .12s}
+.dsrb-row-click:hover,.dsrb-row-click:focus-within{background:var(--dsw-alias-interactive-bg-hover,rgba(255,255,255,.045));border-top-color:transparent}
+.dsrb-rowMain{flex:1;min-width:0;position:relative}
 .dsrb-rowTitle{font-weight:600}
 .dsrb-rowTitle b{color:var(--dsw-alias-label-primary,#fff);font-weight:600}
+/* 快捷键提示叠在标题行右侧：不占布局宽度，副文案不会再被挤成省略号 */
+.dsrb-keys{position:absolute;top:1px;right:0;display:inline-flex;align-items:center;gap:2px;max-width:60%;color:var(--dsw-alias-label-tertiary,#8d8d8d);
+  font-size:12px;line-height:16px;white-space:nowrap;overflow:hidden;opacity:0;pointer-events:none;transition:opacity .12s}
+.dsrb-key{display:inline-flex;align-items:center;justify-content:center;padding:0;border:0;background:transparent;font:inherit}
+.dsrb-keySeparator{font:inherit;color:var(--dsw-alias-label-caption,var(--dsw-alias-label-tertiary,#8d8d8d))}
+.dsrb-row-click:hover .dsrb-keys,.dsrb-row-click:focus-within .dsrb-keys{opacity:1}
+@media (hover:none){.dsrb-row-click .dsrb-keys{opacity:1}}
 .dsrb-rowSub{color:var(--dsw-alias-label-secondary,#9a9a9a);font-size:12px;margin-top:2px}
 /* 开关：对齐官方 role=switch 视觉（36×20、2px 内边距、16px 滑块、16px 行程） */
 .dsrb-switch{position:relative;flex:none;width:36px;height:20px;padding:2px;box-sizing:border-box;
@@ -183,7 +192,9 @@ window.__ModuleLoader__.load({
 .dsrb-set-select option{background:var(--dsw-alias-bg-layer-3,#1c1c1e);color:var(--dsw-alias-label-primary,#eee)}
 `
     // 隐藏输入区（关键：height:0 而非 display:none —— 官方滚动锚定依赖该元素的几何信息）
-    const HIDE_CSS = '[data-composer-seat]{height:0!important;min-height:0!important;overflow:hidden!important}'
+    // visibility:hidden 让隐藏的输入区无法被聚焦——官方“引用文本”仍能写入 Lexical 草稿，
+    // 但浏览器不会再为了露出 0 高光标而滚动会话；比焦点后恢复滚动更干净。
+    const HIDE_CSS = '[data-composer-seat]{height:0!important;min-height:0!important;overflow:hidden!important;visibility:hidden!important}'
     // 隐藏上边栏：正向判据（官方 conversation.header 槽位宿主带 data-conversation-header-leading，
     // 全应用仅此一处）；排除对话框内，避免误伤插件页/嵌入页的头部。
     const HIDE_TOP_CSS = 'header[data-window-drag]:has(> [data-conversation-header-leading]):not([role="dialog"] *){display:none!important}'
@@ -655,6 +666,28 @@ window.__ModuleLoader__.load({
     let settingsRefresh = null
     let settingsAlive = false
     let remounting = false // 语言切换等就地重挂：不算插件停用，不退出全屏
+    let shortcutActions = null // 当前实体提供的隐藏开关动作；未挂载时快捷键命令直接 pass
+    let shortcutHintCatalog = null // 官方快捷键目录（随用户改键发布）
+    let shortcutHintNodes = null // { 命令 id: { hint, input } }
+
+    /** 把官方有效键位同步到面板行内的快捷键提示。 */
+    function refreshShortcutHints() {
+      if (!shortcutHintNodes) return
+      const rows = shortcutHintCatalog && typeof shortcutHintCatalog.getSnapshot === 'function'
+        ? shortcutHintCatalog.getSnapshot() : []
+      for (const [id, target] of Object.entries(shortcutHintNodes)) {
+        const row = rows.find((item) => item.id === id)
+        const keys = row && Array.isArray(row.keys) ? row.keys : []
+        target.hint.textContent = ''
+        for (const key of keys) {
+          target.hint.append(el(key === '+' ? 'span' : 'kbd', key === '+' ? 'dsrb-keySeparator' : 'dsrb-key', key))
+        }
+        target.hint.style.display = keys.length ? '' : 'none'
+        // 与官方新会话按钮一致：让辅助技术直接拿到组合键
+        if (row && row.aria) target.input.setAttribute('aria-keyshortcuts', row.aria)
+        else if (typeof target.input.removeAttribute === 'function') target.input.removeAttribute('aria-keyshortcuts')
+      }
+    }
 
     /** 官方主题快照 → 字号/字体族桥接（0.2.2 角色形与旧版单值形都读）。 */
     function syncTheme(snap) {
@@ -958,6 +991,65 @@ window.__ModuleLoader__.load({
           }
         })
 
+        // ── 官方快捷键：命令自动出现在「通用设置 → 快捷键」速查；动作由当前实体提供 ──
+        ctx.inject(['shortcuts'], (sctx) => {
+          const shortcuts = sctx.shortcuts
+          if (!shortcuts || typeof shortcuts.register !== 'function') return
+          const desktopDefaults = (code) => ({
+            'desktop:macos': { code, modifiers: ['primary', 'shift'] },
+            'desktop:windows': { code, modifiers: ['primary', 'shift'] },
+            'desktop:linux': { code, modifiers: ['primary', 'shift'] },
+          })
+          const command = (id, labelKey, aliases, code, action) => ({
+            id,
+            label: () => t(labelKey),
+            aliases,
+            defaults: desktopDefaults(code),
+            regions: ['page', 'editable', 'terminal'],
+            modals: [],
+            resolve: (context) => {
+              if (context && context.modal != null) return { status: 'blocked', reason: 'modal' }
+              if (!shortcutActions || typeof shortcutActions[action] !== 'function') return { status: 'pass' }
+              return { status: 'handled', run: () => shortcutActions[action]() }
+            },
+          })
+          const commands = [
+            command('happyReader.hideComposer', 'hideComposerTitle',
+              ['hide composer', 'hide input', 'reader input'], 'KeyI', 'hideComposer'),
+            command('happyReader.hideTop', 'hideTopTitle',
+              ['hide title bar', 'hide top bar', 'reader top'], 'KeyT', 'hideTop'),
+          ]
+          for (const def of commands) {
+            try {
+              sctx.effect(() => {
+                try {
+                  return shortcuts.register(def)
+                } catch (err) {
+                  // 默认键位撞上官方/其它插件时，命令仍以未绑定形式出现在快捷键设置里
+                  console.warn('[dsh-happy-reader] 快捷键默认绑定不可用，改为未绑定：', def.id, err)
+                  try { return shortcuts.register({ ...def, defaults: {} }) } catch { return () => {} }
+                }
+              }, 'dsh-happy-reader: 快捷键 ' + def.id)
+            } catch (err) {
+              console.warn('[dsh-happy-reader] 快捷键注册失败：', def.id, err)
+            }
+          }
+          // 面板上的快捷键提示跟随官方目录：用户改键/清除后立即刷新
+          shortcutHintCatalog = shortcuts.catalog || null
+          sctx.effect(() => {
+            refreshShortcutHints()
+            const catalog = shortcuts.catalog
+            if (!catalog || typeof catalog.subscribe !== 'function') return () => {}
+            try {
+              const off = catalog.subscribe(() => refreshShortcutHints())
+              return typeof off === 'function' ? off : () => {}
+            } catch (err) {
+              console.warn('[dsh-happy-reader] 快捷键提示订阅失败：', err)
+              return () => {}
+            }
+          }, 'dsh-happy-reader: 快捷键提示')
+        })
+
         // ── 渲染面：官方 shell.overlay 槽位（框架级覆盖层，pointer-events:none） ──
         let registered = false
         let standalone = null // 旧外壳回退时直挂 body 的宿主，卸载时一并移除
@@ -1084,7 +1176,7 @@ window.__ModuleLoader__.load({
         headRow.append(title, headHint, closeBtn)
 
         /** 开关行：官方 36×20 视觉 + role=switch；整条可点由 bindRowToggle 绑定。 */
-        function makeSwitchRow(titleText, subText) {
+        function makeSwitchRow(titleText, subText, withShortcut) {
           const row = el('div', 'dsrb-row dsrb-row-click')
           const box = el('span', 'dsrb-switch') // span 而非 label：避免原生转发激活面
           const input = el('input')
@@ -1094,13 +1186,24 @@ window.__ModuleLoader__.load({
           input.setAttribute('aria-label', titleText)
           box.append(input, el('span'))
           const main = el('div', 'dsrb-rowMain')
-          main.append(el('div', 'dsrb-rowTitle', titleText), el('div', 'dsrb-rowSub', subText))
+          const title = el('div', 'dsrb-rowTitle', titleText)
+          const sub = el('div', 'dsrb-rowSub', subText)
+          const hint = withShortcut ? el('span', 'dsrb-keys') : null
+          if (hint) hint.setAttribute('aria-hidden', 'true')
+          main.append(title, sub)
+          if (hint) main.append(hint)
           row.append(box, main)
-          return { row, input }
+          return { row, input, hint }
         }
-        const { row: rowHide, input: hideToggle } = makeSwitchRow(t('hideComposerTitle'), t('hideComposerSub'))
+        const { row: rowHide, input: hideToggle, hint: hideComposerHint } = makeSwitchRow(t('hideComposerTitle'), t('hideComposerSub'), true)
 
-        const { row: rowTop, input: topToggle } = makeSwitchRow(t('hideTopTitle'), t('hideTopSub'))
+        const { row: rowTop, input: topToggle, hint: hideTopHint } = makeSwitchRow(t('hideTopTitle'), t('hideTopSub'), true)
+        const shortcutHintMap = {
+          'happyReader.hideComposer': { hint: hideComposerHint, input: hideToggle },
+          'happyReader.hideTop': { hint: hideTopHint, input: topToggle },
+        }
+        shortcutHintNodes = shortcutHintMap
+        refreshShortcutHints()
 
         // 行：行距 / 字距（面板最下方；默认 = 官方原样）
         const rowType = el('div', 'dsrb-row')
@@ -1153,7 +1256,6 @@ window.__ModuleLoader__.load({
           group.append(head, body)
           head.addEventListener('click', () => toggleGroup(key))
           groups[key] = { group, head, body, sub }
-          return groups[key]
         }
         function applyGroupState() {
           for (const key of Object.keys(groups)) {
@@ -1207,6 +1309,7 @@ window.__ModuleLoader__.load({
             picker.list = list
             fillFontOptions(select, list)
             select.append(customOpt)
+            currentOpt = null // 重新填充后旧的“当前”选项已被清掉
             picker.render()
           }
           picker.setEnabled = (on) => {
@@ -1376,17 +1479,22 @@ window.__ModuleLoader__.load({
         function placePanel(keepScroll) {
           const scrollTop = typeof keepScroll === 'number' ? keepScroll : panelBody.scrollTop
           const r = fab.getBoundingClientRect()
-          panel.style.height = ''
-          panel.style.maxHeight = '' // 先按自然高度测量
+          const fixedH = typeof state.panelH === 'number'
+          if (!fixedH) {
+            panel.style.height = ''
+            panel.style.maxHeight = '' // 先按自然高度测量
+          }
+          // 用户已锁定高度时无需清空高度再量自然高度（那会强制整面板重排）；
+          // 宽度仍按实测外框取（常量 280 不含左右 1px 边框）。
           const pw = panel.offsetWidth || PANEL_WIDTH
-          const natural = panel.offsetHeight || 240
+          const natural = fixedH ? 0 : panel.offsetHeight || 240
           const GAP = 6
           const M = 8
           const vw = window.innerWidth
           const vh = window.innerHeight
           const CAP_H = document.fullscreenElement ? 0 : titlebarH
           // 定位按"实际将显示的高度"算 —— 底缘才能与按钮对齐，不会忽远忽近
-          const desired = typeof state.panelH === 'number' ? state.panelH : Math.min(natural, PANEL_MAX_H)
+          const desired = fixedH ? state.panelH : Math.min(natural, PANEL_MAX_H)
           const ph = Math.max(PANEL_MIN_H, Math.min(desired, vh - 2 * M - BORDER_Y))
           const clampX = (x) => Math.min(Math.max(M, x), Math.max(M, vw - pw - M))
           const clampY = (y, yMin) => Math.min(Math.max(yMin, y), Math.max(yMin, vh - ph - BORDER_Y - M))
@@ -1435,10 +1543,15 @@ window.__ModuleLoader__.load({
           // 应用最终高度：以定位时采用的 ph 为准，再按落点与视口底缘的剩余空间收紧
           const finalH = Math.max(PANEL_MIN_H, Math.min(ph, vh - best.y - M - BORDER_Y))
           panel.style.maxHeight = finalH + 'px'
-          if (typeof state.panelH === 'number') panel.style.height = finalH + 'px'
-          // 重算高度/位置会让浏览器把超界 scrollTop 归零；按重排前的值恢复
-          const maxScroll = Math.max(0, panelBody.scrollHeight - panelBody.clientHeight)
-          panelBody.scrollTop = Math.min(scrollTop, maxScroll)
+          if (fixedH) panel.style.height = finalH + 'px'
+          // 重算高度/位置会让浏览器把超界 scrollTop 归零；按重排前的值恢复。
+          // 面板本来在顶部（scrollTop=0）时无需读 scrollHeight 触发布局。
+          if (scrollTop > 0) {
+            const maxScroll = Math.max(0, panelBody.scrollHeight - panelBody.clientHeight)
+            panelBody.scrollTop = Math.min(scrollTop, maxScroll)
+          } else {
+            panelBody.scrollTop = 0
+          }
         }
         function togglePanel(open) {
           state.open = open
@@ -1448,6 +1561,7 @@ window.__ModuleLoader__.load({
           if (open) {
             renderAll()
             rebuildFontPick()
+            // 先归位宽度再显示面板：避免面板出现后下一帧才改聊天宽度，造成背后内容跳动
             refreshWidthTargets()
             placePanel()
           } else {
@@ -1563,6 +1677,19 @@ window.__ModuleLoader__.load({
         topToggle.addEventListener('change', applyHideTop)
         bindRowToggle(rowTop, topToggle, applyHideTop)
 
+        // 快捷键动作由当前实体提供：面板关着也能切换，下次打开时开关已同步
+        const shortcutHandlers = {
+          hideComposer: () => {
+            hideToggle.checked = !hideToggle.checked
+            applyHideComposer()
+          },
+          hideTop: () => {
+            topToggle.checked = !topToggle.checked
+            applyHideTop()
+          },
+        }
+        shortcutActions = shortcutHandlers
+
         // ── 功能 6：全屏（开关与真实全屏状态双向同步；Esc 退出后自动回位） ──
         function inPageFullscreen() {
           return document.fullscreenElement === document.documentElement
@@ -1792,6 +1919,7 @@ window.__ModuleLoader__.load({
           }, 0)
         }
         function onDocPointerCancel() {
+          if (!officialDragging) return
           const restore = officialDragAdopt && state.widthPx != null
           officialDragging = false
           officialDragMoved = false
@@ -1826,8 +1954,22 @@ window.__ModuleLoader__.load({
         // ConversationWidthControls 同款的 ResizeObserver 观察同一节点，把覆盖值/
         // 官方键/官方变量的收敛压到同一批回调内，开合过程不再出现滞留窄值的中间态。
         let watchedColumn = null
-        const columnObserver = new ResizeObserver(() => {
+        let watchedColumnWidth = -1
+        let watchedContentWidth = -1
+        const columnObserver = new ResizeObserver((entries) => {
           if (disposed) return
+          // 块级容器的高度会随流式输出、折叠动画变化；宽度没变时这些回调与
+          // 宽度状态无关，直接跳过（用观测值判断，避免为读 offsetWidth 触发布局）。
+          const entry = entries && entries.length ? entries[entries.length - 1] : null
+          const observed = entry && entry.contentRect ? entry.contentRect.width : null
+          if (observed !== null) {
+            if (observed === watchedContentWidth) return
+            watchedContentWidth = observed
+          }
+          const current = widthTargets()
+          const width = current ? current.column : 0
+          if (width === watchedColumnWidth) return
+          watchedColumnWidth = width
           adoptOfficialWidthOnStart()
           normalizeWidthDrift()
           if (state.widthPx != null && !widthTargets()) scheduleWidthTargetRetry()
@@ -1840,6 +1982,8 @@ window.__ModuleLoader__.load({
           if (container === watchedColumn) return
           columnObserver.disconnect()
           watchedColumn = container
+          watchedColumnWidth = -1
+          watchedContentWidth = -1
           if (container) columnObserver.observe(container)
         }
 
@@ -2141,13 +2285,23 @@ window.__ModuleLoader__.load({
           }
           return walk(root)
         }
+        function texMarkdown(tex, display) {
+          return (display ? '$$' : '$') + tex + (display ? '$$' : '$')
+        }
         let turndownSvc = null
-        /** 懒建并复用 turndown 实例（标准库负责标签映射；仅补一条公式规则——
-         *  .katex / .katex-display 由 KaTeX 的 annotation 源码出口还原）。 */
+        /** 懒建并复用 turndown 实例（标准库负责标签映射；补公式还原与表格单元格管道符转义）。 */
         function getTurndown() {
           if (turndownSvc) return turndownSvc
           turndownSvc = new TurndownService({ codeBlockStyle: 'fenced', headingStyle: 'atx', bulletListMarker: '-' })
           turndownSvc.use(turndownPluginGfm.gfm) // GFM 扩展：表格 / 删除线 / 任务列表（官方配套插件，见文件尾 vendored 段）
+          // vendored gfm 的单元格规则不转义 |，含管道符的单元格复制后会断列；在这里覆盖。
+          turndownSvc.addRule('tableCellPipes', {
+            filter: ['th', 'td'],
+            replacement: (content, node) => {
+              const prefix = node.cellIndex === 0 ? '| ' : ' '
+              return prefix + content.replace(/\|/g, '\\|') + ' |'
+            },
+          })
           turndownSvc.addRule('katex', {
             filter: (node) => {
               const cls = String((node && node.className) || '')
@@ -2156,7 +2310,8 @@ window.__ModuleLoader__.load({
             replacement: (_content, node) => {
               const tex = findTexSource(node)
               if (!tex) return ''
-              return String(node.className).indexOf('katex-display') !== -1 ? '\n$$' + tex + '$$\n' : '$' + tex + '$'
+              const display = String(node.className).indexOf('katex-display') !== -1
+              return display ? '\n' + texMarkdown(tex, true) + '\n' : texMarkdown(tex, false)
             },
           })
           return turndownSvc
@@ -2185,30 +2340,317 @@ window.__ModuleLoader__.load({
           }
           return out.join('\n').trim()
         }
+        /** 向上找选区端点最近的匹配元素。 */
+        function closestFrom(node, selector, elOf) {
+          const el = elOf(node)
+          return el && el.closest ? el.closest(selector) : null
+        }
+        /** 选区所在的块级上下文：引用层数与最近的标题级别。 */
+        function blockContext(node) {
+          let quotes = 0
+          let heading = 0
+          let el = node && (node.nodeType === 1 ? node : node.parentElement)
+          while (el && !el.matches('[data-chat-node-key]')) {
+            if (el.tagName === 'BLOCKQUOTE') quotes += 1
+            else if (!heading) {
+              const level = /^H([1-6])$/.exec(el.tagName)
+              if (level) heading = Number(level[1])
+            }
+            el = el.parentElement
+          }
+          return { quotes, heading }
+        }
+        /** 逐行补回引用前缀（嵌套引用逐层叠加）。 */
+        function quoteMarkdown(md, depth) {
+          if (!depth) return md
+          const line = '> '.repeat(depth)
+          const blank = line.trimEnd()
+          return md.split('\n').map((text) => (text ? line + text : blank)).join('\n')
+        }
+        function cellAlign(cell) {
+          const valid = (value) => value === 'left' || value === 'right' || value === 'center'
+          const explicit = (cell.getAttribute('align') || '').toLowerCase()
+          if (valid(explicit)) return explicit
+          const inline = cell.style && cell.style.textAlign ? cell.style.textAlign.toLowerCase() : ''
+          if (valid(inline)) return inline
+          const cls = String(cell.className || '')
+          const named = /(?:^|\s)(?:align-|text-align-|md-align-|text-)(left|center|right)(?:\s|$)/.exec(cls)
+          return named ? named[1] : ''
+        }
+        /** 只有 DSH 实际渲染出的 GFM 表（唯一表头、等宽行、行内单元格）才可还原。 */
+        function gfmTableParts(table) {
+          const head = table.tHead
+          if (!head || head.rows.length !== 1 || table.tFoot || table.caption) return null
+          const header = head.rows[0]
+          const headerCells = [...header.cells]
+          const width = headerCells.length
+          if (!width || headerCells.some((cell) => cell.tagName !== 'TH')) return null
+          // 单元格只能放行内内容：块结构、硬换行、独立公式都会破坏 GFM 行结构。
+          const cellFits = (cell) =>
+            cell.rowSpan === 1 && cell.colSpan === 1 &&
+            !cell.querySelector('table, ul, ol, pre, blockquote, p, div, h1, h2, h3, h4, h5, h6, hr, br, .katex-display')
+          const rowFits = (row) =>
+            row.cells.length === width && [...row.cells].every(cellFits)
+          const rows = [...table.rows]
+          if (rows[0] !== header || !rows.every(rowFits)) return null
+          return { header, headerCells, rows }
+        }
+        /** 用原表的结构化表头 + 指定行区间生成一张完整 GFM 表（单元格行内内容）。 */
+        function buildGfmTable(parts, lo, hi) {
+          const { header, headerCells, rows } = parts
+          const body = rows.slice(Math.max(0, lo), Math.min(rows.length - 1, hi) + 1).filter((row) => row !== header)
+          const table = document.createElement('table')
+          const thead = document.createElement('thead')
+          const headRow = document.createElement('tr')
+          for (const cell of headerCells) headRow.append(cell.cloneNode(true))
+          thead.append(headRow)
+          table.append(thead)
+          if (body.length) {
+            const tbody = document.createElement('tbody')
+            for (const row of body) {
+              const tr = document.createElement('tr')
+              for (const cell of row.cells) tr.append(cell.cloneNode(true))
+              tbody.append(tr)
+            }
+            table.append(tbody)
+          }
+          return table
+        }
+        /** 表格：按显示结构还原 GFM，只补被选中的整行与原表头；非 GFM 结构交还原生复制。 */
+        function tableReplacement(range, elOf) {
+          const startTable = closestFrom(range.startContainer, 'table', elOf)
+          const endTable = closestFrom(range.endContainer, 'table', elOf)
+          if (!startTable && !endTable) return null
+          if (!startTable || !endTable || startTable !== endTable) return null // 跨表/混合选区走通用转换，不能整段退回原生
+          const startCell = closestFrom(range.startContainer, 'td,th', elOf)
+          const endCell = closestFrom(range.endContainer, 'td,th', elOf)
+          if (!startCell || !endCell) return null
+          // 单个单元格内部按普通行内内容复制，不扩成整表。
+          if (startCell === endCell) return null
+          const startRow = startCell.closest('tr')
+          const endRow = endCell.closest('tr')
+          if (!startRow || !endRow) return false
+          const parts = gfmTableParts(startTable)
+          if (!parts) return false
+          const rows = parts.rows
+          const si = rows.indexOf(startRow)
+          const ei = rows.indexOf(endRow)
+          if (si < 0 || ei < 0) return false
+          const box = document.createElement('div')
+          box.append(buildGfmTable(parts, Math.min(si, ei), Math.max(si, ei)))
+          return box
+        }
+        /**
+         * 混合选区一端的表只会被克隆出局部（通常缺行/缺列），GFM 校验会整段回退原生。
+         * 用原表把首/尾边界表补成完整行（含表头），中间完整表保持原样。
+         */
+        function completeBoundaryTables(box, work, elOf) {
+          const startTable = closestFrom(work.startContainer, 'table', elOf)
+          const endTable = closestFrom(work.endContainer, 'table', elOf)
+          if (!startTable && !endTable) return
+          if (startTable && endTable && startTable === endTable) return
+          const cloned = [...box.querySelectorAll('table')]
+          if (!cloned.length) return
+          const fill = (table, isStart) => {
+            if (!table) return
+            const parts = gfmTableParts(table)
+            if (!parts) return
+            const row = closestFrom(isStart ? work.startContainer : work.endContainer, 'tr', elOf)
+            if (!row) return
+            const index = parts.rows.indexOf(row)
+            if (index < 0) return
+            const lo = isStart ? index : 1
+            const hi = isStart ? parts.rows.length - 1 : Math.max(0, index)
+            const target = isStart ? cloned[0] : cloned[cloned.length - 1]
+            if (target && target.parentNode) target.replaceWith(buildGfmTable(parts, lo, hi))
+          }
+          if (startTable) fill(startTable, true)
+          if (endTable && endTable !== startTable) fill(endTable, false)
+        }
+        /** 列表：跨多个列表项时补齐完整项与 ol 起始序号；单项内部保持普通文本。 */
+        function listReplacement(range, elOf) {
+          const startItem = closestFrom(range.startContainer, 'li', elOf)
+          const endItem = closestFrom(range.endContainer, 'li', elOf)
+          if (!startItem && !endItem) return null
+          if (!startItem || !endItem) return null // 代码块→列表等混合选区仍应保留 Markdown
+          const startList = startItem.parentElement
+          const endList = endItem.parentElement
+          if (!startList || startList !== endList || !/^(UL|OL)$/.test(startList.tagName)) return null
+          if (startItem === endItem) return null
+          const items = [...startList.children].filter((child) => child.tagName === 'LI')
+          const si = items.indexOf(startItem)
+          const ei = items.indexOf(endItem)
+          if (si < 0 || ei < 0) return false
+          const lo = Math.min(si, ei)
+          const hi = Math.max(si, ei)
+          const ordered = startList.tagName === 'OL'
+          const list = document.createElement(ordered ? 'ol' : 'ul')
+          if (ordered) {
+            const start = Number.parseInt(startList.getAttribute('start') || '1', 10)
+            const first = lo + (Number.isFinite(start) ? start : 1)
+            if (first !== 1) list.setAttribute('start', String(first))
+          }
+          for (const item of items.slice(lo, hi + 1)) list.append(item.cloneNode(true))
+          const box = document.createElement('div')
+          box.append(list)
+          return box
+        }
+        function structuralReplacement(range, elOf) {
+          const table = tableReplacement(range, elOf)
+          if (table === false) return false
+          if (table) return table
+          return listReplacement(range, elOf)
+        }
+        /** DSH 的代码语言只写在横幅里（pre/code 上没有 language-* 类）。 */
+        function dshCodeLanguage(pre) {
+          const content = pre.closest('[data-code-block-content]')
+          const block = content ? content.parentElement : pre.closest('.md-code-block')
+          const banner = block ? block.querySelector('[data-code-block-banner]') : null
+          if (!banner) return ''
+          const info = banner.querySelector('[data-text-interaction-exclude]')
+          const span = banner.querySelector('span[class*="language"]') || banner.querySelector('span')
+          const raw = (info ? info.textContent : span ? span.textContent : '').trim()
+          // 无语言时官方横幅显示本地化的“代码/Code”，不能当围栏语言。
+          if (!/^[A-Za-z0-9_+#.-]{1,30}$/.test(raw) || /^code$/i.test(raw)) return ''
+          return raw
+        }
+        /** 把官方横幅语言补成 language-* 类（转换器只认这个），并移除横幅等非正文 UI。 */
+        function normalizeCodeBlocks(root) {
+          for (const pre of root.querySelectorAll('pre')) {
+            const code = pre.firstElementChild
+            if (!code || code.tagName !== 'CODE') continue
+            if (/(^|\s)language-\S+/.test(code.getAttribute('class') || '')) continue
+            const lang = pre.getAttribute('data-dsrb-lang') || dshCodeLanguage(pre)
+            if (lang) code.className = (code.className ? code.className + ' ' : '') + 'language-' + lang
+          }
+          for (const banner of [...root.querySelectorAll('[data-code-block-banner]')]) banner.remove()
+        }
+        /** 混合选区时首/尾代码块可能只克隆出 pre、没带横幅；按原 DOM 端点补语言。 */
+        function tagSelectedCodeLanguages(box, work, elOf) {
+          const pres = [...box.querySelectorAll('pre')]
+          if (!pres.length) return
+          const preAt = (node) => {
+            const direct = closestFrom(node, 'pre', elOf)
+            if (direct) return direct
+            const block = closestFrom(node, '.md-code-block', elOf)
+            return block ? block.querySelector('[data-code-block-content] pre') : null
+          }
+          const mark = (pre, original) => {
+            if (!original || !pre || pre.getAttribute('data-dsrb-lang')) return
+            const lang = dshCodeLanguage(original)
+            if (!lang) return
+            const text = pre.textContent
+            if (text && !original.textContent.includes(text)) return
+            pre.setAttribute('data-dsrb-lang', lang)
+          }
+          mark(pres[0], preAt(work.startContainer))
+          if (pres.length > 1) mark(pres[pres.length - 1], preAt(work.endContainer))
+        }
+        /** 选区从嵌套列表子项开始时，克隆会带出“只有子列表、没有自身文字”的父 li；
+         *  直接转换会得到 `-   -   子项`。把空父项拆壳，让子列表成为顶层列表。 */
+        function normalizeEmptyListItems(root) {
+          for (const li of [...root.querySelectorAll('li')]) {
+            const nested = [...li.children].filter((child) => /^(UL|OL)$/.test(child.tagName))
+            if (!nested.length) continue
+            const own = [...li.childNodes].some((node) =>
+              !nested.includes(node) && (node.nodeType === 1 || (node.nodeType === 3 && node.textContent.trim())))
+            if (own) continue
+            li.replaceWith(...nested)
+          }
+        }
+        /** 从任务列表项文字开始时，克隆会丢掉前面的 checkbox，`[x]` 状态随之消失；
+         *  按原 li 给首/尾克隆项补回 checkbox。 */
+        function tagSelectedTaskItems(root, work, elOf) {
+          const cloned = [...root.querySelectorAll('li')]
+          if (!cloned.length) return
+          const ownCheckbox = (li) => [...li.children].find((child) => child.tagName === 'INPUT' && child.type === 'checkbox')
+          const mark = (li, original) => {
+            if (!li || !original) return
+            const source = ownCheckbox(original)
+            if (!source || ownCheckbox(li)) return
+            const text = li.textContent.trim()
+            if (text && !original.textContent.includes(text)) return
+            const input = document.createElement('input')
+            input.setAttribute('type', 'checkbox')
+            input.checked = !!source.checked
+            if (input.checked) input.setAttribute('checked', '')
+            li.insertBefore(input, li.firstChild)
+          }
+          mark(cloned[0], closestFrom(work.startContainer, 'li', elOf))
+          if (cloned.length > 1) mark(cloned[cloned.length - 1], closestFrom(work.endContainer, 'li', elOf))
+        }
+        /** 混合选区从有序列表中段开始时，克隆会保留原 start 但丢掉前面各项，
+         *  序号会从 3、4 重新开始；按原列表项的真实位置改写克隆 ol 的 start。 */
+        function fixOrderedListStarts(root, work, elOf) {
+          const list = closestFrom(work.startContainer, 'ol', elOf)
+          const item = closestFrom(work.startContainer, 'li', elOf)
+          if (!list || !item) return
+          const items = [...list.children].filter((child) => child.tagName === 'LI')
+          const index = items.indexOf(item)
+          if (index < 0) return
+          const base = Number.parseInt(list.getAttribute('start') || '1', 10)
+          const first = (Number.isFinite(base) ? base : 1) + index
+          const target = item.textContent.trim()
+          const depth = (node, stop) => {
+            let n = 0
+            for (let el = node.parentElement; el && el !== stop; el = el.parentElement) {
+              if (el.tagName === 'UL' || el.tagName === 'OL') n += 1
+              if (el.matches && el.matches('[data-chat-node-key]')) break
+            }
+            return n
+          }
+          const listDepth = depth(list)
+          for (const ol of root.querySelectorAll('ol')) {
+            if (depth(ol, root) !== listDepth) continue
+            const firstItem = [...ol.children].find((child) => child.tagName === 'LI')
+            if (!firstItem || firstItem.textContent.trim() !== target) continue
+            ol.setAttribute('start', String(first))
+            break
+          }
+        }
+        /** 校验选区里的所有表格并把对齐落到 align；非 GFM 表返回 false。 */
+        function normalizeGfmTables(root) {
+          for (const table of root.querySelectorAll('table')) {
+            const parts = gfmTableParts(table)
+            if (!parts) return false
+            for (const cell of parts.headerCells) {
+              const align = cellAlign(cell)
+              if (align) cell.setAttribute('align', align)
+            }
+          }
+          return true
+        }
         function onCopy(e) {
           try {
             const sel = document.getSelection()
             if (!sel || sel.isCollapsed || !sel.rangeCount) return
+            const elOf = (n) => (n && n.nodeType === 3 ? n.parentElement : n)
             // 选区两端都要在消息行内才接管（跨区选择保持系统默认行为）
             const inChat = (n) => {
-              const node = n && (n.nodeType === 3 ? n.parentElement : n)
+              const node = elOf(n)
               return !!(node && node.closest && node.closest('[data-chat-node-key]'))
             }
             if (!inChat(sel.anchorNode) || !inChat(sel.focusNode)) return
             // 可编辑区域（输入框/富文本编辑器）保持原生复制
             const inEditable = (n) => {
-              const node = n && (n.nodeType === 3 ? n.parentElement : n)
+              const node = elOf(n)
               return !!(node && node.closest && node.closest('input, textarea, [contenteditable="true"], [contenteditable=""], [contenteditable="plaintext-only"]'))
             }
             if (inEditable(sel.anchorNode) || inEditable(sel.focusNode)) return
-            const elOf = (n) => (n && n.nodeType === 3 ? n.parentElement : n)
+            // 代码块横幅是语言/复制按钮等 UI，不是正文；只选横幅时交还原生。
+            const bannerAt = (n) => {
+              const node = elOf(n)
+              return node && node.closest ? node.closest('[data-code-block-banner]') : null
+            }
+            const bannerStart = bannerAt(sel.anchorNode)
+            if (bannerStart && bannerStart === bannerAt(sel.focusNode)) return
             const ka = elOf(sel.anchorNode).closest('.katex')
             const kf = elOf(sel.focusNode).closest('.katex')
             // 只选中了某个公式本身（两端落在同一个公式内）→ 直接输出该公式的 LaTeX
             if (ka && ka === kf) {
               const tex = findTexSource(ka)
               if (tex) {
-                e.clipboardData.setData('text/plain', ka.closest('.katex-display') ? '$$' + tex + '$$' : '$' + tex + '$')
+                e.clipboardData.setData('text/plain', texMarkdown(tex, !!ka.closest('.katex-display')))
                 e.clipboardData.setData('text/html', ka.outerHTML) // 富目标（Word 等）粘贴仍显示公式
                 e.preventDefault()
                 return
@@ -2226,39 +2668,63 @@ window.__ModuleLoader__.load({
             const ke = katexAt(work.endContainer)
             if (ks) work.setStartBefore(ks)
             if (ke) work.setEndAfter(ke)
-            const box = document.createElement('div')
-            // 选区克隆丢掉共同祖先往上的层级（代码块外层的 <pre> 即如此丢的），转换器的
-            // 空白折叠随即把换行折掉；按现场回收"预格式化"祖先链（判据=实际生效的
-            // white-space）补壳还原层级——非预格式化选区零改动。
-            const cac = work.commonAncestorContainer
-            let anc = cac.nodeType === 1 ? cac : cac.parentElement
-            const ancShells = []
-            while (anc && anc !== document.body && !anc.matches('[data-chat-node-key]')) {
-              ancShells.push(anc)
-              anc = anc.parentElement
-            }
-            let topShell = -1
-            let inlineShell = -1
-            const INLINE_SHELL = new Set(['CODE', 'STRONG', 'B', 'EM', 'I', 'DEL', 'S', 'STRIKE', 'A'])
-            for (let i = 0; i < ancShells.length; i++) {
-              const ws = getComputedStyle(ancShells[i]).whiteSpace
-              if (ws === 'pre' || ws === 'pre-wrap' || ws === 'pre-line' || ws === 'break-spaces') topShell = i
-              // 行内语义元素同样会在克隆时丢外壳：<code> 补 `…`，粗体/斜体/
-              // 删除线/链接补对应 Markdown；取最外层，嵌套格式才能完整保留。
-              if (INLINE_SHELL.has(ancShells[i].tagName)) inlineShell = i
-            }
-            if (topShell < 0 && inlineShell >= 0) topShell = inlineShell
-            let nestAt = box
-            for (let i = topShell; i >= 0; i--) {
-              const shell = ancShells[i].cloneNode(false)
-              nestAt.append(shell)
-              nestAt = shell
+            const structural = structuralReplacement(work, elOf)
+            if (structural === false) return // 不支持的结构：交还原生复制（纯文本）
+            let box
+            if (structural) {
+              box = structural
+            } else {
+              box = document.createElement('div')
+              // 选区克隆丢掉共同祖先往上的层级（代码块外层的 <pre> 即如此丢的），转换器的
+              // 空白折叠随即把换行折掉；按现场回收"预格式化"祖先链（判据=实际生效的
+              // white-space）补壳还原层级——非预格式化选区零改动。
+              const cac = work.commonAncestorContainer
+              let anc = cac.nodeType === 1 ? cac : cac.parentElement
+              const ancShells = []
+              while (anc && anc !== document.body && !anc.matches('[data-chat-node-key]')) {
+                ancShells.push(anc)
+                anc = anc.parentElement
+              }
+              let topShell = -1
+              let inlineShell = -1
+              const INLINE_SHELL = new Set(['CODE', 'STRONG', 'B', 'EM', 'I', 'DEL', 'S', 'STRIKE', 'A'])
+              for (let i = 0; i < ancShells.length; i++) {
+                const ws = getComputedStyle(ancShells[i]).whiteSpace
+                if (ws === 'pre' || ws === 'pre-wrap' || ws === 'pre-line' || ws === 'break-spaces') topShell = i
+                // 行内语义元素同样会在克隆时丢外壳：<code> 补 `…`，粗体/斜体/
+                // 删除线/链接补对应 Markdown；取最外层，嵌套格式才能完整保留。
+                if (INLINE_SHELL.has(ancShells[i].tagName)) inlineShell = i
+              }
+              if (topShell < 0 && inlineShell >= 0) topShell = inlineShell
+              let nestAt = box
+              for (let i = topShell; i >= 0; i--) {
+                const shell = ancShells[i].cloneNode(false)
+                if (shell.nodeName === 'PRE') {
+                  const lang = dshCodeLanguage(ancShells[i])
+                  if (lang) shell.setAttribute('data-dsrb-lang', lang)
+                }
+                nestAt.append(shell)
+                nestAt = shell
+              }
+              nestAt.append(work.cloneContents())
             }
-            nestAt.append(work.cloneContents())
+            tagSelectedCodeLanguages(box, work, elOf)
+            completeBoundaryTables(box, work, elOf)
+            normalizeCodeBlocks(box)
+            fixOrderedListStarts(box, work, elOf)
+            normalizeEmptyListItems(box)
+            tagSelectedTaskItems(box, work, elOf)
+            // 通用/列表结构里若夹带非 GFM 表格（含整表被框进选区的情况），
+            // 不能让 Turndown 退回 HTML 表或拼出坏表——整段交还原生复制。
+            if (!normalizeGfmTables(box)) return
             // 公式场景先留存原始 HTML（含 <math>）：粘进 Word 等富目标仍可显示公式
             const html = box.querySelector('.katex') ? box.innerHTML : null
-            const md = tidyMarkdown(getTurndown().turndown(box))
+            let md = tidyMarkdown(getTurndown().turndown(box))
             if (!md) return
+            // 克隆只带走被选中的子节点，会丢掉选区所在的引用/标题外壳；按现场补回块级语义。
+            const context = blockContext(work.commonAncestorContainer)
+            if (context.heading && !md.includes('\n')) md = '#'.repeat(context.heading) + ' ' + md
+            md = quoteMarkdown(md, context.quotes)
             e.clipboardData.setData('text/plain', md)
             if (html) e.clipboardData.setData('text/html', html)
             e.preventDefault()
@@ -2298,8 +2764,8 @@ window.__ModuleLoader__.load({
         // 宽度目标只随事件变化：启动、面板打开、窗口尺寸、会话切换、官方手柄操作。
         refreshWidthTargets()
 
-        // 启动标记：记录加载时刻与版本（供诊断确认插件已加载；不影响功能）
-        writeState({ lastBootAt: Date.now(), lastBootVersion: VERSION })
+        // 启动版本标记：供诊断确认插件已加载（不影响功能）
+        writeState({ lastBootVersion: VERSION })
 
         // ── 卸载清理（React 槽位卸载 / 插件热重载 / ctx.effect 三路都会触发；
         //    幂等，可重复调用） ──
@@ -2308,6 +2774,8 @@ window.__ModuleLoader__.load({
           disposed = true
           overlayAlive = false
           ui = null
+          if (shortcutActions === shortcutHandlers) shortcutActions = null
+          if (shortcutHintNodes === shortcutHintMap) shortcutHintNodes = null
           if (widthRefreshTimer) { clearTimeout(widthRefreshTimer); widthRefreshTimer = null }
           if (widthTargetRetry) { clearTimeout(widthTargetRetry); widthTargetRetry = null }
           cancelFontRetry()
@@ -2397,7 +2865,7 @@ window.__ModuleLoader__.load({
     }
 
     // ══ vendored: turndown start ══
-    // turndown 7.2.4（MIT License）——逐字内联自官方发行版 dist/turndown.js。
+    // turndown 7.2.5（MIT License）——逐字内联自官方发行版 dist/turndown.js。
     // 用途：选区复制时把渲染后的 HTML 按社区标准规则映射回 Markdown（不再是手写标签规则）。
     // 官方仓库：https://github.com/mixmark-io/turndown
     /*
@@ -3139,8 +3607,8 @@ var TurndownService = (function () {
    * Reduces a DOM node down to its Markdown string equivalent
    * @private
    * @param {HTMLElement} parentNode The node to convert
-   * @returns A Markdown representation of the node
-   * @type String
+   * @returns Accumulator with Markdown representation parts of the node
+   * @type Array
    */
 
   function process(parentNode) {
@@ -3153,14 +3621,15 @@ var TurndownService = (function () {
       } else if (node.nodeType === 1) {
         replacement = replacementForNode.call(self, node);
       }
-      return join(output, replacement);
-    }, '');
+      join(output, replacement);
+      return output;
+    }, []);
   }
 
   /**
    * Appends strings as each rule requires and trims the output
    * @private
-   * @param {String} output The conversion output
+   * @param {Array} output The conversion output accumulator
    * @returns A trimmed version of the ouput
    * @type String
    */
@@ -3169,10 +3638,10 @@ var TurndownService = (function () {
     var self = this;
     this.rules.forEach(function (rule) {
       if (typeof rule.append === 'function') {
-        output = join(output, rule.append(self.options));
+        join(output, rule.append(self.options));
       }
     });
-    return output.replace(/^[\t\r\n]+/, '').replace(/[\t\r\n\s]+$/, '');
+    return output.join('').replace(/^[\t\r\n]+/, '').replace(/[\t\r\n\s]+$/, '');
   }
 
   /**
@@ -3185,27 +3654,29 @@ var TurndownService = (function () {
 
   function replacementForNode(node) {
     var rule = this.rules.forNode(node);
-    var content = process.call(this, node);
+    var content = process.call(this, node).join('');
     var whitespace = node.flankingWhitespace;
     if (whitespace.leading || whitespace.trailing) content = content.trim();
     return whitespace.leading + rule.replacement(content, node, this.options) + whitespace.trailing;
   }
 
   /**
-   * Joins replacement to the current output with appropriate number of new lines
+   * Joins replacement with the current output accumulator using the appropriate number of new lines
+   * (makes sure the only trailing whitespace will be in the last array element)
    * @private
-   * @param {String} output The current conversion output
+   * @param {String} output The current conversion output accumulator
    * @param {String} replacement The string to append to the output
-   * @returns Joined output
-   * @type String
    */
 
   function join(output, replacement) {
-    var s1 = trimTrailingNewlines(output);
+    var tail = output.pop() || '';
+    var s1 = trimTrailingNewlines(tail);
     var s2 = trimLeadingNewlines(replacement);
-    var nls = Math.max(output.length - s1.length, replacement.length - s2.length);
+    var nls = Math.max(tail.length - s1.length, replacement.length - s2.length);
     var separator = '\n\n'.substring(0, nls);
-    return s1 + separator + s2;
+    if (s1) output.push(s1);
+    if (separator) output.push(separator);
+    if (s2) output.push(s2);
   }
 
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-happy-reader",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "Happy Reader（阅读增强）：隐藏输入框 / 上边栏、全屏切换、字号 10–40px、行距/字距微调、面板可拖动可拉高、复制为 Markdown（公式→LaTeX）、内容宽度扩展、中英文分别选正文字体 + 官方代码/终端字体与字号（仅列本机已装）—— 与官方设置协同，不冲突",
   "type": "module",
   "license": "MIT",