dsh-composer-ease 0.0.0-stage → 0.9.66

package/lib/client/45-settings.js

@@ -0,0 +1,225 @@
+// ── 模块：设置项（严格配对 / 引号模式 / 候选类型预设）──────────────────
+// 从 70-input.js 拆出来的（加完候选类型预设后那个片段到 411 行，超结构闸的 400 上限）。
+// 只放「存哪儿 + 怎么读 + 预设怎么切」，不碰事件处理。
+
+    var PAIR_STRICT_KEY = 'dsh-composer-ease:pairStrict'
+    function pairStrict() {
+      try { return window.localStorage.getItem(PAIR_STRICT_KEY) === '1' } catch (e) { return false }
+    }
+    function setPairStrict(on) {
+      try { window.localStorage.setItem(PAIR_STRICT_KEY, on ? '1' : '0') } catch (e) {}
+    }
+
+ /* 引号模式（）：'warn' = 不自动补闭引号，未闭合时标红提示（VS Code 的
+ * 「标红而不是硬改」口径，默认）；'auto' = 老行为，打一个引号补一对。 */
+ /* 候选类型开关（等价 VS Code `suggest.show*` 一族里插件有的四类）：
+ * 存「关掉哪些」，默认全开；过滤在候选合并那一处做，索引/灰字/Tab 都跟着同一份列表。 */
+    var KIND_KEY = 'dsh-composer-ease:kinds-off'
+    var ALL_KINDS = [['word', '词'], ['file', '文件'], ['model', '模型'], ['snippet', '片段']]
+    function kindsOff() {
+      try { var a = JSON.parse(window.localStorage.getItem(KIND_KEY) || '[]'); return Array.isArray(a) ? a : [] } catch (e) { return [] }
+    }
+    function isKindOn(k) { return kindsOff().indexOf(k) < 0 }
+    function toggleKind(k) {
+      var off = kindsOff(), i = off.indexOf(k)
+      if (i >= 0) off.splice(i, 1); else off.push(k)
+      try { window.localStorage.setItem(KIND_KEY, JSON.stringify(off)) } catch (e) {}
+    }
+
+ /* 候选类型**预设**：不把四个开关摊成四行（`/` 菜单里太费），一行循环切换。
+ * 组合仍是四个 kind 的开关，所以手改 localStorage 的 kinds-off 依然有效。 */
+    var KIND_PRESETS = [
+      { label: '全部', off: [] },
+      { label: '无文件', off: ['file'] },
+      { label: '只有词', off: ['file', 'snippet', 'model'] },
+      { label: '全关', off: ['word', 'file', 'model', 'snippet'] },
+    ]
+    function kindPresetIndex() {
+      var off = kindsOff().slice().sort().join(',')
+      for (var i = 0; i < KIND_PRESETS.length; i++) {
+        if (KIND_PRESETS[i].off.slice().sort().join(',') === off) return i
+      }
+      return -1          // 手工组合：不属于任何预设
+    }
+    function kindPresetLabel() {
+      var i = kindPresetIndex()
+      return i >= 0 ? KIND_PRESETS[i].label : '自定义'
+    }
+    function kindPresetDesc() {
+      var i = kindPresetIndex()
+      if (i < 0) return '自定义组合（' + ALL_KINDS.filter(function (k) { return isKindOn(k[0]) }).map(function (k) { return k[1] }).join('+') + '）'
+      return i === 0 ? '词 + 文件 + 模型 + 片段 全开'
+        : i === 1 ? '词 + 模型 + 片段（文件路径不进候选）'
+        : i === 2 ? '只留词（词典 / 关键字 / 本机词）'
+        : '四类全关（等于关掉补全）'
+    }
+    function kindPresetNextLabel() {
+      var i = kindPresetIndex()
+      return KIND_PRESETS[(i + 1) % KIND_PRESETS.length].label
+    }
+    function cycleKindPreset() {
+      var next = KIND_PRESETS[(kindPresetIndex() + 1) % KIND_PRESETS.length]
+      try { window.localStorage.setItem(KIND_KEY, JSON.stringify(next.off)) } catch (e) {}
+    }
+
+    var QUOTE_MODE_KEY = 'dsh-composer-ease:quoteMode'
+ // 全角括号改半角（默认关）：中文输入法会把 ( 合成 （，有人要的就是 ASCII 的 ()。
+ // 关＝尊重输入法打出来的字符（中文正文里 （） 才是正确标点）。
+    var FW_HALF_KEY = 'dsh-composer-ease:fullwidthHalf'
+ // 默认开：中文态打 ( 出来的 （ 直接换成半角 ()（一次反馈：括号会输出成（））。
+ // 想按中文标点写正文的，在 / 菜单关掉即可。
+    function fwHalf() {
+      try { return window.localStorage.getItem(FW_HALF_KEY) !== '0' } catch (e) { return true }
+    }
+    function setFwHalf(on) {
+      try { window.localStorage.setItem(FW_HALF_KEY, on ? '1' : '0') } catch (e) {}
+    }
+ // 默认 auto：没有选区、前方也没有未闭合引号时，单独打一个引号就该得到一对。
+ // 标红模式退成显式开关（/ 菜单里切），不再默认关掉配对。
+    function quoteMode() {
+      try { return window.localStorage.getItem(QUOTE_MODE_KEY) === 'warn' ? 'warn' : 'auto' } catch (e) { return 'auto' }
+    }
+    function setQuoteMode(m) {
+      try { window.localStorage.setItem(QUOTE_MODE_KEY, m === 'auto' ? 'auto' : 'warn') } catch (e) {}
+    }
+ // ── 设置版本：默认值改过之后，旧默认值不能一直粘在用户身上 ──────────────
+ // 实测：旧版默认是「标红提示」，那些用户 localStorage 里存着 warn，升级后打引号
+ // 仍然不配对，看上去像插件没修好。换默认值时清掉该格，显式选择从这一版重新记。
+    var SCHEMA_KEY = 'dsh-composer-ease:schema'
+    var SCHEMA_NOW = '2'
+    function settingsKeys() { return [PAIR_STRICT_KEY, KIND_KEY, QUOTE_MODE_KEY, FW_HALF_KEY] }
+    function migrateSettings() {
+      try {
+        if (window.localStorage.getItem(SCHEMA_KEY) === SCHEMA_NOW) return
+        window.localStorage.removeItem(QUOTE_MODE_KEY)
+        window.localStorage.setItem(SCHEMA_KEY, SCHEMA_NOW)
+      } catch (e) {}
+    }
+    function resetSettings() {
+      try {
+        for (var i = 0; i < settingsKeys().length; i++) window.localStorage.removeItem(settingsKeys()[i])
+        window.localStorage.setItem(SCHEMA_KEY, SCHEMA_NOW)
+      } catch (e) {}
+    }
+
+ /* ── / 菜单：三行设置什么时候出、命令名怎么补 ───────────────────────
+ * 宿主那侧只用子序列打分（dsh-web-frontend 里的 rankByName）：/comp 出 compact，
+ * 但 /compot 这种错拼的子序列会断（整组只剩本插件那三行）。
+ * 所以：① 三行也按 query 过滤，别在宿主那组消失后还赖在菜单里；
+ * ② 错拼的兜底行由宿主的命令表来补（rescueRows），插件自己不解命令。 */
+    function looseScore(query, text) {
+      var q = String(query || '').toLowerCase(), t = String(text || '').toLowerCase()
+      if (!q) return 0
+      if (!t) return -1
+      if (t.indexOf(q) === 0) return 1000 - Math.min(999, t.length - q.length)   // 前缀命中
+      var at = t.indexOf(q)
+      if (at > 0) return 800 - Math.min(799, at)                                  // 中段连续命中
+      var ti = 0, hit = 0
+      for (var qi = 0; qi < q.length; qi++) {
+        var ch = q.charAt(qi)
+        while (ti < t.length && t.charAt(ti) !== ch) ti++
+        if (ti >= t.length) return -1                                             // 子序列也断：不命中
+        ti++; hit++
+      }
+      return 400 + hit
+    }
+ /** 错拼容忍：正常命中一律不算（返回 -1），只有「跳过 ≤2 个查询字符、≤2 个目标字符」
+ * 才给分数。实测 /compot → compact 恰好是跳 1 个查询字符（o）、2 个目标字符（a c）。 */
+    function typoScore(query, text) {
+      var q = String(query || '').toLowerCase(), t = String(text || '').toLowerCase()
+      if (!q || !t || looseScore(q, t) >= 0) return -1
+      var qi = 0, ti = 0, skipQ = 0, skipT = 0, hit = 0
+      while (qi < q.length) {
+        if (ti >= t.length) { skipQ += q.length - qi; break }
+        if (q.charAt(qi) === t.charAt(ti)) { qi++; ti++; hit++; continue }
+        var ahead = t.indexOf(q.charAt(qi), ti)
+        if (ahead >= 0 && ahead - ti <= 2 && skipT + (ahead - ti) <= 2) { skipT += ahead - ti; ti = ahead; continue }
+        skipQ++; qi++
+        if (skipQ > 2) return -1
+      }
+      return hit >= 3 ? hit : -1
+    }
+ /** 三条设置行（定的口径：/ 菜单是操作入口不是设置面板，一行一条、点一下切一档）。 */
+    function settingsRows() {
+      var on = pairStrict()
+      var qm = quoteMode()
+      return [
+        {
+          name: '引号模式',
+          label: qm === 'auto' ? '引号模式：自动补对' : '引号模式：标红提示',
+          description: qm === 'auto'
+            ? '当前：自动补对（打一个引号补一对；严格配对关时右侧有文字则只插一个）'
+            : '当前：标红提示（默认；引号未闭合时输入框标红，不替你补）',
+          hint: qm === 'auto' ? '点击改为标红提示' : '点击改为自动补对',
+        },
+        { name: '候选类型',
+          label: '候选类型：' + kindPresetLabel(),
+          description: '当前：' + kindPresetDesc(),
+          hint: '点击切到：' + kindPresetNextLabel() },
+        {
+          name: '全角括号',
+          label: '全角括号：' + (fwHalf() ? '打成半角 ()' : '保持全角（）'),
+          description: fwHalf()
+            ? '当前：输入法打 （ 得到半角 ()（写正文想要中文标点就关掉这一项）'
+            : '当前：保持输入法给的字符（中文正文里 （） 是正确标点）',
+          hint: fwHalf() ? '点击改为保持全角' : '点击改为打成半角 ()',
+        },
+        {
+          name: '重置插件设置',
+          label: '重置插件设置',
+          description: '把本插件存下的选择（引号模式 / 候选类型 / 严格配对）清回默认',
+          hint: '点击立即重置',
+        },
+        {
+          name: '严格配对',
+          label: '严格配对',
+          description: on ? '当前：开（引号必须前后成对，混全角半角也算一对）' : '当前：关（默认，遇到已有引号就不再补对）',
+          hint: on ? '点击关闭' : '点击开启',
+        },
+      ]
+    }
+ /** 取不到宿主命令表时的兜底：本机只有这三条内置命令（dsh-command-compact/goal/feedback）。 */
+    var BUILTIN_COMMANDS = [['compact', '压缩上下文'], ['goal', '目标'], ['feedback', '反馈']]
+ /** 错拼兜底行：宿主那份排名没排出来的命令，按「跳字」判据补一行（正常拼写不重复出）。 */
+    function rescueRows(query, host, leading) {
+      var q = String(query || '')
+      if (!q) return []
+      var matched = {}
+      var seen = host && host.matched ? host.matched : []
+      for (var i = 0; i < seen.length; i++) if (seen[i] && seen[i].name) matched[seen[i].name] = 1
+      var pool = (host && host.all && host.all.length) ? host.all : BUILTIN_COMMANDS.map(function (c) {
+        return { name: c[0], label: c[1] }
+      })
+      var out = []
+      for (var j = 0; j < pool.length; j++) {
+        var r = pool[j]
+        if (!r || !r.name || matched[r.name]) continue       // 宿主已经排出来的行不再重复
+ // 与宿主同一条位置判据：带输入提示的命令只在行首列（行内打 / 时不列）
+        if (!leading && r.hint) continue
+        var score = Math.max(typoScore(q, r.name), typoScore(q, r.label || ''))
+        if (score < 0) continue
+        out.push({
+          name: r.name,
+          label: '/' + r.name + (r.label ? '　' + r.label : ''),
+          description: String(r.description || ''),
+          hint: '错拼兜底',
+          rescue: r.name,
+        })
+        if (out.length >= 3) break
+      }
+      return out
+    }
+    function triggerBasename(rel) {
+      var t = String(rel || '')
+      var i = t.lastIndexOf('/')
+      return i >= 0 ? t.slice(i + 1) : t
+    }
+
+ /** 直接问一次只读路由，拿原始候选（不做 DOM 渲染，供触发源用）。 */
+    function fetchItems(prefix) {
+      var url = ROUTE_WORDS + '?prefix=' + encodeURIComponent(prefix || '') + '&lang='
+      return fetch(url).then(function (r) { return r.json() }).then(function (d) {
+        return d ? (Array.isArray(d.candidates) ? d.candidates : (Array.isArray(d.items) ? d.items : [])) : []
+      }).catch(function () { return [] })
+    }
+

package/lib/client/50-caret.js

@@ -0,0 +1,254 @@
+// ── 模块：光标复位与接受 ────────────────────────────────
+// placeCaretVerified / flushCaretFix / afterPairCheck / ensureCaretAt：插入后把光标放回该在的位置，以及 acceptCurrent。
+// 本文件是 lib/client.js 的片段，由 tools/build-client.mjs 按序拼回；不要直接改生成物 lib/client.js。
+
+    var suppressInput = 0   // 我们自己插入文本后会派发 input；别让它回来又开一次弹层（连按即滚雪球）
+    var caretEpoch = 0      // 每次按键 +1；延后的光标复位只认最后一次
+ /* IME 合成中：拼音还没上屏，这时候的拉丁字母不是「输入内容」，不能触发补全。
+ * 实测：打拼音 `ye` 时 JS 关键字 `yield` 被前缀命中，弹层＋灰字 `eld`
+ * 盖在输入法候选窗旁边。VS Code 同样在 composition 期间不出建议。 */
+    var composing = false
+ /* 光标复位要**跨帧校验**：实测（demo 3081）配对后只调一次 `setSelectionRange`
+ * 会被 Lexical 随后的一次重渲染冲掉 —— 空框打 `"` 拿到 `""` 但 caret 停在 0（开符之前），
+ * 于是接着打字打到引号外面、连按第三下也被当成「跳过闭符」吞掉。
+ * 这里按绝对偏移写几次，每次都读回来确认；期间只要又按了键（caretEpoch 变）就立刻放手，
+ * 不去跟用户抢光标。文本域是同步的，写一次就返回。 */
+  /* 光标复位：时机由 **Lexical 的 DOM 变化**来定，不能猜 —— 插件插入的文本节点在 microtask / rAF /
+   * `setTimeout 0` 那一刻都还不存在，约 2ms 后才出现。盲目撒定时器两头出错：等不到那一格会被输入法
+   * 上屏抢先（文字落到闭符外面），长尾回调又会在用户打完字后把光标拽回原位。
+   * 做法：MutationObserver 等文本落地，再用**文本护栏**（`expect`）判断有没有人插手。 */
+    var caretFix = null
+    var caretObserver = null, caretObserverTarget = null
+    function ensureCaretObserver(ed) {
+      if (typeof MutationObserver === 'undefined') return
+      try {
+        if (caretObserver && caretObserverTarget === ed) return
+        if (caretObserver) caretObserver.disconnect()
+        caretObserver = new MutationObserver(function () { flushCaretFix() })
+        caretObserver.observe(ed, { childList: true, subtree: true, characterData: true })
+        caretObserverTarget = ed
+      } catch (e) { caretObserver = null }
+    }
+    function flushCaretFix() {
+      var f = caretFix
+      if (!f) return
+      if (f.epoch !== caretEpoch) { caretFix = null; return }     // 期间有按键/输入法接管：放手
+      if (f.tries === undefined) f.tries = 0
+      var now
+      try { now = textOf(f.ed) } catch (e) { return }
+      if (now !== f.expect) {
+        if (now.length < f.expect.length) return                  // 自己的插入还没落地，等下一次 mutation
+        caretFix = null; return                                   // 文本被别人改过：不猜，放手
+      }
+      var at = -1
+      try {
+        if (caretPos(f.ed) !== f.target) setCaret(f.ed, f.target)
+        at = caretPos(f.ed)
+      } catch (e) { at = -1 }
+ /* **要连续两拍都读到目标位置、而且文本没再变**才算落地：
+ * Lexical 的重渲染比插件的写入晚一拍（实测 ~2ms），只写一次会被它冲掉 ——
+ * 那正是「空框打全角开符，配对后光标停在闭符之后」的实测值来源。 */
+      if (at === f.target && f.lastText === now) f.stable = (f.stable || 0) + 1
+      else f.stable = 0
+      f.lastText = now
+      if (f.stable >= 2) {
+        caretFix = null
+        if (typeof f.then === 'function') { try { f.then() } catch (e) {} }   // 落地后的复核
+        return
+      }
+      if (++f.tries < 10) soon(flushCaretFix)
+      else caretFix = null
+    }
+ /** 配对之后的**结果复核**：按「落地后的真文本」把判据重算一遍。
+ * 读到的状态可能是旧的（Lexical 重渲染的空窗），但结果不能跟着旧走 ——
+ * 本该「只插一个」的，就把多出来的闭符撤掉。判据在真文本上成立时这个函数什么都不做
+ * （这正是正常路径），只在读到旧状态时才纠正。 */
+    function afterPairCheck(ed, open, close, atOpen) {
+      return function () {
+        try {
+          var t = textOf(ed)
+          if (t.slice(atOpen, atOpen + 2) !== open + close) return   // 已经不是我们插的那一对了
+          var b = t.slice(0, atOpen), n = t.charAt(atOpen + 2)
+          if (!isUnbalancedBefore(b, open, close) && shouldPair(b, n, open)) return
+          suppressInput++
+          deleteAt(ed, atOpen + 1)                                   // 撤掉闭符 → 只剩一个开符
+          placeCaretVerified(ed, atOpen + 1, t.slice(0, atOpen + 1) + t.slice(atOpen + 2))
+          ensureCaretAt(ed, atOpen + 1)
+        } catch (e) {}
+      }
+    }
+ /** 插一段文本：优先用粘贴事件（Lexical 把它当一次原子编辑，落点稳定），不行再 execCommand。
+ * 专门给"配对"这种紧跟下一键的场景用。 */
+    function insertAtomic(ed, text) {
+      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
+      } catch (e) { handled = false }
+      if (!handled) insertText(ed, text)
+    }
+
+ /** 读**实际**光标在编辑器纯文本里的偏移；读不到回 -1。 */
+    function caretOffsetNow(ed) {
+      try {
+        if (isText(ed)) return ed.selectionStart
+        var sel = window.getSelection()
+        if (!sel || !sel.rangeCount) return -1
+        var r = sel.getRangeAt(0)
+        if (!r.collapsed) return -1
+        var pre = document.createRange()
+        pre.selectNodeContents(ed)
+        pre.setEnd(r.startContainer, r.startOffset)
+        return textLenOf(pre.cloneContents())
+      } catch (e) { return -1 }
+    }
+
+ /** 把光标按**实际偏移**钉到 target：不对就硬设，再按梯子复验几拍。
+ * 配对那条路不能只信"预期偏移"——编辑器可能自己挪过光标（全角引号就是这种情况）。 */
+    function ensureCaretAt(ed, target, tries) {
+      var left = tries === undefined ? 3 : tries
+      var step = function (n) {
+        if (target < 0) return
+        if (caretOffsetNow(ed) === target) return
+        try { setSelectionRange(ed, target, target) } catch (e) {}
+ // 让编辑器（Lexical）把模型选区也同步过来，否则下一键会按它自己的模型落字
+        try { document.dispatchEvent(new Event('selectionchange')) } catch (e2) {}
+        if (n > 0) soon(function () { step(n - 1) })
+      }
+      step(left)
+    }
+
+ /** 把光标放到 target，但要等 `expect` 这段文本落地之后才动手。
+ * `expect` = 插件自己这一次插入完成后的**整段文本**；文本长度更短＝还没落地（继续等），
+ * 内容对不上＝别人（用户/输入法）插手了（放手，绝不抢光标）。
+ * `then` = 落地后跑一次的复核。 */
+    function placeCaretVerified(ed, target, expect, then) {
+      if (target < 0) return
+      var epoch = ++caretEpoch
+      if (isText(ed)) {
+        try { ed.selectionStart = ed.selectionEnd = target } catch (e) {}
+        if (typeof then === 'function') { try { then() } catch (e) {} }
+        return
+      }
+      caretFix = { ed: ed, target: target, expect: String(expect === undefined ? '' : expect), epoch: epoch, then: then }
+      ensureCaretObserver(ed)
+      flushCaretFix()                                   // 文本已经在位的情况（跳闭符那条路没有文本变化）
+      soon(function () {                                  // 兜底：万一等不到 mutation
+        if (caretFix && caretFix.epoch === caretEpoch) flushCaretFix()
+      })
+    }
+ /** 片段占位符的待跳表：接受片段后填上，Tab 依次跳，任何其它按键/失焦清空。 */
+    var snippetStops = null, snippetEpoch = 0
+
+ /* 把光标前 [start, 光标) 这一段换成 text，并**核对结果**。
+ * 一次反馈：接受后原文被吞掉、候选没进去，只能 Ctrl+Z 找回。
+ * 真因是 contenteditable 这条路把「选 token → 插候选」交给 execCommand，而宿主 Lexical
+ * 有时不认插件摆的选区（实测：打 文档 再 Tab 得到「文档管理文档」，多一份原文；
+ * 另有一次候选一个字都没落进去）。所以：落一次 → 比整段文本 → 不对就 undo 这一笔，
+ * 原文原地留着 —— 接受要么正确，要么什么都没发生。 */
+    function spliceDraft(ed, start, text) {
+      var before = textOf(ed)
+      var caret = caretPos(ed)
+      var end = caret >= 0 ? caret : before.length
+      if (start < 0 || start > end) start = end
+      var expected = before.slice(0, start) + text + before.slice(end)
+      var multi = String(text).indexOf('\n') >= 0
+      suppressInput++
+      if (isText(ed)) {
+        try { ed.selectionStart = start; ed.selectionEnd = end } catch (e) {}
+        insertRich(ed, text)
+        return textOf(ed) === expected
+      }
+      try {
+        setSelectionRange(ed, start, end)
+        insertRich(ed, text)          // 多行走 paste 通道，单行走 execCommand
+        if (textOf(ed) === expected) return true
+        if (multi) {                  // 宿主的 paste 是异步落的：给它一拍再核
+          soon(function () {
+            try { if (textOf(ed) !== expected) document.execCommand('undo') } catch (e2) {}
+          })
+          return true
+        }
+        if (before !== textOf(ed)) { try { document.execCommand('undo') } catch (e3) {} }
+        return false
+      } catch (e) { return false }
+    }
+
+    function acceptCurrent() {
+      var it = popup.items[popup.index]
+      var ed = lastComposer
+      if (!it || !ed) { closePopup(); return }
+      if (it.lang) habitBump(it.lang, 2)     // 接受过哪套词表的候选，就算在用哪门语言
+ // token 必须在**接受这一拍**现算：lastToken 是弹层触发时的快照，
+ // 打字比弹层快时会过期（实测：打 console.log 只回删了 'log'，前面的 'console.' 留在原地）。
+      var tok = tokenBefore(textBeforeCaret(ed)) || lastToken || ''
+      var caret0 = caretPos(ed)
+      var start0 = (caret0 >= 0 && tok) ? Math.max(0, caret0 - tok.length) : caret0
+      var payload = String(it.kind === 'file' ? String(it.value).replace(/\\/g, '/') : it.value)
+      var stops = []
+      if (it.kind === 'snippet') {
+        var ex = expandSnippet(payload)
+        payload = ex.text
+        stops = ex.stops
+      }
+      snippetStops = null
+ // 没落成就把原文留着、弹层也留着（换一条再来），Tab 不会看起来像没反应
+      if (!spliceDraft(ed, start0, payload)) return
+      closePopup()
+      if (stops.length && start0 >= 0) {
+ // 落点基准是**替换区间的起点**，不是插入前的光标位置（早先按光标算，光标会落在文本末尾）
+        snippetStops = stops.map(function (s) { return start0 + s })
+        snippetEpoch = caretEpoch
+ // 先同步落一次（异步观察者赶不上下一拍），再用 placeCaretVerified 兜住编辑器把光标甩到末尾的情况
+        try { setSelectionRange(ed, snippetStops[0], snippetStops[0]) } catch (e) {}
+        placeCaretVerified(ed, snippetStops[0])
+ // 再补一拍：Lexical 往往在插入落地后才把光标甩到末尾，placeCaretVerified 的观察者赶不上它
+        var stop0 = snippetStops[0]
+        soon(function () {
+          if (!snippetStops || snippetStops[0] !== stop0) return
+          try { setSelectionRange(ed, stop0, stop0) } catch (e) {}
+        })
+      }
+    }
+
+    var lastComposer = null, lastToken = '', lastSelText = ''
+
+ /* 语言习惯：观察实际在用什么语言（围栏标记、以及接受过哪套词表的候选），
+ * 存本地，下一次没写围栏时就按习惯上词表 —— 原话「通过观察用户操作习惯选择使用哪个语言」。 */
+    var HABIT_KEY = 'dsh-composer-ease:lang-habit'
+    function habitRead() { try { return JSON.parse(window.localStorage.getItem(HABIT_KEY) || '{}') || {} } catch (e) { return {} } }
+    function habitBump(lang, weight) {
+      if (!lang) return
+      try {
+        var h = habitRead(); h[lang] = (h[lang] || 0) + (weight || 1)
+        window.localStorage.setItem(HABIT_KEY, JSON.stringify(h))
+      } catch (e) {}
+    }
+    function habitTop() {
+      var h = habitRead(), best = '', n = 0
+      for (var k in h) { if (h[k] > n) { best = k; n = h[k] } }
+      return best
+    }
+
+ /* 调试开关（默认关）：localStorage['dsh-composer-ease:debug']='1' 后刷新页面即开。
+ * 存在的唯一理由：一次反馈在本机 Playwright 上复现不出来
+ * （造不出真实输入法的 composition 事件），所以把实测上那几个字段原样打出来。 */
+    var DBG = (function () {
+      try { return window.localStorage.getItem('dsh-composer-ease:debug') === '1' } catch (e) { return false }
+    })()
+    function dbg(kind, o) {
+      if (!DBG) return
+      try {
+        var ed = o && o.ed
+        var t = ed ? textOf(ed) : ''
+        var sel = ed ? [caretOffset(ed), selectedText(ed)] : ['-', '-']
+        console.log('[cpe] ' + kind, JSON.stringify({
+          key: o.key, data: o.data, itype: o.itype, composing: !!o.composing,
+          before: o.before, sel: sel[1], caret: sel[0], text: t,
+          action: o.action, prevented: !!o.prevented
+        }))
+      } catch (e) {}
+    }
+