dsh-paste-code-block 0.2.5 → 0.2.6

package/src/i18n.js

@@ -1,140 +1,140 @@
-/**
- * dsh-paste-code-block — locale dictionaries and label logic (pure, no DOM).
- *
- * Canonical source for the user-visible names of pasted blocks ("代码块 1"
- * vs "Code #1", etc.). The browser half (`client.js`) embeds its own
- * copy of this logic because DSH's client module loader resolves *package
- * names*, not relative ESM files; this module is the single place where that
- * logic is unit-tested. **Keep `src/i18n.js` and the embedded copy in
- * `src/client.js` in sync.**
- *
- * Labels render through the DSH locale service (`ctx.locale`), whose
- * `t(key, params)` lookup walks the active language's fallback chain, so the
- * dictionaries below are the whole story: identical key sets in zh and en,
- * `{name}` placeholders for interpolation.
- */
-
-/** Dictionary namespace owned by this plugin. */
-export const NS = 'paste-code-block'
-
-/** Simplified Chinese dictionary (the key-set source of truth). */
-export const zh = {
-  'block.code': '代码块 {n}',
-  'block.text': '文本块 {n}',
-  'detail.aria': '代码块详情',
-  'slot.label': '粘贴代码块详情',
-  'lines.one': '{count} 行',
-  'lines.other': '{count} 行',
-  'expand': '展开',
-  'collapse': '折叠',
-  'copy': '复制',
-  'copied': '已复制',
-  'hide': '收起',
-  'remove': '移除',
-  'edit.aria': '编辑代码块内容',
-  'error.stale': '代码块已失效，请重新粘贴',
-  'error.remove': '无法删除该块，请重试',
-  'fold.code': '代码块',
-  'fold.text': '文本块',
-  'fold.aria': '展开或折叠该块',
-}
-
-/** English dictionary, key-identical to the Chinese source of truth. */
-export const en = {
-  'block.code': 'Code #{n}',
-  'block.text': 'Text #{n}',
-  'detail.aria': 'Block details',
-  'slot.label': 'Pasted block details',
-  'lines.one': '{count} line',
-  'lines.other': '{count} lines',
-  'expand': 'Expand',
-  'collapse': 'Collapse',
-  'copy': 'Copy',
-  'copied': 'Copied',
-  'hide': 'Hide',
-  'remove': 'Remove',
-  'edit.aria': 'Edit block content',
-  'error.stale': 'This block is no longer valid — paste it again',
-  'error.remove': 'Could not remove the block — please retry',
-  'fold.code': 'Code',
-  'fold.text': 'Text',
-  'fold.aria': 'Expand or collapse this block',
-}
-
-/** Shipped dictionaries keyed by locale id (mirrors DSH's built-in zh/en set). */
-export const dictionaries = { zh, en }
-
-/**
- * Pre-0.1.3 chip labels ("复制代码块N" / "Code block #N" …). No longer
- * rendered, but still recognized by `parseBlockLabel` so chips inserted by an
- * older bundle keep resolving to their block after an in-place page refresh.
- */
-export const legacyLabels = {
-  zh: { 'block.code': '复制代码块{n}', 'block.text': '复制文本块{n}' },
-  en: { 'block.code': 'Code block #{n}', 'block.text': 'Text block #{n}' },
-}
-
-/**
- * Standalone translator used only when no DSH locale service is present
- * (defensive fallback outside the standard web composition). English is the
- * fallback language, matching DSH's own `FALLBACK_LOCALE`.
- */
-export function createT(locale) {
-  const dict = dictionaries[locale] || dictionaries.en
-  return (key, params) => {
-    let text = dict[key] != null ? dict[key] : (dictionaries.en[key] != null ? dictionaries.en[key] : key)
-    if (params) text = text.replace(/\{(\w+)\}/g, (m, name) => (name in params ? String(params[name]) : m))
-    return text
-  }
-}
-
-/** Guess a locale id from the browser's language list (fallback path only). */
-export function detectBrowserLocale() {
-  try {
-    const langs = [...(navigator.languages || []), navigator.language].filter(Boolean).map((l) => String(l).toLowerCase())
-    return langs.some((l) => l.startsWith('zh')) ? 'zh' : 'en'
-  } catch (e) {
-    return 'en'
-  }
-}
-
-/** Build a block chip label from a translator: 代码块 2 / Code #2. */
-export function blockLabel(t, type, n) {
-  return t(type === 'code' ? 'block.code' : 'block.text', { n })
-}
-
-/**
- * Build the title of a SENT-message fold card: `python · 128 行` /
- * `Code · 128 lines`. `lang` (the fence info string) names code cards when
- * present; text cards and untagged code cards fall back to the localized
- * type name. Line count always renders, so users can gauge size while the
- * card is collapsed.
- */
-export function foldTitle(t, type, lang, lines) {
-  const meta = t(lines === 1 ? 'lines.one' : 'lines.other', { count: lines })
-  const name = type === 'code' ? (lang || t('fold.code')) : t('fold.text')
-  return `${name} · ${meta}`
-}
-
-/**
- * Recognize a rendered block label in ANY shipped locale (or a pre-0.1.3
- * legacy locale) and recover its `{ type, n }` identity. This lets a chip
- * click, an ✕ delete, and the locale-switch retitling find the right block
- * even when the chip was inserted under a different language than the one
- * currently active. Returns null for anything that is not a block label.
- */
-export function parseBlockLabel(text) {
-  if (!text) return null
-  for (const dict of [dictionaries.zh, dictionaries.en, legacyLabels.zh, legacyLabels.en]) {
-    for (const key of ['block.code', 'block.text']) {
-      const pattern = new RegExp(
-        '^' +
-          dict[key].replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/\\\{n\\\}/g, '(\\d+)') +
-          '$',
-      )
-      const m = pattern.exec(text)
-      if (m) return { type: key === 'block.code' ? 'code' : 'text', n: Number(m[1]) }
-    }
-  }
-  return null
-}
+/**
+ * dsh-paste-code-block — locale dictionaries and label logic (pure, no DOM).
+ *
+ * Canonical source for the user-visible names of pasted blocks ("代码块 1"
+ * vs "Code #1", etc.). The browser half (`client.js`) embeds its own
+ * copy of this logic because DSH's client module loader resolves *package
+ * names*, not relative ESM files; this module is the single place where that
+ * logic is unit-tested. **Keep `src/i18n.js` and the embedded copy in
+ * `src/client.js` in sync.**
+ *
+ * Labels render through the DSH locale service (`ctx.locale`), whose
+ * `t(key, params)` lookup walks the active language's fallback chain, so the
+ * dictionaries below are the whole story: identical key sets in zh and en,
+ * `{name}` placeholders for interpolation.
+ */
+
+/** Dictionary namespace owned by this plugin. */
+export const NS = 'paste-code-block'
+
+/** Simplified Chinese dictionary (the key-set source of truth). */
+export const zh = {
+  'block.code': '代码块 {n}',
+  'block.text': '文本块 {n}',
+  'detail.aria': '代码块详情',
+  'slot.label': '粘贴代码块详情',
+  'lines.one': '{count} 行',
+  'lines.other': '{count} 行',
+  'expand': '展开',
+  'collapse': '折叠',
+  'copy': '复制',
+  'copied': '已复制',
+  'hide': '收起',
+  'remove': '移除',
+  'edit.aria': '编辑代码块内容',
+  'error.stale': '代码块已失效，请重新粘贴',
+  'error.remove': '无法删除该块，请重试',
+  'fold.code': '代码块',
+  'fold.text': '文本块',
+  'fold.aria': '展开或折叠该块',
+}
+
+/** English dictionary, key-identical to the Chinese source of truth. */
+export const en = {
+  'block.code': 'Code #{n}',
+  'block.text': 'Text #{n}',
+  'detail.aria': 'Block details',
+  'slot.label': 'Pasted block details',
+  'lines.one': '{count} line',
+  'lines.other': '{count} lines',
+  'expand': 'Expand',
+  'collapse': 'Collapse',
+  'copy': 'Copy',
+  'copied': 'Copied',
+  'hide': 'Hide',
+  'remove': 'Remove',
+  'edit.aria': 'Edit block content',
+  'error.stale': 'This block is no longer valid — paste it again',
+  'error.remove': 'Could not remove the block — please retry',
+  'fold.code': 'Code',
+  'fold.text': 'Text',
+  'fold.aria': 'Expand or collapse this block',
+}
+
+/** Shipped dictionaries keyed by locale id (mirrors DSH's built-in zh/en set). */
+export const dictionaries = { zh, en }
+
+/**
+ * Pre-0.1.3 chip labels ("复制代码块N" / "Code block #N" …). No longer
+ * rendered, but still recognized by `parseBlockLabel` so chips inserted by an
+ * older bundle keep resolving to their block after an in-place page refresh.
+ */
+export const legacyLabels = {
+  zh: { 'block.code': '复制代码块{n}', 'block.text': '复制文本块{n}' },
+  en: { 'block.code': 'Code block #{n}', 'block.text': 'Text block #{n}' },
+}
+
+/**
+ * Standalone translator used only when no DSH locale service is present
+ * (defensive fallback outside the standard web composition). English is the
+ * fallback language, matching DSH's own `FALLBACK_LOCALE`.
+ */
+export function createT(locale) {
+  const dict = dictionaries[locale] || dictionaries.en
+  return (key, params) => {
+    let text = dict[key] != null ? dict[key] : (dictionaries.en[key] != null ? dictionaries.en[key] : key)
+    if (params) text = text.replace(/\{(\w+)\}/g, (m, name) => (name in params ? String(params[name]) : m))
+    return text
+  }
+}
+
+/** Guess a locale id from the browser's language list (fallback path only). */
+export function detectBrowserLocale() {
+  try {
+    const langs = [...(navigator.languages || []), navigator.language].filter(Boolean).map((l) => String(l).toLowerCase())
+    return langs.some((l) => l.startsWith('zh')) ? 'zh' : 'en'
+  } catch (e) {
+    return 'en'
+  }
+}
+
+/** Build a block chip label from a translator: 代码块 2 / Code #2. */
+export function blockLabel(t, type, n) {
+  return t(type === 'code' ? 'block.code' : 'block.text', { n })
+}
+
+/**
+ * Build the title of a SENT-message fold card: `python · 128 行` /
+ * `Code · 128 lines`. `lang` (the fence info string) names code cards when
+ * present; text cards and untagged code cards fall back to the localized
+ * type name. Line count always renders, so users can gauge size while the
+ * card is collapsed.
+ */
+export function foldTitle(t, type, lang, lines) {
+  const meta = t(lines === 1 ? 'lines.one' : 'lines.other', { count: lines })
+  const name = type === 'code' ? (lang || t('fold.code')) : t('fold.text')
+  return `${name} · ${meta}`
+}
+
+/**
+ * Recognize a rendered block label in ANY shipped locale (or a pre-0.1.3
+ * legacy locale) and recover its `{ type, n }` identity. This lets a chip
+ * click, an ✕ delete, and the locale-switch retitling find the right block
+ * even when the chip was inserted under a different language than the one
+ * currently active. Returns null for anything that is not a block label.
+ */
+export function parseBlockLabel(text) {
+  if (!text) return null
+  for (const dict of [dictionaries.zh, dictionaries.en, legacyLabels.zh, legacyLabels.en]) {
+    for (const key of ['block.code', 'block.text']) {
+      const pattern = new RegExp(
+        '^' +
+          dict[key].replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/\\\{n\\\}/g, '(\\d+)') +
+          '$',
+      )
+      const m = pattern.exec(text)
+      if (m) return { type: key === 'block.code' ? 'code' : 'text', n: Number(m[1]) }
+    }
+  }
+  return null
+}

package/src/index.js

@@ -1,11 +1,11 @@
-/**
- * dsh-paste-code-block — host (node) half.
- *
- * Pure UI plugin: the host body is intentionally empty. The browser half ships
- * via exports["./client"], discovered through the package.json `dsh.client`
- * declaration and mounted into the Web composer by the host layer.
- */
-export const name = 'dsh-paste-code-block'
-
-/** Host plugin body — no host-side behavior. */
-export function apply() {}
+/**
+ * dsh-paste-code-block — host (node) half.
+ *
+ * Pure UI plugin: the host body is intentionally empty. The browser half ships
+ * via exports["./client"], discovered through the package.json `dsh.client`
+ * declaration and mounted into the Web composer by the host layer.
+ */
+export const name = 'dsh-paste-code-block'
+
+/** Host plugin body — no host-side behavior. */
+export function apply() {}

package/src/parse.js

@@ -37,6 +37,26 @@ export function detectLang(text) {
   return ''
 }
 
+/**
+ * The single complete fence of `text`, or null when the text is not exactly one
+ * fenced block (blank lines around it are tolerated; any real prose is not).
+ * Shares splitFencedSegments' pairing rules, so a 4-backtick wrapper around
+ * content that itself contains ``` is recognised as one fence, not two.
+ */
+export function wholeFence(text) {
+  const segs = splitFencedSegments(text)
+  let fence = null
+  for (const seg of segs) {
+    if (seg.kind === 'fence') {
+      if (fence) return null
+      fence = seg
+    } else if (seg.text.trim() !== '') {
+      return null
+    }
+  }
+  return fence
+}
+
 /**
  * Parse pasted text into a block, or null when it is ordinary short prose
  * that should paste plainly. `isCode` drives both the chip label (registered
@@ -47,12 +67,46 @@ export function parseBlock(raw) {
   const text = String(raw || '').replace(/^\uFEFF/, '')
   if (!text) return null
 
-  const fm = /^\s*```([\w+-]*)[^\n]*\n([\s\S]*?)\n?\s*```\s*$/.exec(text)
-  if (fm) {
-    const lang = (fm[1] || '').trim()
-    const content = fm[2].replace(/\n+$/, '')
+  // (1) A paste that is exactly ONE complete fence — this plugin's own output
+  // shape, and what "copy the block back out" produces. The type comes from the
+  // fence's info string, so an explicit ```text paste is a TEXT block and
+  // round-trips, instead of degrading into a bare code fence on the next send.
+  const whole = wholeFence(text)
+  if (whole) {
+    const content = whole.body.replace(/\n+$/, '')
     if (!content) return null
-    return { lang, content, lines: content.split(/\r?\n/), isCode: true }
+    const infoLang = (whole.lang || '').toLowerCase()
+    return {
+      lang: infoLang === 'text' ? '' : whole.lang,
+      content,
+      lines: content.split(/\r?\n/),
+      isCode: infoLang !== 'text',
+    }
+  }
+
+  // (2) A paste that OPENS with a fence but carries trailing prose after it —
+  // copying a whole previous message (fenced block + the line typed under it).
+  // Keep the entire paste as ONE block so its fence pairing survives, and take
+  // the type from the leading fence's info string. 0.2.5 fell through to the
+  // heuristic branch here: `fenced` forced isCode = true and serializeBlock
+  // re-wrapped the already-fenced text in a BARE fence, so the bubble received
+  // two nested fences (with the trailing line inside the outer one) even though
+  // the chip had said 文本块.
+  const segs = splitFencedSegments(text)
+  let leadFence = -1
+  for (let i = 0; i < segs.length; i += 1) {
+    if (segs[i].kind === 'fence') { leadFence = i; break }
+    if (segs[i].text.trim() !== '') break
+  }
+  if (leadFence >= 0) {
+    const leadLang = (segs[leadFence].lang || '').toLowerCase()
+    const content = text.replace(/\n+$/, '')
+    return {
+      lang: leadLang === 'text' ? '' : segs[leadFence].lang,
+      content,
+      lines: content.split(/\r?\n/),
+      isCode: leadLang !== 'text',
+    }
   }
 
   const multi = /\r?\n/.test(text)
@@ -96,9 +150,25 @@ export function countMarkdownSignals(text) {
   return n
 }
 
+/**
+ * Backtick marker long enough to wrap `content` unambiguously: one longer than
+ * the longest backtick run inside it (GFM nesting rule). Without this, content
+ * that already contains a fence closes the wrapper early and the sent message
+ * re-parses as several blocks — the bubble then shows the wall of text plus a
+ * card built from whatever fragment happened to look like a fence.
+ */
+export function fenceMarkerFor(content) {
+  const src = String(content == null ? '' : content)
+  let longest = 0
+  const runs = src.match(/`+/g)
+  if (runs) for (const run of runs) if (run.length > longest) longest = run.length
+  return '`'.repeat(Math.max(3, longest + 1))
+}
+
 export function serializeBlock(block) {
   const lang = block.isCode ? (block.lang || '') : 'text'
-  return `\n\`\`\`${lang}\n${block.content}\n\`\`\`\n`
+  const marker = fenceMarkerFor(block.content)
+  return `\n${marker}${lang}\n${block.content}\n${marker}\n`
 }
 
 /**
@@ -163,4 +233,87 @@ export function splitFencedSegments(text) {
   }
   flushProse(lines.length)
   return segments
+}
+
+/**
+ * Character ranges of every complete fence in `text`, in order, as
+ * `{ start, end }` (end exclusive, covering both fence lines). Same pairing
+ * rules as splitFencedSegments — index k here is the fence of the k-th fence
+ * segment it returns. Used by the sent-message fold scan to tell whether a
+ * fence sits inside one rendered run or straddles several.
+ */
+export function fenceRanges(text) {
+  const src = String(text == null ? '' : text)
+  const out = []
+  if (!src) return out
+  const starts = [0]
+  for (let i = 0; i < src.length; i += 1) if (src.charCodeAt(i) === 10) starts.push(i + 1)
+  const lineEnd = (n) => (n + 1 < starts.length ? starts[n + 1] - 1 : src.length)
+  const lineText = (n) => src.slice(starts[n], lineEnd(n)).replace(/\r$/, '')
+  const OPEN = /^ {0,3}(`{3,}|~{3,})(.*)$/
+  let i = 0
+  while (i < starts.length) {
+    const m = OPEN.exec(lineText(i))
+    if (!m) { i += 1; continue }
+    const marker = m[1]
+    const ch = marker[0]
+    const info = m[2].trim()
+    if (ch === '`' && info.includes('`')) { i += 1; continue }
+    const closeRe = new RegExp('^ {0,3}' + (ch === '`' ? '`' : '~') + '{' + marker.length + ',}[ \\t]*$')
+    let j = i + 1
+    let closed = false
+    while (j < starts.length) {
+      if (closeRe.test(lineText(j))) { closed = true; break }
+      j += 1
+    }
+    if (!closed) { i += 1; continue }
+    out.push({ start: starts[i], end: starts[j] + lineText(j).length })
+    i = j + 1
+  }
+  return out
+}
+
+/**
+ * How the sent-message fold scan should fold `text`, given the `runTexts` DSH
+ * actually rendered it as. DSH splits a user message into one plain run per
+ * mention chip, so a serialized block whose body mentions someone arrives as
+ * several sibling runs — with the fence opener in one and its closer in
+ * another, which no per-run scan can ever pair up.
+ *
+ * Returns null when nothing is foldable, else:
+ *  - { mode: 'single', segments, runs }   every fence lies inside ONE run;
+ *      `runs` lists the run indices to fold, each on its own.
+ *  - { mode: 'bubble', segments, fences } a fence straddles run boundaries;
+ *      the caller must rebuild the whole bubble from `segments`, because
+ *      per-run folding only ever sees a broken half of the fence.
+ */
+export function planFoldRuns(text, runTexts) {
+  const src = String(text == null ? '' : text)
+  const segments = splitFencedSegments(src)
+  const fenceSegs = segments.filter((seg) => seg.kind === 'fence')
+  const spans = fenceRanges(src)
+  if (fenceSegs.length !== spans.length) return null // defensive: keep the two walks in step
+  const fences = []
+  fenceSegs.forEach((seg, k) => { if (seg.body.trim() !== '') fences.push(spans[k]) })
+  if (!fences.length) return null
+
+  const bounds = []
+  let at = 0
+  for (const rt of (runTexts || [])) {
+    const len = String(rt == null ? '' : rt).length
+    bounds.push([at, at + len])
+    at += len
+  }
+  const runOf = (off) => {
+    for (let k = 0; k < bounds.length; k += 1) if (off >= bounds[k][0] && off < bounds[k][1]) return k
+    return -1
+  }
+  const runs = []
+  for (const f of fences) {
+    const a = runOf(f.start)
+    const b = runOf(Math.max(f.start, f.end - 1))
+    if (a < 0 || a !== b) return { mode: 'bubble', segments, fences }
+    if (!runs.includes(a)) runs.push(a)
+  }
+  return { mode: 'single', segments, runs }
 }

package/src/projection.js

@@ -1,54 +1,54 @@
-/**
- * Composer-projection geometry.
- *
- * The input shell publishes two coordinate systems for the same document:
- *
- * - `draft` (clipboard projection): every chip expands to its `clipboardText`,
- *   so a chip occupies `occurrence.length` characters.
- * - the editor's detect projection (what the scoped edit verbs address): every
- *   chip collapses to exactly ONE placeholder character (U+FFFC), while plain
- *   text is identical in both.
- *
- * Editing verbs (`slash/input-insert-text`, chip insertion) take detect spans,
- * so clipboard offsets must be converted before addressing an occurrence.
- *
- * Pure and dependency-free so the conversion is unit-testable; keep the embedded
- * copy in src/client.js in sync (same rule as parse.js/i18n.js/chip-nodes.js).
- */
-
-/**
- * Convert one occurrence's clipboard offset into a detect offset.
- * @param occurrences - all occurrences of the same projection.
- * @param occ - the occurrence to convert.
- * @returns the detect offset where the occurrence's placeholder sits.
- */
-export function detectOffsetOf(occurrences, occ) {
-  let shift = 0
-  for (const other of occurrences || []) {
-    if (other === occ || other.offset >= occ.offset) continue
-    shift += Math.max(0, (other.length || 1) - 1)
-  }
-  return occ.offset - shift
-}
-
-/**
- * Detect span of the separating space the shell appends right after a freshly
- * inserted chip — or null when the character after that chip is not a space.
- *
- * `SessionInputShell.insertReference` inserts `[chip, ' ']` whenever the
- * character at the pick-time span is not itself a space. Blocks are inserted at
- * the end of the draft, so that character can only have come from the insertion
- * itself: removing it never touches a space the draft already contained.
- *
- * @param projection - published input state (`{ draft, occurrences }`).
- * @param occ - OUR chip, the one that was just inserted.
- * @returns `{ start, end }` in detect coordinates, or null.
- */
-export function separatorSpaceSpan(projection, occ) {
-  if (!projection || !occ) return null
-  const draft = projection.draft || ''
-  const afterChip = occ.offset + (occ.length || 0)
-  if (draft.charAt(afterChip) !== ' ') return null
-  const start = detectOffsetOf(projection.occurrences, occ) + 1
-  return { start, end: start + 1 }
-}
+/**
+ * Composer-projection geometry.
+ *
+ * The input shell publishes two coordinate systems for the same document:
+ *
+ * - `draft` (clipboard projection): every chip expands to its `clipboardText`,
+ *   so a chip occupies `occurrence.length` characters.
+ * - the editor's detect projection (what the scoped edit verbs address): every
+ *   chip collapses to exactly ONE placeholder character (U+FFFC), while plain
+ *   text is identical in both.
+ *
+ * Editing verbs (`slash/input-insert-text`, chip insertion) take detect spans,
+ * so clipboard offsets must be converted before addressing an occurrence.
+ *
+ * Pure and dependency-free so the conversion is unit-testable; keep the embedded
+ * copy in src/client.js in sync (same rule as parse.js/i18n.js/chip-nodes.js).
+ */
+
+/**
+ * Convert one occurrence's clipboard offset into a detect offset.
+ * @param occurrences - all occurrences of the same projection.
+ * @param occ - the occurrence to convert.
+ * @returns the detect offset where the occurrence's placeholder sits.
+ */
+export function detectOffsetOf(occurrences, occ) {
+  let shift = 0
+  for (const other of occurrences || []) {
+    if (other === occ || other.offset >= occ.offset) continue
+    shift += Math.max(0, (other.length || 1) - 1)
+  }
+  return occ.offset - shift
+}
+
+/**
+ * Detect span of the separating space the shell appends right after a freshly
+ * inserted chip — or null when the character after that chip is not a space.
+ *
+ * `SessionInputShell.insertReference` inserts `[chip, ' ']` whenever the
+ * character at the pick-time span is not itself a space. Blocks are inserted at
+ * the end of the draft, so that character can only have come from the insertion
+ * itself: removing it never touches a space the draft already contained.
+ *
+ * @param projection - published input state (`{ draft, occurrences }`).
+ * @param occ - OUR chip, the one that was just inserted.
+ * @returns `{ start, end }` in detect coordinates, or null.
+ */
+export function separatorSpaceSpan(projection, occ) {
+  if (!projection || !occ) return null
+  const draft = projection.draft || ''
+  const afterChip = occ.offset + (occ.length || 0)
+  if (draft.charAt(afterChip) !== ' ') return null
+  const start = detectOffsetOf(projection.occurrences, occ) + 1
+  return { start, end: start + 1 }
+}