collab-canvas 0.3.0 → 0.4.0

package/lib/doc-model.js

@@ -0,0 +1,291 @@
+// ═══ 话布文档模型（P1：块级模型 + markdown 无损往返）═══════════════════
+//
+// 目标（2026-10-15 主人选定"乙"）：
+//   **语义等价 + 规范化一次后稳定** ✓
+//     · 第一次 parse→serialize 可能整理写法（列表标记统一成 - ✓ 空行统一成一个 ✓）
+//     · 之后【再往返完全一致】✓（幂等 ✓）—— 也就是"最多动一次，之后不再漂"
+//
+// 为什么只做块级 ✗（P1 的范围）：
+//   这次的"有损"是**块级漂移** ✗（日志：行数 308→311，差 100 行 ✓）
+//   —— 多行段落被拆、列表套代码块漂移之类 ✓ 那都是块级 ✓
+//   行内（**粗体** / 链接 / 脚注）目前往返是好的 ✓ 先当**原始文本**存 ✓
+//   等 P2 编辑器需要行内结构时再加 ✓（范围小、风险低 ✓）
+//
+// 自包含 ✓ 零依赖 ✓ —— 与 lib/ 下其它侧模块同一种写法 ✓
+// 浏览器：window.__ccvDocModel = CCV_DOC_MODEL ✓
+// node  ：new Function(src + '\nreturn CCV_DOC_MODEL')() ✓（测试就这么用 ✓）
+var CCV_DOC_MODEL = (function () {
+  'use strict'
+
+  // ─── 解析：markdown → Doc ───────────────────────────────────────
+  // Doc = { blocks: [ Block ] }
+  // Block:
+  //   { type:'h', level:1-6, text }
+  //   { type:'p', text }                       ← text 是**原始 markdown 行**（行内不建模 ✓）
+  //   { type:'code', lang, text }
+  //   { type:'quote', blocks:[Block] }         ← 递归 ✓
+  //   { type:'list', ordered, items:[{blocks:[Block]}] }
+  //   { type:'table', align:[…], rows:[[cell,…]], widths:null|[%…], heights:null|[…] }
+  //   { type:'hr' }
+  //   { type:'html', text }                    ← 原始 HTML 块（脚注 / div / mark 等 ✓）
+  function parse(md) {
+    var lines = String(md == null ? '' : md).replace(/\r\n?/g, '\n').split('\n')
+    var blocks = parseBlocks(lines)
+    return { blocks: blocks }
+  }
+
+  function isBlank(l) { return /^\s*$/.test(l) }
+  function fenceOpen(l) { var m = l.match(/^\s*(```+|~~~+)\s*([^\s`]*)\s*$/); return m ? { fence: m[1], lang: m[2] || '' } : null }
+  function isHr(l) { return /^\s{0,3}(-{3,}|\*{3,}|_{3,})\s*$/.test(l) }
+  function headingOf(l) { var m = l.match(/^\s{0,3}(#{1,6})\s+(.*)$/); return m ? { level: m[1].length, text: m[2].replace(/\s+$/, '') } : null }
+  function isQuote(l) { return /^\s{0,3}>/.test(l) }
+  function isTableSep(l) { return /^\s*\|?[\s:|-]*-[\s:|-]*\|?\s*$/.test(l) && l.indexOf('-') >= 0 && l.indexOf('|') >= 0 }
+  function isTableRow(l) { return l.indexOf('|') >= 0 && !isBlank(l) }
+  // 列表项：- / * / + 或 1. / 1) ；带缩进
+  function listItemOf(l) {
+    var m = l.match(/^(\s*)([-*+]|\d{1,9}[.)])\s+(.*)$/)
+    if (!m) return null
+    var ordered = /\d/.test(m[2])
+    return { indent: m[1].replace(/\t/g, '    ').length, ordered: ordered, text: m[3], marker: m[2] }
+  }
+  // 原始 HTML 块：以 <tag 或 <!-- 开头（到空行为止；不做完整 HTML 解析 ✓ 够用 ✓）
+  function isHtmlStart(l) {
+    return /^\s*<(div|p|table|details|summary|section|figure|blockquote|ul|ol|pre|mark|span|a|img|br|hr|sub|sup|kbd|dl|dt|dd|aside|nav|header|footer|video|audio|iframe|script|style)\b/i.test(l) ||
+      /^\s*<!--/.test(l)
+  }
+
+  function parseBlocks(lines) {
+    var out = []
+    var i = 0
+    while (i < lines.length) {
+      var l = lines[i]
+      if (isBlank(l)) { i++; continue }
+
+      // ① 围栏代码块
+      var fo = fenceOpen(l)
+      if (fo) {
+        var buf = []
+        i++
+        while (i < lines.length && !new RegExp('^\\s*' + fo.fence.charAt(0) + '{3,}\\s*$').test(lines[i])) { buf.push(lines[i]); i++ }
+        if (i < lines.length) i++   // 吃掉收尾围栏
+        out.push({ type: 'code', lang: fo.lang, text: buf.join('\n') })
+        continue
+      }
+
+      // ② 标题
+      var h = headingOf(l)
+      if (h) { out.push({ type: 'h', level: h.level, text: h.text }); i++; continue }
+
+      // ③ 分隔线
+      if (isHr(l)) { out.push({ type: 'hr' }); i++; continue }
+
+      // ④ 表格：本行含 | 且下一行是分隔行
+      if (isTableRow(l) && i + 1 < lines.length && isTableSep(lines[i + 1])) {
+        var rows = [], align = []
+        var sepCells = splitRow(lines[i + 1])
+        for (var a = 0; a < sepCells.length; a++) {
+          var s = sepCells[a].trim()
+          var lf = s.charAt(0) === ':', rt = s.charAt(s.length - 1) === ':'
+          align.push(lf && rt ? 'center' : (rt ? 'right' : (lf ? 'left' : '')))
+        }
+        rows.push(splitRow(l))
+        i += 2
+        while (i < lines.length && isTableRow(lines[i]) && !isBlank(lines[i])) { rows.push(splitRow(lines[i])); i++ }
+        // 紧跟的列宽/行高注释 ✓（我们自己的标记 ✓ 不算正文 ✓）
+        var widths = null, heights = null
+        while (i < lines.length) {
+          var c = lines[i].trim()
+          var mw = c.match(/^<!--\s*ccv-table:\s*([\d.,\s]+?)\s*-->$/)
+          var mh = c.match(/^<!--\s*ccv-table-h:\s*([\d.,auto\s]+?)\s*-->$/)
+          if (mw) { widths = mw[1].split(',').map(function (x) { return parseFloat(x) || 0 }); i++; continue }
+          if (mh) { heights = mh[1].split(',').map(function (x) { var v = String(x).trim(); return (v === 'auto' || !(parseFloat(v) > 0)) ? 0 : Math.round(parseFloat(v)) }); i++; continue }
+          break
+        }
+        out.push({ type: 'table', align: align, rows: rows, widths: widths, heights: heights })
+        continue
+      }
+
+      // ⑤ 引用（连续 > 行 → 内部递归 ✓）
+      if (isQuote(l)) {
+        var q = []
+        while (i < lines.length && (isQuote(lines[i]) || (q.length && !isBlank(lines[i]) && !headingOf(lines[i]) && !isHr(lines[i]) && !listItemOf(lines[i]) && !fenceOpen(lines[i])))) {
+          q.push(lines[i].replace(/^\s{0,3}>\s?/, ''))
+          i++
+        }
+        out.push({ type: 'quote', blocks: parseBlocks(q) })
+        continue
+      }
+
+      // ⑥ 列表（含嵌套缩进 ✓ 连续项算一个列表 ✓）
+      var li = listItemOf(l)
+      if (li) {
+        var items = []
+        var ordered = li.ordered
+        var startNo = li.ordered ? (parseInt(String(li.marker).replace(/[.)]$/, ''), 10) || 1) : 1
+        while (i < lines.length) {
+          var it = listItemOf(lines[i])
+          if (!it) break
+          var itemLines = [it.text]
+          var baseIndent = it.indent
+          i++
+          // 该项的续行
+          //   ⚠️ 空行后面只要**缩进更深**就仍属于这一项 ✓
+          //      —— 2026-10-15 修：原来只认"下一行还是列表项"✗
+          //         于是「- 项\n\n  ```代码块```」里的代码块被拉出列表 ✗
+          while (i < lines.length) {
+            if (isBlank(lines[i])) {
+              var nx = lines[i + 1] || ''
+              if (isBlank(nx)) break
+              var nxIndent = (nx.match(/^\s*/) || [''])[0].replace(/\t/g, '    ').length
+              if (nxIndent > baseIndent) { itemLines.push(''); i++; continue }
+              break
+            }
+            var nIt = listItemOf(lines[i])
+            if (nIt && nIt.indent <= baseIndent) break
+            var lineIndent = (lines[i].match(/^\s*/) || [''])[0].replace(/\t/g, '    ').length
+            if (lineIndent <= baseIndent && !/^\s{2,}/.test(lines[i])) break
+            // 保留相对缩进 ✓（至少去掉 baseIndent+2 的前缀 ✓）
+            itemLines.push(lines[i].replace(new RegExp('^\\s{0,' + (baseIndent + 2) + '}'), ''))
+            i++
+          }
+          // 去掉尾部空行 ✓
+          while (itemLines.length && isBlank(itemLines[itemLines.length - 1])) itemLines.pop()
+          items.push({ blocks: parseBlocks(itemLines) })
+          // 跳过一个空行继续找下一项 ✓
+          var save = i
+          while (i < lines.length && isBlank(lines[i])) i++
+          var after = listItemOf(lines[i] || '')
+          if (!after) { i = save; break }
+        }
+        out.push({ type: 'list', ordered: ordered, start: startNo, items: items })
+        continue
+      }
+
+      // ⑦ 原始 HTML 块
+      if (isHtmlStart(l)) {
+        var hb = []
+        while (i < lines.length && !isBlank(lines[i])) { hb.push(lines[i]); i++ }
+        out.push({ type: 'html', text: hb.join('\n') })
+        continue
+      }
+
+      // ⑧ 段落：连续非空行（到空行/其它块开头为止 ✓）
+      var pb = [l]
+      i++
+      while (i < lines.length && !isBlank(lines[i]) &&
+        !headingOf(lines[i]) && !isHr(lines[i]) && !fenceOpen(lines[i]) &&
+        !isQuote(lines[i]) && !listItemOf(lines[i]) && !isHtmlStart(lines[i]) &&
+        !(isTableRow(lines[i]) && i + 1 < lines.length && isTableSep(lines[i + 1]))) {
+        pb.push(lines[i]); i++
+      }
+      out.push({ type: 'p', text: pb.join('\n') })
+    }
+    return out
+  }
+
+  // 拆一行表格：| a | b | → ['a','b']（保留转义 \| ✓）
+  //   ⚠️ **必须与渲染器一致**（2026-10-15 结论 ✓）：
+  //      lib/client.js 的 buildTable 是 `raw.split("|")` —— **见 | 就拆** ✗
+  //      我一度加了"反引号里不拆" ✗ → 模型与视图各说各话 ✗
+  //      → 这里保持"见 | 就拆"✓ 与渲染器一字不差 ✓
+  function splitRow(l) {
+    var s = String(l).trim().replace(/^\|/, '').replace(/\|$/, '')
+    var cells = [], cur = ''
+    for (var i = 0; i < s.length; i++) {
+      var ch = s.charAt(i)
+      if (ch === '\\' && s.charAt(i + 1) === '|') { cur += '\\|'; i++; continue }
+      if (ch === '|') { cells.push(cur.trim()); cur = ''; continue }
+      cur += ch
+    }
+    cells.push(cur.trim())
+    return cells
+  }
+
+  // ─── 序列化：Doc → markdown（规范形式 ✓ 幂等的关键 ✓）────────────
+  function serialize(doc) {
+    var blocks = (doc && doc.blocks) || []
+    var parts = []
+    for (var i = 0; i < blocks.length; i++) {
+      var s = serBlock(blocks[i])
+      if (s !== '') parts.push(s)
+    }
+    return parts.join('\n\n') + '\n'
+  }
+
+  function serBlock(b) {
+    if (!b) return ''
+    switch (b.type) {
+      case 'h': return repeat('#', Math.max(1, Math.min(6, b.level || 1))) + ' ' + b.text
+      case 'hr': return '---'
+      case 'p': return b.text
+      case 'code': return '```' + (b.lang || '') + '\n' + b.text + '\n```'
+      case 'html': return b.text
+      case 'quote': {
+        var inner = serialize({ blocks: b.blocks }).replace(/\n$/, '')
+        return inner.split('\n').map(function (l) { return l === '' ? '>' : '> ' + l }).join('\n')
+      }
+      case 'list': {
+        var marker = b.ordered ? null : '-'
+        var out = []
+        var startN = b.ordered ? (b.start || 1) : 1   // ★ 起始序号要保 ✓（4. 不能写成 1. ✗）
+        for (var i = 0; i < b.items.length; i++) {
+          var mk = b.ordered ? (startN + i) + '. ' : marker + ' '
+          var body = serialize({ blocks: b.items[i].blocks }).replace(/\n$/, '')
+          var ls = body.split('\n')
+          out.push(mk + ls[0])
+          for (var j = 1; j < ls.length; j++) out.push(ls[j] === '' ? '' : '  ' + ls[j])
+        }
+        return out.join('\n')
+      }
+      case 'table': {
+        var rows = b.rows || []
+        var cols = 0
+        // 列数取所有行的**最大值** ✓（不截断 ✗ —— 截断会静默丢格子内容 ✗✗）
+        //   与渲染器一致：渲染器也是按最宽的那行画 ✓
+        //   → 若原文件的分隔行列数少于正文行 ✓ 规范化后会补齐 ✓（这是**好**的规范化 ✓）
+        for (var r = 0; r < rows.length; r++) if (rows[r].length > cols) cols = rows[r].length
+        if (!cols) return ''
+        var lines = []
+        for (var r2 = 0; r2 < rows.length; r2++) {
+          var row = rows[r2].slice()
+          while (row.length < cols) row.push('')
+          lines.push('| ' + row.join(' | ') + ' |')
+          if (r2 === 0) {
+            var sep = []
+            for (var c = 0; c < cols; c++) {
+              var al = (b.align && b.align[c]) || ''
+              sep.push(al === 'center' ? ':---:' : (al === 'right' ? '---:' : '---'))
+            }
+            lines.push('| ' + sep.join(' | ') + ' |')
+          }
+        }
+        var txt = lines.join('\n')
+        if (b.widths && b.widths.length) {
+          var any = false
+          for (var w = 0; w < b.widths.length; w++) if (b.widths[w] > 0) { any = true; break }
+          if (any) txt += '\n<!-- ccv-table: ' + b.widths.map(function (x) { return Math.round(x) || 0 }).join(',') + ' -->'
+        }
+        if (b.heights && b.heights.length) {
+          var anyH = false
+          for (var hh = 0; hh < b.heights.length; hh++) if (b.heights[hh] > 0) { anyH = true; break }
+          if (anyH) txt += '\n<!-- ccv-table-h: ' + b.heights.map(function (x) { return x > 0 ? Math.round(x) : 'auto' }).join(',') + ' -->'
+        }
+        return txt
+      }
+      default: return ''
+    }
+  }
+  function repeat(s, n) { var o = ''; for (var i = 0; i < n; i++) o += s; return o }
+
+  // ─── 幂等自检（P1 的验收工具 ✓）────────────────────────────────
+  // 返回 { once, twice, stable } —— stable 为 true 才算过关 ✓
+  function roundTrip(md) {
+    var once = serialize(parse(md))
+    var twice = serialize(parse(once))
+    return { once: once, twice: twice, stable: once === twice }
+  }
+
+  var API = { parse: parse, serialize: serialize, roundTrip: roundTrip, splitRow: splitRow }
+  try { if (typeof window !== 'undefined') window.__ccvDocModel = API } catch (_) {}
+  return API
+})()

package/lib/selref.js

@@ -4,8 +4,14 @@
 //       可点、整块删除、按发送时自动翻译成带定位信息的上下文。
 //       设计稿：canvas-docs/话布选区引用方案.md（v3）
 //
-// 加载方式：与 docdrop / doclink 完全相同 —— host 端点 /api/canvas/selref.js
-//           提供源码，client 入口动态执行。**改本文件只需刷新页面，不用重启。**
+// 加载方式：侧模块 —— host 端点 /api/canvas/selref.js 提供源码，
+//           client 入口动态执行。**改本文件只需刷新页面，不用重启。**
+//
+// ⚠️⚠️ **这个文件就是源头，直接改这里**（2026-10-14 补的说明）
+//    与它同类的还有 lib/viewer-md.js（同样是源头）。
+//    与之相反：**lib/client.js 是生成的** ✗（由 src/client/editor-panel.js 复制而来，
+//      `npm run build` 会覆盖它）—— 直接改 lib/client.js 会被冲掉 ✗
+//    （原注释写"与 docdrop / doclink 相同"——那两个模块 2026-10-11 随画布面板删除了 ✓）
 //
 // ── 与主模块的通信（重要）────────────────────────────────────────────
 // 侧模块由 new Function(src)() 执行，作用域是**全局**，拿不到主模块的局部变量
@@ -421,6 +427,27 @@
                 head = "【话布选区】" + (rec.doc.title || "(未命名)")
               }
               var out = head + "\n「" + rec.selected + "」"
+              // ── 零宽编号：**已验证可行，但还没启用**（2026-10-04 实测）──────
+              // 结论：零宽字符能一路活到服务端，可以拿来给每条引用藏一个看不见的编号。
+              //
+              // 实测证据（探针已撤，数据留着）：
+              //   客户端  ZW探针: serialize 输出含零宽空格 3 个，编号 1 / 编号 2
+              //   会话    agent/inbox/spliced 含 6 个 → user/message 含 6 个（2 条 × 3）
+              //   全链路 0 处被洗掉
+              //
+              // 为什么需要它：同一篇文档里同一个词出现多次时，两条引用会长得**一模一样**
+              //   （同一条 @路径 + 同一段「原文」），光靠文字分不出谁是谁，只能靠顺序 ——
+              //   而顺序一被调换就会**静默改错地方**。有了看不见的编号，
+              //   配对就与顺序无关：删掉一条、调换顺序、只发其中一条，都仍然精确。
+              //
+              // 启用时的写法（等编辑区方案落地再打开）：
+              //   out = out + "\u200B" + 把 rec.code 编成零宽序列
+              //   （U+200B 当 0、U+200C 当 1 就够；解码在 host 侧的 agent/pre-step）
+              //
+              // ⚠️ 教训：上一版探针装进了 client.js 的 insertQuoteBlock —— 那里**不是**
+              //    引用正文的产生地（正文是这里、发送那一刻拼的），结果白测一轮。
+              //    判断依据是**比对格式**：`@路径\n「原文」` 两行式，只有这里有。
+              // ────────────────────────────────────────────────────────
 
               // 正文里不再有定位信息。真正的"到底是哪一处"由服务端**主动注入**给模型 ——
               // 那边读的是**当前**文档，顺带把"这段引用是不是已经失效"也一并告诉它。
@@ -546,28 +573,84 @@
       return { start: det, end: det, draftRev: d.rev }
     }
 
+    // ═══ 「插入前先停在行首」═══════════════════════════════════════════
+    // 🔴 2026-10-04 主人实测：连着插两条引用，**第二条会粘在前一句话屁股上** ——
+    //
+    //     @"H:/…/123.md"
+    //     「1111」 测试1@"H:/…/123.md"      ← 粘住了，换行被吃掉
+    //     「1111」 测试2
+    //
+    //   因为胶囊是**零宽追加到草稿末尾**的（见 tailSpan）：末尾正好是主人刚打的字时，
+    //   它就直接贴上去。所以插入之前要保证草稿停在行首。
+    //
+    // ⚠️ 为什么不能"补一次换行就完事"：补换行**也是一次官方编辑**，它会把 draftRev
+    //    推进一格，而 window.__ccvInputState 是**异步**更新的。紧接着拿旧 rev 去派发
+    //    插入胶囊，会被官方的版本校验（CAS）拒掉 —— 那正是主人报过两次的
+    //    「第二条引用插不进去」。所以补完必须**等 rev 真的变了**再往下走。
+    function draftNeedsNewline(d) {
+      var t = d ? String(d.text || "") : ""
+      return t.length > 0 && !/\n$/.test(t)
+    }
+
+    // 轮询等草稿版本号变化（= 官方投影落地）。**超时也放行** ——
+    // 宁可拿旧 rev 试一次（官方会拒，拒了不破坏任何东西），也不卡在这里。
+    function waitDraftRevChanged(oldRev, timeoutMs) {
+      return new Promise(function (resolve) {
+        var t0 = Date.now()
+        function tick() {
+          var d = draftNow()
+          if (d && d.rev !== oldRev) return resolve(d)
+          if (Date.now() - t0 >= timeoutMs) {
+            log("补换行后等 rev 变化超时（" + timeoutMs + "ms），按当前草稿继续")
+            return resolve(d || null)
+          }
+          setTimeout(tick, 10)
+        }
+        tick()
+      })
+    }
+
+    var NEWLINE_WAIT_MS = 300
+
+    // @returns {Promise<object|null>} 补完换行之后**新读**的草稿描述（rev 是新的）
+    function ensureDraftAtLineStart() {
+      var d = draftNow()
+      if (!d) return Promise.resolve(null)
+      if (!draftNeedsNewline(d)) return Promise.resolve(d)          // 空草稿或在行首：不用补
+      var ok = dispatchInput("slash/input-insert-text", { text: "\n", span: tailSpan(d) })
+      log("插入前补换行：" + String(ok) + "（草稿末尾是 " + JSON.stringify(String(d.text).slice(-8)) + "）")
+      if (!ok) return Promise.resolve(draftNow())                    // 官方拒了：原样继续，不做别的
+      return waitDraftRevChanged(d.rev, NEWLINE_WAIT_MS)
+    }
+
     // 直接插入胶囊。成功 = 官方返回 true **且**胶囊数真的多了一个
     // （官方返回 true 只代表"编辑器接受并应用了这次编辑"，仍要数一遍才作数）。
     function insertChipDirect(rec) {
       return new Promise(function (resolve) {
         try {
           if (!rec) return resolve(false)
-          var d = draftNow()
-          if (!d) return resolve(false)
-          var before = chipCount()
-          var ok = dispatchInput("slash/input-insert-reference", {
-            reference: chipPayload(rec),
-            span: tailSpan(d)
-          })
-          log("直接插入：事件返回 " + String(ok) + "（草稿 " + d.text.length + " 字，版本 " + d.rev
-            + "，已有胶囊 " + before + " 条）")
-          if (!ok) return resolve(false)
-          setTimeout(function () {
-            var after = chipCount()
-            if (after > before) { log("直接插入成功：胶囊进了输入框（" + before + " → " + after + "）"); return resolve(true) }
-            log("直接插入：事件说成功了，但胶囊数没变（" + before + " → " + after + "）")
-            resolve(false)
-          }, VERIFY_MS)
+          ensureDraftAtLineStart().then(function (d) {
+            try {
+              if (!d) return resolve(false)
+              var before = chipCount()
+              var ok = dispatchInput("slash/input-insert-reference", {
+                reference: chipPayload(rec),
+                span: tailSpan(d)
+              })
+              log("直接插入：事件返回 " + String(ok) + "（草稿 " + d.text.length + " 字，版本 " + d.rev
+                + "，已有胶囊 " + before + " 条）")
+              if (!ok) return resolve(false)
+              setTimeout(function () {
+                var after = chipCount()
+                if (after > before) { log("直接插入成功：胶囊进了输入框（" + before + " → " + after + "）"); return resolve(true) }
+                log("直接插入：事件说成功了，但胶囊数没变（" + before + " → " + after + "）")
+                resolve(false)
+              }, VERIFY_MS)
+            } catch (e) {
+              log("直接插入异常: " + (e && e.message))
+              resolve(false)
+            }
+          }, function () { resolve(false) })
         } catch (e) {
           log("直接插入异常: " + (e && e.message))
           resolve(false)
@@ -583,8 +666,12 @@
       try {
         var d = draftNow()
         if (!d) { log("兜底插纯文字：读不到草稿，放弃"); return false }
-        var ok = dispatchInput("slash/input-insert-text", { text: String(body), span: tailSpan(d) })
-        log("兜底插纯文字：事件返回 " + String(ok))
+        // 纯文字这条路**不需要等**：换行可以和正文一起塞进同一次派发。
+        // （胶囊那条路做不到 —— insertReference 一次只能插一颗胶囊，带不了换行，
+        //   所以它才要"先派发换行、等 rev 落地、再派发胶囊"两步。）
+        var text = (draftNeedsNewline(d) ? "\n" : "") + String(body)
+        var ok = dispatchInput("slash/input-insert-text", { text: text, span: tailSpan(d) })
+        log("兜底插纯文字：事件返回 " + String(ok) + (text.charAt(0) === "\n" ? "（已补换行）" : ""))
         return ok
       } catch (e) {
         log("兜底插纯文字异常: " + (e && e.message))