dsh-composer-ease 0.0.0-stage → 0.9.66

package/lib/client/10-foundation.js

@@ -0,0 +1,396 @@
+// ── 模块：表与文本工具 ────────────────────────────────
+// 成对符号表（PAIRS/CLOSERS/家族/奇偶判据）、shouldPair、以及 contenteditable 的取文/摆光标/插字原语。
+// 本文件是 lib/client.js 的片段，由 tools/build-client.mjs 按序拼回；不要直接改生成物 lib/client.js。
+
+    var ROUTE_WORDS = '/dsh-composer-ease/words'
+ // 加全角/中文成对符：实测「输入（ 只出（」——中文输入法下原来完全没有配对。
+ // 全角走 input 事件那条补配对（IME 合成的字符不一定有对应的 keydown）。
+    var PAIRS = { '(': ')', '[': ']', '{': '}', '`': '`', '"': '"', "'": "'",
+                  '（': '）', '【': '】', '「': '」', '『': '』', '《': '》', '〈': '〉', '“': '”', '‘': '’' }
+    var CLOSERS = { ')': '(', ']': '[', '}': '{', '`': '`', '"': '"', "'": "'",
+                    '）': '（', '】': '【', '」': '「', '』': '『', '》': '《', '〉': '〈', '”': '“', '’': '‘' }
+
+ // ── 纯逻辑（selftest 直接喂）───────────────────────────────────────────
+ /** **成对家族**：所有成对符号的开符与闭符（半角 + 中文标点）。
+ * 三条反馈同一类：①有前引号再打引号出两个 ②中文模式打引号变多个
+ * ③括号也一样（`(` 后面再打 `(` 会变 `(()`）——所以守卫要从「引号」扩到整个家族：
+ * 光标前一个字符是家族里的任意成员时，只插一个字符、不补对。 */
+    var PAIRED_CHAR = /[()[\]{}（）【】「」『』《》〈〉“”‘’"'`]$/
+
+ /** 光标前这段文字里，`open` 是否处在一个**没闭合**的状态。
+ * 一次反馈就是这个漏的：
+ * 原来只看前一个字符（`PAIRED_CHAR`），当前面是「好」这种正文时看不到更早那个开符，
+ * 于是又补一对，得到 `"你好""`。对称引号按奇偶判，非对称按开符多于闭符判。 */
+ /* 引号家族（根因）：全角 “ 与半角 " 在判定里必须算同一个"引号位"，
+ * 否则中文输入法下混着打就永远被判成"没有开符"，于是一路补对、各处冒出多个引号。
+ * 规则只有一条：**引号永远成对，家族内合计字符数为奇 = 还有未闭合的引号**。
+ * 括号不进家族：`（` 与 `(` 语义不同，混用不算一对。 */
+    var QUOTE_FAMILY = '"\u201c\u201d\u201e\u201f\uff02\u0027\u2018\u2019\u201a\u201b\uff07'
+    function isQuoteChar(ch) { return !!ch && QUOTE_FAMILY.indexOf(ch) >= 0 }
+    function quoteCount(text) {
+      var q = String(text || ''), n = 0
+      for (var i = 0; i < q.length; i++) if (QUOTE_FAMILY.indexOf(q[i]) >= 0) n++
+      return n
+    }
+
+ /** 没闭合的那个引号在全文里的下标（撇号不算，与 unclosedQuoteCount 同口径）。
+ * 标红要画在**这个字符**底下，而不是整行：一行里只有一个引号真的有问题。 */
+    function unmatchedQuoteIndex(text) {
+      var s = String(text || ''), n = 0, last = -1
+      for (var i = 0; i < s.length; i++) {
+        var c = s.charAt(i)
+        if (!isQuoteChar(c)) continue
+        if (c === '\u0027' || c === '\u2019') {
+          var pv = s.charAt(i - 1), nx = s.charAt(i + 1)
+          if (/[A-Za-z0-9]/.test(pv) && /[A-Za-z0-9]/.test(nx)) continue
+        }
+        n++
+        last = i
+      }
+      return n % 2 === 1 ? last : -1
+    }
+
+    function isUnbalancedBefore(text, open, close) {
+      var s = String(text || '')
+ // 引号按家族奇偶判：`“你好` 与 `"你好` 同为未闭合，混着打也算一对
+      if (isQuoteChar(open) || isQuoteChar(close)) return quoteCount(s) % 2 === 1
+      var o = 0, c = 0
+      for (var i = 0; i < s.length; i++) {
+        if (s[i] === open) o++
+        else if (close !== open && s[i] === close) c++
+      }
+      return close === open ? (o % 2 === 1) : (o > c)
+    }
+ /** 光标前那一段的最后是不是「一个**非空**成对符号的闭符」——即这块内容已经被框好了。
+ * 用来挡「框完再打一次闭符，于是多堆一个」：`"你好"` 再打 `"` 不该变成 `"你好""`。
+ * **空对（`""`、`()`）不算**：连打引号/括号是「写 ``` 围栏」那类正常用法，见行为矩阵里的连按用例。 */
+    function alreadyClosedBefore(before, open, close) {
+      var s = String(before || '')
+      if (s.length < 3) return false                        // 至少要「开符 + 一个字符 + 闭符」
+ // 只认「同字符」的已闭合（`"abc"` 后再打 " 才跳过）。
+ // 混宽一律不吞 —— 那是的一次反馈。
+      if (s.charAt(s.length - 1) !== close) return false
+      if (s.charAt(s.length - 2) === open) return false     // 空对：放行（连按引号仍要能打出来）
+      return isUnbalancedBefore(s.slice(0, -1), open, close)
+    }
+ /** 该不该补闭符：上一个字符是成对家族成员→不配；右边紧跟字母/数字/汉字→不配；其余补。 */
+ /** 唯一决策入口：纯函数，返回 { action: wrap|skip|convert|pair|insert, open, close }。 */
+    function decideType(ch, ctx) {
+      var c = ctx || {}
+      var before = String(c.before || '')
+      var after = String(c.after || '')
+      var open = ch, close = PAIRS[ch] || ''
+      if (c.selection) return { action: 'wrap', open: open, close: close }
+      if (c.fwHalf && FW_TO_ASCII[ch]) { open = FW_TO_ASCII[ch]; close = PAIRS[open] || ''; return { action: 'convert', open: open, close: close } }
+      if (after === close && close) return { action: 'skip', open: open, close: close }
+      if (close && alreadyClosedBefore(before, open, close)) return { action: 'insert', open: open, close: close }
+      if (close === open && before.slice(-1) === open) return { action: 'insert', open: open, close: close }
+      if (close && isUnbalancedBefore(before, open, close)) return { action: 'insert', open: open, close: close }
+      if (shouldPair(before, after, ch)) return { action: 'pair', open: open, close: close }
+      return { action: 'insert', open: open, close: close }
+    }
+
+// VS Code 打字拦截层（模式 + before 集合 + 编辑列表），常量取自其产物
+    var AC_MODES = ['always', 'languageDefined', 'beforeWhitespace', 'never']
+    var AC_BEFORE_QUOTES = ';:.,=}])> \t'
+    var AC_BEFORE_BRACKETS = '\'"`;:.,=}])> \t'
+    var AC_BEFORE_WS = ' \t'
+
+ /** 设置 → 模式（认不得的值按 languageDefined 处理，与 VS Code 的默认值一致）。 */
+    function autoCloseMode(kind) {
+      var v = ''
+      try { v = String(window.localStorage.getItem('dsh-composer-ease:autoClose' + (kind === 'quote' ? 'Quotes' : 'Brackets')) || '') } catch (e) {}
+      return AC_MODES.indexOf(v) >= 0 ? v : 'languageDefined'
+    }
+    function setAutoCloseMode(kind, mode) {
+      try { window.localStorage.setItem('dsh-composer-ease:autoClose' + (kind === 'quote' ? 'Quotes' : 'Brackets'), AC_MODES.indexOf(mode) >= 0 ? mode : 'languageDefined') } catch (e) {}
+    }
+
+ /** VS Code 的 shouldAutoCloseBefore：只有前一个字符落在集合里才补对。kind 决定用哪张集合。 */
+    function shouldAutoCloseBefore(prev, mode, kind) {
+      var m = AC_MODES.indexOf(mode) >= 0 ? mode : 'languageDefined'
+      if (m === 'always') return true
+      if (m === 'never') return false
+      if (m === 'beforeWhitespace') return AC_BEFORE_WS.indexOf(prev) >= 0
+      var set = kind === 'quote' ? AC_BEFORE_QUOTES : AC_BEFORE_BRACKETS
+ // 空上下文、中文、字母数字后允许成对
+      if (!prev) return true
+      if (/[\u4e00-\u9fff]/.test(prev)) return true
+      if (/[A-Za-z0-9_]/.test(prev)) return true
+      return set.indexOf(prev) >= 0
+    }
+
+ /** 打一个字符要做的编辑（VS Code 的 typeWithInterceptors 子集）：
+ *  返回 [{ range: [from, to], text }]，按 from 升序；空数组＝不干预，交原生插入。 */
+    function buildTypeEdits(ch, ctx) {
+      var c = ctx || {}
+      var before = String(c.before || ''), after = String(c.after || '')
+      var sel = c.selection || ''
+      var off = before.length
+      var close = PAIRS[ch] || ''
+      var kind = isQuoteChar(ch) ? 'quote' : 'bracket'
+      var mode = autoCloseMode(kind)
+      var edits = []
+ // 有选区：框住（surround）
+      if (sel) {
+        return [{ range: [off, off + sel.length], text: ch + sel + close, caret: off + 1, select: [off + 1, off + 1 + sel.length] }]
+      }
+ // 全角括号开关：换算成半角对子
+      if (c.fwHalf && FW_TO_ASCII[ch]) { ch = FW_TO_ASCII[ch]; close = PAIRS[ch] || '' }
+ // 右边已经是同一个闭符：跳过去（overtype）
+      if (close && after === close) return [{ range: [off + 1, off + 1], text: '', caret: off + 1 }]
+      if (!close) return edits
+ // 已闭合 / 未闭合：只插一个
+      if (alreadyClosedBefore(before, ch, close)) return edits
+      if (close === ch && before.slice(-1) === ch) return edits
+      if (isUnbalancedBefore(before, ch, close)) return edits
+      if (!shouldAutoCloseBefore(before.slice(-1), mode, kind)) return edits
+      if (/[A-Za-z0-9_\u4e00-\u9fff]/.test(String(after || ''))) return edits   // 右边紧跟文字时不补（VS Code 的 beforeWhitespace 精神）
+      return [{ range: [off, off], text: ch + close, caret: off + 1 }]
+    }
+
+    function shouldPair(before, after, ch) {
+ // 引号（恢复「打一个引号得一对」）：
+ // 严格配对开 → 老行为，一律补对；
+ // 严格配对关（默认）→ 也补对，但按 VS Code `editor.autoClosingQuotes` 的
+ // `beforeWhitespace` 口径收窄：**右边紧跟文字时不补**（保护「在一段已有文字前打前引号」，
+ // 实测发现的多一个引号就是这条），左边已是成对符号时也不补。
+ // 历史：曾一律只插一个，原因是配对后光标靠 DOM Range 复位，
+ // 快速连打会多冒一个引号；现在走的是括号那条 `insertAtomic + placeCaretVerified`
+ // 的复核链（文本护栏 + 跨帧校验），所以放回来。
+      if (isQuoteChar(ch)) {
+ // warn 模式（默认）：不自动补闭引号 —— 闭符落到句子末尾、以及"打完一个引号多一个"的
+ // 两类投诉都源于自动补对；这里改为只插当前字符，由 lintQuotes 标红提示。
+        if (quoteMode() !== 'auto') return false
+        if (pairStrict()) return true
+        if (/[A-Za-z0-9_\u4e00-\u9fff]/.test(String(after || ''))) return false
+ // 引号是自对称的，前一个引号到底是开符还是闭符只能看**奇偶**：奇数 = 还悬着一个开符，
+ // 这一下不该再补对；偶数 = 前面那对已经闭合，新打的引号应当开一对新的（反馈：其他引号都闭合
+ // 的情况下，新打引号不出对）。
+        var lastCh = String(before || '').slice(-1)
+        if (isQuoteChar(lastCh) && quoteCount(String(before || '')) % 2 === 1) return false
+        if (!isQuoteChar(lastCh) && PAIRED_CHAR.test(lastCh)) return false
+        return true
+      }
+      if (/[A-Za-z0-9_\u4e00-\u9fff]/.test(String(after || ''))) return false
+      var last = before.slice(-1)
+      if (PAIRED_CHAR.test(last)) return false
+ // 与 VS Code 的 `editor.autoClosingBrackets: languageDefined` 对齐：词/数字后面照样补对
+ // （`abc` 后打 `(` 得 `abc()`）。旧规则在标识符后面不补，用户看到的就是「括号不配对」。
+      return true
+    }
+ /** 取 caret 前的当前 token（补全用）：文件/标识符字符集，遇空白或换行截断。 */
+ /** 展开片段占位符：`${n:默认值}` → 默认值（或空），同时算出每个落点的**偏移**。
+ * 返回 { text, stops }；stops 按占位符编号升序（与出现顺序无关），供 Tab 依次跳。 */
+    function expandSnippet(v) {
+      var src = String(v || '')
+      var re = /\$\{(\d+)(?::([^}]*))?\}/g
+      var out = '', stops = [], m, last = 0
+      while ((m = re.exec(src))) {
+        out += src.slice(last, m.index)
+        out += m[2] || ''
+        stops.push({ n: Number(m[1]), at: out.length })
+        last = re.lastIndex
+      }
+      out += src.slice(last)
+      stops.sort(function (a, b) { return a.n - b.n })
+      return { text: out, stops: stops.map(function (s) { return s.at }) }
+    }
+
+    function tokenBefore(text) {
+      var m = String(text || '').match(/([A-Za-z0-9_./@:,-]*)$/)
+      return m ? m[1] : ''
+    }
+ /** 键位决策表：返回动作名，selftest 与真实监听共用判据。 */
+    function keyAction(k) {
+      if (k.ctrl && k.code === 'Space') return 'complete'
+      if (k.key === 'Escape') return 'dismiss'
+ // （实测发现的）：聊天框里**回车必须发送**，不能被补全弹层吃掉。
+ // 原来 Enter 也算接受，弹层开着时连按回车就把候选一遍遍插进正文（打出
+ // "i临时目录/attrib-index.dif临时目录/attrib-index.dif…" 那种滚雪球）。接受只留 Tab。
+      if (k.__popupOpen && k.key === 'Tab') return 'accept'
+      if (k.key === 'Backspace' && !k.__collapsedFalse) return 'pairbackspace'
+ // 对称引号（" ' `）右边已经是同一个字符：走「跳过」而不是再补一对（否则就是多出来的那一对）
+      if (k.__nextIsCloser && Object.prototype.hasOwnProperty.call(CLOSERS, k.key)) return 'pairclose'
+      if (Object.prototype.hasOwnProperty.call(PAIRS, k.key)) return 'pairopen'
+      if (Object.prototype.hasOwnProperty.call(CLOSERS, k.key)) return 'pairclose'
+      return null
+    }
+
+ // ── DOM 层 ──────────────────────────────────────────────────────────────
+    function composerOf(el) {
+      if (!el || el === document.body) return null
+      var c = el.closest ? el.closest('[data-composer-input], textarea, [contenteditable="true"], [contenteditable=""]') : null
+      return c
+    }
+    function isText(ed) {
+      return ed && (ed.tagName === 'TEXTAREA' || ed.tagName === 'INPUT')
+    }
+ /* 插件的 keydown 监听在**捕获阶段**，跑在 Lexical 自己的键位处理之前；插入后立刻改光标/选区
+ * 会被 Lexical 随后的渲染覆盖（实测扫出来的）。contenteditable 这条路一律往后推一拍再改选区。 */
+    function soon(fn) { try { setTimeout(fn, 0) } catch (e) { fn() } }
+
+ // 全角 → 半角映射（模块级：beforeinput 与 input 两条路都要用，放在某个处理器里会 ReferenceError）
+    var FW_TO_ASCII = { '（': '(', '【': '[' }
+    var FULL_TO_HALF_OPEN = { '（': 1, '【': 1 }   // 需要换算的全角开符   // 只换括号：引号族保持输入法给的字符
+ // keydown 已经自己换过的那一下，beforeinput 不要再换一遍（否则 （ 变成 （() ）
+    var fwKeyHandled = false
+
+ /** 删光标前一个字符：Lexical 只认按键路径的删除。 */
+    function backspaceOnce(ed) {
+      try {
+        window.__dceSyntheticBackspace = true
+        var ev = new KeyboardEvent('keydown', { key: 'Backspace', code: 'Backspace', keyCode: 8, which: 8, bubbles: true, cancelable: true })
+        ed.dispatchEvent(ev)
+        window.__dceSyntheticBackspace = false
+        return true
+      } catch (e) { window.__dceSyntheticBackspace = false; return false }
+    }
+
+    function insertText(ed, text) {
+      if (isText(ed)) {
+        var s = Object.getOwnPropertyDescriptor(window.HTMLTextAreaElement.prototype, 'value').set
+        var start = ed.selectionStart, end = ed.selectionEnd
+        s.call(ed, ed.value.slice(0, start) + text + ed.value.slice(end))
+        ed.selectionStart = ed.selectionEnd = start + text.length
+        ed.dispatchEvent(new Event('input', { bubbles: true }))
+      } else {
+        ed.focus()
+        document.execCommand('insertText', false, text)
+      }
+    }
+ /** 插文本的**通用入口**：多行走合成 paste（实测：片段是多行的，
+ * `execCommand('insertText')` 在真 Lexical 上会被吃掉 —— 连点选片段都插不进去）。
+ * 宿主接下 paste（返回 false = preventDefault 过）就不再兜底；否则退回 execCommand。 */
+    function insertRich(ed, text) {
+      var s = String(text == null ? '' : text)
+      if (isText(ed) || s.indexOf('\n') < 0) return insertText(ed, s)
+      try {
+        var dt = new DataTransfer()
+        dt.setData('text/plain', s)
+        var evP = new ClipboardEvent('paste', { clipboardData: dt, bubbles: true, cancelable: true })
+        if (ed.dispatchEvent(evP) === false) return
+      } catch (e) {}
+      insertText(ed, s)
+    }
+
+    function selectedText(ed) {
+      if (isText(ed)) return ed.value.slice(ed.selectionStart, ed.selectionEnd)
+      var sel = window.getSelection()
+      return sel && !sel.isCollapsed ? sel.toString() : ''
+    }
+
+ /* 实测扫出来的坑：Lexical 不认 `sel.modify(...)` —— 在真 composer 上
+ * 配对后的光标、跳闭合、删空对、环绕选区还原、Tab 替换 token 全都没生效（值对了、位置全错）。
+ * 改成把 composer 文本摊平成一个字符偏移，用显式 Range 定位/选区。文本节点之外的东西
+ * （br、mention 之类）按 0 长处理：真 composer 里就是纯文本，够用。 */
+    function flatText(ed) {
+      try {
+        var w = document.createTreeWalker(ed, 4 /* SHOW_TEXT */, null)
+        var out = '', node
+        while ((node = w.nextNode())) out += node.nodeValue || ''
+        return out
+      } catch (e) { return '' }
+    }
+ /** 数一个文档片段里文本节点的字符数（与 flatText 同口径：只数文本节点，不含块边界）。 */
+    function textLenOf(frag) {
+      try {
+        var w = document.createTreeWalker(frag, 4 /* SHOW_TEXT */, null)
+        var n = 0, node
+        while ((node = w.nextNode())) n += (node.nodeValue || '').length
+        return n
+      } catch (e) { return 0 }
+    }
+    function caretOffset(ed) {
+      try {
+        var sel = window.getSelection()
+        if (!sel || !sel.rangeCount) return -1
+        var r = sel.getRangeAt(0)
+        var pre = r.cloneRange()
+        pre.selectNodeContents(ed)
+        pre.setEnd(r.endContainer, r.endOffset)
+        return pre.toString().length
+      } catch (e) { return -1 }
+    }
+ /** 摆光标：文本域直接写 selectionStart，contenteditable 才需要 Range（setSelectionRange 只认 Selection）。 */
+    function setCaret(ed, off) {
+      if (off < 0) return
+      if (isText(ed)) { try { ed.selectionStart = ed.selectionEnd = off } catch (e) {} ; return }
+      setSelectionRange(ed, off, off)
+    }
+ /** 当前光标偏移，文本域与 contenteditable 同一个口径（caretOffset 只认 Selection）。 */
+    function caretPos(ed) {
+      if (isText(ed)) { try { return ed.selectionStart } catch (e) { return -1 } }
+      return caretOffset(ed)
+    }
+ /** 把选区设成 composer 内的 [start, end) 字符区间；失败返回 false。 */
+ /** 把光标前 count 个字符替换成 text（text 两字符时，光标落在两字符之间）。
+ * 输入法把 ( 合成 （ 之后要换成 ()，text-input 与 contenteditable 两条路都得能走。 */
+    function replaceBeforeCaret(ed, count, text) {
+      if (isText(ed)) {
+        var pos = ed.selectionStart
+        if (pos < count) return false
+        var set = Object.getOwnPropertyDescriptor(window.HTMLTextAreaElement.prototype, 'value').set
+        set.call(ed, ed.value.slice(0, pos - count) + text + ed.value.slice(pos))
+        ed.selectionStart = ed.selectionEnd = pos - count + Math.max(1, text.length - 1)
+        ed.dispatchEvent(new Event('input', { bubbles: true }))
+        return true
+      }
+      var at = caretPos(ed)
+      var before = textOf(ed)
+      if (at < count || !setSelectionRange(ed, at - count, at)) return false
+      insertText(ed, text)
+ // 宿主可能吃掉这次 insertText（实测 Lexical 对 2 字符串会静默不落字）：
+ // 按整段文本复核，没落地就交回给原来的配对路径，别让开关变成「点了没反应」。
+      var want = before.slice(0, at - count) + text + before.slice(at)
+      if (textOf(ed) !== want) {
+        if (setSelectionRange(ed, at, at)) { /* 复原光标，让调用方继续走老路 */ }
+        return false
+      }
+      placeCaretVerified(ed, at - count + Math.max(1, text.length - 1), want)
+      return true
+    }
+
+    function setSelectionRange(ed, start, end) {
+      try {
+        var sel = window.getSelection()
+        if (!sel) return false
+        var walker = document.createTreeWalker(ed, 4, null)
+        var acc = 0, node, startNode = null, startOff = 0, endNode = null, endOff = 0
+        while ((node = walker.nextNode())) {
+          var len = (node.nodeValue || '').length
+          if (startNode === null && acc + len >= start) { startNode = node; startOff = Math.max(0, start - acc) }
+          if (acc + len >= end) { endNode = node; endOff = Math.max(0, end - acc); break }
+          acc += len
+        }
+        var r = document.createRange()
+        if (startNode && endNode) { r.setStart(startNode, startOff); r.setEnd(endNode, endOff) }
+        else { r.selectNodeContents(ed); r.collapse(false) }
+        sel.removeAllRanges(); sel.addRange(r)
+        return true
+      } catch (e) { return false }
+    }
+
+    function caretChar(ed, dir) {
+      try {
+        if (isText(ed)) {
+          var i = ed.selectionStart
+          return dir > 0 ? ed.value[i] || '' : ed.value[i - 1] || ''
+        }
+        var off = caretOffset(ed)
+        if (off < 0) return ''
+        var t = flatText(ed)
+        return dir > 0 ? (t[off] || '') : (t[off - 1] || '')
+      } catch (e) { return '' }
+    }
+    function selectBack(ed, n) { // 把 caret 前 n 个字符变成选区（补全替换 token 用）
+      try {
+        if (isText(ed)) { ed.selectionStart = Math.max(0, ed.selectionStart - n); return }
+        var off = caretOffset(ed)
+        if (off >= 0) setSelectionRange(ed, Math.max(0, off - n), off)
+      } catch (e) {}
+    }
+  /** 环绕选区：把选中内容用一对符号框起来，光标落在闭符之后（框完继续打字接在闭符后面）。
+   * 插入只能走 **paste 通道**（合成 ClipboardEvent）—— `insertText` 拼好的多行文本会被 Lexical 吃掉，
+   * 连续两次 execCommand 也会被它的重渲染清成最后一个字符。没被接管时才退回 execCommand。 */
+ /* 上一次框选的范围：用于「再打一次同一个引号 = 取消这次框选」（）。 */

package/lib/client/20-pairing.js

@@ -0,0 +1,177 @@
+// ── 模块：配对与框选 ────────────────────────────────
+// wrapSelection / repairWrapDup / tryUnwrap / surroundSelection：把选区框起来、以及框完的反选与清理。
+// 本文件是 lib/client.js 的片段，由 tools/build-client.mjs 按序拼回；不要直接改生成物 lib/client.js。
+
+    var lastWrap = null
+
+ /* 框选只是"一个动作"：期间不许弹补全。
+ * 实测原因：Lexical 不认 preventDefault，会先把选区替成那一个字符，插件随后用 paste 补全；
+ * 这中间的 input 事件足以让自动补全弹出来 —— 也就是说的"暴露第一个字然后进行提醒"。 */
+    function wrapSelection(ed, open, selTxt, close) {
+      var from = textBeforeCaret(ed).length
+      var baseLen = textOf(ed).length
+      var prevSuppress = suppressInput
+      suppressInput = prevSuppress + 1
+      closePopup()
+      try {
+        surroundSelection(ed, open, selTxt, close)
+      } finally {
+        suppressInput = prevSuppress          // 只压住自己这一次插入，不泄漏给下一键
+        var start = from + open.length
+        lastWrap = { ed: ed, open: open, close: close, start: start,
+                     end: start + String(selTxt || '').length, inner: String(selTxt || '') }
+ // 落地后按真文本复核（实测：全角 “ 包裹会多出一个开符 ——
+ // Lexical 不认 preventDefault，粘贴之外它又按自己的键插了一遍；
+ // 于是 Ctrl+Z 撤掉的是那个多余引号，而不是把原文还回来）。
+ // 多拍复核：Lexical 那次"按自己的键再插一遍"落在插件第一次复核之后（实测），
+ // 所以按 0/16/48/120/240ms 各看一次，命中一次就收（修复是幂等的）。
+        var wantLen = baseLen + open.length + close.length
+ // 多行/带空格的包裹走 execCommand 兜底时会被吃掉一部分（实测：围栏里选中整段再框，
+ // 落地的是「开符 + 内容」，闭符没了）。所以落定后复核一次，缺哪一侧就补哪一侧。
+        ;[0, 16, 48, 120, 240].forEach(function (ms) {
+          setTimeout(function () { repairWrapDup(ed, open, String(selTxt || ''), close, wantLen) }, ms)
+        })
+      }
+    }
+
+ /* 「反选」：框完再打同一个引号 → 去掉两侧、内层重新选中。文本被别人改过就不认。
+ * deleteAt(ed, off) 只删一个字符，从后往前删，开符那一侧的偏移不会被挪动。 */
+
+ /** 包裹后按真文本复核：把「不在 open+内层+close 里」的多余开符删掉。
+ * 实测 全角 “ 包裹时 Lexical 会按自己的模型再插一个开符，而且**落在文首**
+ * （选中 abcd 的 1-3 → `“a“bc”d`），原来的判断只认紧挨着的 `open+open`，所以漏了。 */
+    function repairWrapDup(ed, open, inner, close, wantLen) {
+      try {
+        var t = textOf(ed)
+ // 长度不变量：包裹只在选区两侧各加一个字符。文本没变长就说明没有多余开符，
+ // 一旦动手就会删掉正确的那一个（半角中文那例就是这么被删坏的）。
+        if (typeof wantLen === 'number' && t.length <= wantLen) return
+        var want = open + inner + close
+        var at = t.indexOf(want)
+        if (at < 0) return
+        for (var i = 0; i < t.length; i++) {
+          if (t.charAt(i) !== open) continue
+          if (i >= at && i < at + open.length) continue     // 正确那个开符
+          deleteAt(ed, i)                                   // 落在地上的多余开符
+          t = textOf(ed)
+          at = t.indexOf(want)
+          break
+        }
+        if (at >= 0) {
+          var endAt = at + want.length
+          if (t.charAt(endAt - 1) === close) placeCaretVerified(ed, endAt, t)
+          lastWrap && (lastWrap.start = at + open.length)
+        }
+      } catch (e) {}
+    }
+
+    function tryUnwrap(ed, open) {
+      if (!lastWrap || lastWrap.ed !== ed || lastWrap.open !== open) return false
+      if (open !== lastWrap.close) return false
+      var w = lastWrap
+      var text = textOf(ed)
+      var start = w.start
+      var exact = text.slice(w.start - 1, w.start) === open
+        && text.slice(w.end, w.end + 1) === w.close
+        && text.slice(w.start, w.end) === w.inner
+      if (!exact) {
+ // 位置口径在不同编辑器里不一致（textBeforeCaret 可能按选区起点也可能按末端），
+ // 所以对不上时按「开符 + 内层 + 闭符」在全文里找一次；找不到才算被改过。
+        var at = text.indexOf(open + w.inner + w.close)
+        if (at < 0) { lastWrap = null; return false }
+        start = at + open.length
+      }
+      lastWrap = null
+      var innerEnd = start + w.inner.length
+ // 一次替换，不留给编辑器中间态：选中 open+inner+close，用 inner 覆盖
+      if (isText(ed)) {
+        ed.selectionStart = start - 1
+        ed.selectionEnd = innerEnd + 1
+      } else {
+        setSelectionRange(ed, start - 1, innerEnd + 1)
+      }
+      insertText(ed, w.inner)
+      if (isText(ed)) {
+        ed.selectionStart = start - 1
+        ed.selectionEnd = start - 1 + w.inner.length
+      } else {
+        soon(function () { setSelectionRange(ed, start - 1, start - 1 + w.inner.length) })
+      }
+      return true
+    }
+
+ /** 多行包裹的第二步：确认「开符 + 内容 + 闭符」齐全，缺闭符就补一个（单字符插入）。
+ * 幂等：已经齐了就什么都不做；找不到「开符 + 内容」也放手，不猜位置。 */
+    function finishMultilineWrap(ed, open, inner, close) {
+      try {
+        var t = textOf(ed)
+        var want = open + inner + close
+        if (t.indexOf(want) >= 0) return
+        var head = open + inner
+        var at = t.indexOf(head)
+        if (at < 0) return
+        var pos = at + head.length
+        if (t.charAt(pos) === close) return
+        setSelectionRange(ed, pos, pos)
+        suppressInput++
+        insertText(ed, close)
+        placeCaretVerified(ed, pos + close.length, t.slice(0, pos) + close + t.slice(pos))
+      } catch (e) {}
+    }
+    function surroundSelection(ed, open, selTxt, close) {
+      try {
+        if (!isText(ed)) {
+          var sel = window.getSelection()
+          if (!sel || !sel.rangeCount) return
+          var inner = String(selTxt || sel.toString() || '')
+          var text = open + inner + close
+ // 含换行的选区（两段以上、代码围栏整段）分两步包裹：
+ // ① 80ms 后贴「开符 + 内容」—— 同拍贴整段时宿主会把**末尾的引号**吃掉（只丢引号，不丢别的字符）；
+ // ② 再等 400ms 核对，缺闭符就用单字符插入补上（那时宿主已落定，单字符插入稳定）。
+ // 判据：两段文本两侧引号齐全、每次一致；撤销两拍回到原句（单段仍是一拍）。
+          if (String(inner).indexOf('\n') >= 0) {
+            setTimeout(function () {
+              try {
+                var selNow = window.getSelection()
+                if (!selNow || !selNow.rangeCount || !String(selNow)) return
+                var dtM = new DataTransfer()
+                dtM.setData('text/plain', open + String(inner))
+                ed.dispatchEvent(new ClipboardEvent('paste', { clipboardData: dtM, bubbles: true, cancelable: true }))
+                setTimeout(function () { finishMultilineWrap(ed, open, String(inner), close) }, 400)
+              } catch (eM) {}
+            }, 80)
+            return
+          }
+          var tailLen = 0
+          try {
+            var r0 = sel.getRangeAt(0)
+            var afterR = document.createRange()
+            afterR.selectNodeContents(ed)
+            afterR.setStart(r0.endContainer, r0.endOffset)
+            tailLen = textLenOf(afterR.cloneContents())
+          } catch (e5) { tailLen = 0 }
+          var handled = false
+          try {
+            var dt = new DataTransfer()
+            dt.setData('text/plain', text)
+            var evPaste = new ClipboardEvent('paste', { clipboardData: dt, bubbles: true, cancelable: true })
+            handled = ed.dispatchEvent(evPaste) === false     // false = 被 preventDefault = 编辑器接下了
+          } catch (e3) {}
+          dbg('wrap-paste', { ed: ed, sel: inner, handled: handled })
+ // 兜底只在**宿主没接**时走 execCommand；它含空格会静默不落字，落没落由 wrapSelection 复核
+          if (!handled) insertText(ed, text)
+          soon(function () {                                  // 等 Lexical 落定，再把光标放到闭符之后
+            try {
+              var at = flatText(ed).length - tailLen
+              if (at >= 0) setSelectionRange(ed, at, at)
+            } catch (e4) {}
+          })
+          return
+        }
+        insertText(ed, open + selTxt + close)
+        var endAt = ed.selectionStart                        // 文本插入完成后 caret 在整段之后
+        ed.selectionStart = ed.selectionEnd = endAt          // 就在这里：闭符之后
+      } catch (e) {}
+    }
+
+ // 弹层：一个 fixed div，数据来自 words 路由