dsh-happy-reader 0.3.2 → 0.3.4

package/CHANGELOG.md

@@ -0,0 +1,55 @@
+# 版本记录
+
+版本策略：插件版本与 DSH 客户端版本绑定。`package.json.engines.dsh` 是安装/更新时的
+硬门槛；客户端 `apply()` 里还有一次运行时闸门，手动 `file:///` 安装也会被拦住。
+旧的 DSH 用户继续装旧的插件版本，不追求“一个版本通吃”。
+
+| 插件版本 | DSH 范围 | 状态 |
+|---|---|---|
+| 0.3.4 | `>=0.2.2-rc.2 <0.2.3` | 2026-11-12 已发布 |
+| 0.3.3 / 0.3.2 | DSH 0.2.2-rc.1 / rc.2 | 已发布 |
+| 0.3.0 / 0.3.1 | DSH 0.2.2-rc.1 | 已发布 |
+| 0.2.0 – 0.2.7 | DSH 0.2.2 早期 | 已发布，保留 tag |
+
+## 0.3.4（2026-11-12 发布）
+
+- 适配 DSH 0.2.2-rc.2；`engines.dsh` 收紧到 `>=0.2.2-rc.2 <0.2.3`，并加运行时版本闸门。
+- 默认快捷键改为 `Ctrl/⌘+Alt+I`（隐藏输入框）/ `Ctrl/⌘+Alt+T`（隐藏上边栏）。
+- 复制监听先看 `e.defaultPrevented`：官方或其它插件先处理时主动让行。
+- macOS：面板与 Aa 加 `data-window-drag-exclude`（单个按钮不需要
+  `data-window-drag-controls`；仅基础声明，未实机验证）。
+- 面板稳定性：最大化/还原/全屏切换时只按新视口夹取当前落点，不再重跑自动候选；
+  拖动 Aa 不再带着已打开的面板一起移动；未拖动过的 Aa 在窗口变化后仍按右下 16px 锚定。
+
+## 0.3.3
+
+- 修复混合选区被整段退回原生：代码块↔列表/正文、表头↔列表、正文↔表格边界、表格↔表格。
+- 首尾代码块补语言；边界表补完整表头/整行；有序列表中段续接真实序号；
+  嵌套列表子项不再输出 `-   -`；任务项 checkbox 状态补回。
+- 代码横幅/复制按钮的 UI 选区交还原生复制。
+
+## 0.3.2
+
+- 通过官方 `ctx.shortcuts` 注册“隐藏输入框 / 隐藏上边栏”，面板显示官方键帽提示。
+- 隐藏输入区改用 `visibility:hidden` 预防聚焦，官方“引用文本”不再带动会话滚动。
+- 代码围栏从 DSH 横幅读取语言；表格/列表结构补全；浅色主题面板白底深字。
+- 面板高度锁定、滚动区顶部跳过 `scrollHeight` 读取、宽度观察器延后一帧。
+
+## 0.3.1
+
+- 修复行内代码选区复制外壳（`Elf64_Rela` 不再被转义成 `Elf64\_Rela`）。
+- 记录官方原生右键“复制”与全局 copy 拦截的冲突（见 TODO）。
+
+## 0.3.0
+
+- 界面迁移到官方 `shell.overlay` / `settings.general.item` 槽位；文案走官方 locale；
+  开关符合 `role="switch"`；取色只用官方主题变量。
+- 正文字体三组可折叠卡片（正文/代码/终端），中英分设字体，官方代码/终端字体与字号同步。
+- 官方「通用设置」增加中文/西文两行正文字体；浮动面板与设置页双向同步。
+- 宽度扩展、全屏补偿、引用滚动修复、热重载清理与禁用即恢复。
+
+## 0.2.0 – 0.2.7
+
+公开版本重命名后的迭代：面板开关与底部设置栏、滚动条贴右缘、隐藏上边栏收敛为
+会话头正向判据、行距/字距、面板拖动/拉高、失败回退与安装/卸载清理。逐版本提交见
+GitHub tag `v0.2.0` – `v0.2.7`。

package/README.md

@@ -103,6 +103,10 @@
 - **引用/标题**内选区补回 `>` / `#`；**表格**选区自动补整行、原表头和分隔行；
   单格/单项内部按格内/项内内容复制。DSH 聊天只渲染 GFM 表（raw HTML 按文本显示）；
   跨格/整表选择时，合并单元格/无表头等非 GFM 结构整段交还原生复制，不伪造表格
+- 跨代码块、列表、表格、引用/标题的混合选区保留各自结构：代码围栏、列表符号、
+  行内代码和表格不会因为一端落在某类结构里就整段退化成纯文本；边界表补完整表头/
+  整行，有序列表中段续接真实序号，嵌套列表不出现双项目符号，任务项 `[x]/[ ]`
+  状态保留；只选中代码块顶部语言/复制按钮时交还系统原生复制
 - 只在消息区域生效；复制界面其它地方（如设置、输入框）保持系统默认行为
 - **与官方「引用文本」不冲突（v0.3.0 核对）**：官方引用是选中文字后出现的按钮，
   把纯文本插入输入框；本功能只接管消息区内的 `copy` 事件（Ctrl+C）改写剪贴板，
@@ -124,8 +128,8 @@
 ### 10. 快捷键（官方通用设置）
 - 通过官方 `ctx.shortcuts` 注册两条命令，自动出现在**设置 → 通用 → 快捷键**
   （官方“编辑快捷键”入口）里：**隐藏输入框**、**隐藏上边栏**
-- 桌面端默认键位：Windows/Linux `Ctrl+Shift+I` / `Ctrl+Shift+T`，
-  macOS `⌘+Shift+I` / `⌘+Shift+T`；Web 端默认不绑定
+- 桌面端默认键位：Windows/Linux `Ctrl+Alt+I` / `Ctrl+Alt+T`，
+  macOS `⌘+Option+I` / `⌘+Option+T`；Web 端默认不绑定
 - 在速查里可以直接录制、清除或恢复默认；如果默认键位被注册服务拒绝（与已注册
   命令冲突），插件会自动改为“未绑定”命令；若被固定操作占用，速查会标出冲突，
   仍可自行改键
@@ -163,11 +167,18 @@ dsh plugin --profile <profile> add dsh-happy-reader
 
 ## 兼容性
 
-- Windows + DSH 桌面端 0.2.2 开发验证（按官方客户端插件接口实现）；macOS / Linux 未适配
-  （面板避让的是 Windows 系统按钮条，字体候选为 Windows 常用字体）。
-- 依赖官方客户端界面结构，DSH 版本升级后可能需要跟随更新。
+> 逐版本改动与 DSH 范围见 [CHANGELOG.md](CHANGELOG.md)；旧版本继续保留在 npm 与 GitHub tag 上。
+
+- **0.3.4**：DSH `0.2.2-rc.2` ≤ 版本 < `0.2.3`（`package.json.engines.dsh`）；插件管理器
+  会在安装/更新时拒绝旧 DSH，客户端挂载时也会再做一次版本闸门。
+- **0.3.3 / 0.3.2**：DSH 0.2.2-rc.1 / rc.2；**0.3.0 / 0.3.1**：DSH 0.2.2-rc.1。
+- 仍在旧 DSH 上的用户请显式安装对应旧版，例如
+  `dsh plugin --profile <profile> add dsh-happy-reader@0.3.3`；不要依赖 `latest` 自动升级。
+- Windows + DSH 桌面端实机验证；macOS 已给面板与 Aa 加 `data-window-drag-exclude`
+  基础兼容声明，但未实机验证；Linux 字体候选仍按 Windows 常用字体。
+- 依赖官方客户端界面结构，DSH 版本升级后需要跟随发布对应插件版本。
 - 运行时按事件工作：无常驻定时轮询；宽度观察器只在面板打开或扩展宽度生效时挂载，
-  字体 token 晚就绪用有限次退避重试（成功后停止）。
+  纯高度变化不触发宽度逻辑；字体 token 晚就绪用有限次退避重试（成功后停止）。
 
 ## 许可
 

package/lib/client.js

@@ -21,7 +21,7 @@ window.__ModuleLoader__.load({
     var exports = module.exports
 
     // ── 常量 ────────────────────────────────────────────────────────────
-    const VERSION = '0.3.2'
+    const VERSION = '0.3.4'
     const INSTANCE_TOKEN = {}
     const GROUPS_VERSION = 3
     const STATE_KEY = 'dsh.reader-boost.v1'
@@ -868,8 +868,32 @@ window.__ModuleLoader__.load({
       }
     }
 
+    /** 0.3.4 起明确声明 DSH 兼容范围；手动 file:/// 安装没有插件管理器兜底，
+     *  这里再做一次运行时闸门。未知版本不拦截，避免破坏开发/预览环境。 */
+    function dshVersionSupported(version) {
+      if (typeof version !== 'string' || !version) return true
+      const m = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?/.exec(version)
+      if (!m) return true
+      const major = Number(m[1]), minor = Number(m[2]), patch = Number(m[3])
+      if (major !== 0 || minor !== 2 || patch !== 2) return false
+      if (!m[4]) return true
+      const pre = /^rc\.(\d+)$/.exec(m[4])
+      return !!(pre && Number(pre[1]) >= 2)
+    }
+
     function apply(ctx) {
       try {
+        const bootVersion = globalThis.__DSH_BOOT__ && globalThis.__DSH_BOOT__.release
+          ? globalThis.__DSH_BOOT__.release.version : undefined
+        if (!dshVersionSupported(bootVersion)) {
+          console.error('[dsh-happy-reader] 当前 DSH ' + bootVersion + ' 不在本插件支持范围（需 0.2.2-rc.2 至 0.2.2.x），已停止挂载。')
+          // 支持范围被收紧后热重载到本版本：旧实例不应继续留在页面上。
+          const staleDispose = window.__dsrbDispose
+          if (typeof staleDispose === 'function') {
+            try { staleDispose() } catch { /* 旧实例拆除失败不阻塞退出 */ }
+          }
+          return
+        }
         // 热重载：DSH 监视插件文件变化，会再次执行本客户端。先拆旧实例、再按 id
         // 清扫遗留节点、最后重建 —— 页面上运行的必然是最新代码。
         const prevDispose = window.__dsrbDispose
@@ -996,9 +1020,9 @@ window.__ModuleLoader__.load({
           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'] },
+            'desktop:macos': { code, modifiers: ['primary', 'alt'] },
+            'desktop:windows': { code, modifiers: ['primary', 'alt'] },
+            'desktop:linux': { code, modifiers: ['primary', 'alt'] },
           })
           const command = (id, labelKey, aliases, code, action) => ({
             id,
@@ -1150,6 +1174,10 @@ window.__ModuleLoader__.load({
         fab.type = 'button'
         fab.title = t('fabTitle')
         fab.setAttribute('aria-label', t('fabTitle'))
+        // 0.2.2-rc.1+ macOS：自定义浮层控件需显式声明窗口拖拽排除。
+        // 单个按钮用 data-window-drag-exclude 即可；data-window-drag-controls 是
+        // “容器内控件分别排除”的作用域，不应标在按钮自身。
+        fab.setAttribute('data-window-drag-exclude', '')
         const [fx, fy] = clampPos(
           state.x ?? window.innerWidth - FAB_SIZE - 16,
           state.y ?? window.innerHeight - FAB_SIZE - 16,
@@ -1165,6 +1193,7 @@ window.__ModuleLoader__.load({
         panel.id = PANEL_ID
         panel.setAttribute('role', 'region')
         panel.setAttribute('aria-label', t('panelTitle'))
+        panel.setAttribute('data-window-drag-exclude', '') // macOS：浮层可见矩形不参与窗口拖拽
 
         const headRow = el('div', 'dsrb-head')
         const title = el('h4', null, t('panelTitle'))
@@ -1476,9 +1505,11 @@ window.__ModuleLoader__.load({
         const titlebarH =
           Number.parseFloat(getComputedStyle(document.documentElement).getPropertyValue('--dsh-windows-titlebar-height')) || 40
         const CAP_W = 138
-        function placePanel(keepScroll) {
+        function placePanel(keepScroll, keepPosition) {
           const scrollTop = typeof keepScroll === 'number' ? keepScroll : panelBody.scrollTop
           const r = fab.getBoundingClientRect()
+          const currentLeft = Number.parseFloat(panel.style.left)
+          const currentTop = Number.parseFloat(panel.style.top)
           const fixedH = typeof state.panelH === 'number'
           if (!fixedH) {
             panel.style.height = ''
@@ -1498,14 +1529,21 @@ window.__ModuleLoader__.load({
           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))
+          const yMinFor = (x) => CAP_H > 0 && x + pw > vw - CAP_W ? CAP_H : M
           let best = null
-          if (typeof state.panelX === 'number' && typeof state.panelY === 'number') {
+          // 窗口最大化/还原/全屏切换时，面板若已经开着，保持当前视觉位置并只做视口夹取；
+          // 不重新跑自动候选，避免面板在窗口状态变化时跳位。
+          if (keepPosition && Number.isFinite(currentLeft) && Number.isFinite(currentTop)) {
+            const sx = clampX(currentLeft)
+            best = { x: sx, y: clampY(currentTop, yMinFor(sx)) }
+          }
+          if (!best && typeof state.panelX === 'number' && typeof state.panelY === 'number') {
             // 用户拖过位置 → 用记住的位置；仍做两件保护：避开右上角系统按钮条；
             // 若与按钮重叠（按钮可能后来被拖到附近）则放弃记忆、回自动布局
             const sx = clampX(state.panelX)
-            const sy = clampY(state.panelY, CAP_H > 0 && sx + pw > vw - CAP_W ? CAP_H : M)
+            const sy = clampY(state.panelY, yMinFor(sx))
             const overlapsFab = sx < r.right + GAP && sx + pw > r.left - GAP && sy < r.bottom + GAP && sy + ph > r.top - GAP
-            if (overlapsFab) {
+            if (overlapsFab && !keepPosition) {
               state.panelX = null
               state.panelY = null
               writeState({ panelX: null, panelY: null })
@@ -1525,8 +1563,7 @@ window.__ModuleLoader__.load({
               x < r.right + GAP && x + pw > r.left - GAP && y < r.bottom + GAP && y + ph > r.top - GAP
             for (const c of candidates) {
               const x = clampX(c.x)
-              const yMin = CAP_H > 0 && x + pw > vw - CAP_W ? CAP_H : M
-              const y = clampY(c.y, yMin)
+              const y = clampY(c.y, yMinFor(x))
               if (!hits(x, y)) {
                 best = { x, y }
                 break
@@ -1561,15 +1598,9 @@ window.__ModuleLoader__.load({
           if (open) {
             renderAll()
             rebuildFontPick()
+            // 先归位宽度再显示面板：避免面板出现后下一帧才改聊天宽度，造成背后内容跳动
+            refreshWidthTargets()
             placePanel()
-            // 观察器接线不影响首帧可读性：挪到下一帧，避免打开瞬间与定位抢布局。
-            if (typeof window.requestAnimationFrame === 'function') {
-              window.requestAnimationFrame(() => {
-                if (!disposed && state.open) refreshWidthTargets()
-              })
-            } else {
-              refreshWidthTargets()
-            }
           } else {
             refreshWidthTargets()
           }
@@ -1709,8 +1740,9 @@ window.__ModuleLoader__.load({
           const root = document.documentElement
           if (on) root.setAttribute(FS_ATTR, '')
           else root.removeAttribute(FS_ATTR)
-          // 全屏切换会改变系统按钮条的有无 → 面板开着时当场重定位
-          if (state.open) placePanel()
+          // 全屏切换会改变系统按钮条的有无 → 面板开着时夹取到新视口；
+          // 保留用户当前看到的落点，不重新跑自动候选。
+          if (state.open) placePanel(undefined, true)
         }
         function applyFullscreen() {
           // 进入全屏必须发生在用户手势内：本函数由开关 change / 整条点击同步触发，满足
@@ -1961,10 +1993,17 @@ window.__ModuleLoader__.load({
         // 官方键/官方变量的收敛压到同一批回调内，开合过程不再出现滞留窄值的中间态。
         let watchedColumn = null
         let watchedColumnWidth = -1
-        const columnObserver = new ResizeObserver(() => {
+        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
@@ -1982,6 +2021,7 @@ window.__ModuleLoader__.load({
           columnObserver.disconnect()
           watchedColumn = container
           watchedColumnWidth = -1
+          watchedContentWidth = -1
           if (container) columnObserver.observe(container)
         }
 
@@ -2131,7 +2171,8 @@ window.__ModuleLoader__.load({
           drag = null
           if (wasDrag) {
             writeState({ x: fab.offsetLeft, y: fab.offsetTop })
-            if (state.open) placePanel()
+            // 面板是独立浮层：拖动 Aa 时保持面板原位，不跟着按钮跑；
+            // 下次打开面板再按新按钮位置自动布局。
           } else {
             togglePanel(!state.open)
           }
@@ -2393,15 +2434,36 @@ window.__ModuleLoader__.load({
           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 false
+          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 false
+          if (!startCell || !endCell) return null
           // 单个单元格内部按普通行内内容复制，不扩成整表。
           if (startCell === endCell) return null
           const startRow = startCell.closest('tr')
@@ -2409,41 +2471,50 @@ window.__ModuleLoader__.load({
           if (!startRow || !endRow) return false
           const parts = gfmTableParts(startTable)
           if (!parts) return false
-          const { header, headerCells, rows } = parts
+          const rows = parts.rows
           const si = rows.indexOf(startRow)
           const ei = rows.indexOf(endRow)
           if (si < 0 || ei < 0) return false
-          const lo = Math.min(si, ei)
-          const hi = Math.max(si, ei)
-          const body = rows.slice(lo, hi + 1).filter((row) => row !== header)
           const box = document.createElement('div')
-          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)
-          }
-          box.append(table)
+          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 false
+          if (!startItem || !endItem) return null // 代码块→列表等混合选区仍应保留 Markdown
           const startList = startItem.parentElement
           const endList = endItem.parentElement
-          if (!startList || startList !== endList || !/^(UL|OL)$/.test(startList.tagName)) return false
+          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)
@@ -2493,6 +2564,89 @@ window.__ModuleLoader__.load({
           }
           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')) {
@@ -2507,6 +2661,7 @@ window.__ModuleLoader__.load({
         }
         function onCopy(e) {
           try {
+            if (e.defaultPrevented) return // 尊重先注册/先执行的复制处理（含官方公式复制）
             const sel = document.getSelection()
             if (!sel || sel.isCollapsed || !sel.rangeCount) return
             const elOf = (n) => (n && n.nodeType === 3 ? n.parentElement : n)
@@ -2522,6 +2677,13 @@ window.__ModuleLoader__.load({
               return !!(node && node.closest && node.closest('input, textarea, [contenteditable="true"], [contenteditable=""], [contenteditable="plaintext-only"]'))
             }
             if (inEditable(sel.anchorNode) || inEditable(sel.focusNode)) return
+            // 代码块横幅是语言/复制按钮等 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
@@ -2586,7 +2748,12 @@ window.__ModuleLoader__.load({
               }
               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
@@ -2626,11 +2793,15 @@ window.__ModuleLoader__.load({
         document.addEventListener('keydown', onDocKeyDown)
 
         function onResize() {
-          const [x, y] = clampPos(fab.offsetLeft, fab.offsetTop, FAB_SIZE, FAB_SIZE)
+          // 未拖动过：Aa 始终按“右下 16px”重新锚定；拖动过：按记住的绝对位置夹取。
+          const baseX = state.x == null ? window.innerWidth - FAB_SIZE - 16 : state.x
+          const baseY = state.y == null ? window.innerHeight - FAB_SIZE - 16 : state.y
+          const [x, y] = clampPos(baseX, baseY, FAB_SIZE, FAB_SIZE)
           fab.style.left = x + 'px'
           fab.style.top = y + 'px'
           refreshWidthTargets()
-          if (state.open) placePanel()
+          // 面板已开着：保持当前视觉位置并夹取视口，避免最大化/还原时跳位。
+          if (state.open) placePanel(undefined, true)
         }
         window.addEventListener('resize', onResize)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-happy-reader",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "Happy Reader（阅读增强）：隐藏输入框 / 上边栏、全屏切换、字号 10–40px、行距/字距微调、面板可拖动可拉高、复制为 Markdown（公式→LaTeX）、内容宽度扩展、中英文分别选正文字体 + 官方代码/终端字体与字号（仅列本机已装）—— 与官方设置协同，不冲突",
   "type": "module",
   "license": "MIT",
@@ -34,6 +34,7 @@
     "lib",
     "cordis.patch.yml",
     "README.md",
+    "CHANGELOG.md",
     "LICENSE",
     "locale/*.json",
     "icon.svg"
@@ -46,5 +47,8 @@
       "platform": "web",
       "immediately": true
     }
+  },
+  "engines": {
+    "dsh": ">=0.2.2-rc.2 <0.2.3"
   }
 }