Part the inline scan into named readers, and share the mark identity both directions read

src/markdown/parse/inline-content.ts

@@ -1,11 +1,12 @@
 import type { AdfMark, AdfNode } from '../../adf/document.ts'
+import type { EmphasisPairing } from '../emphasis-matching.ts'
 import type { LinkDefinition } from '../link-syntax.ts'
 import { backslashEscape, decodeTextEscapes, inlineHtmlConstruct, readBracketedAutolink, readEmailAutolink } from '../commonmark-grammar.ts'
 import { backtickRun, closingBacktickRun } from '../backtick-runs.ts'
 import { delimiterFlags, matchEmphasis, runLength } from '../emphasis-matching.ts'
 import { failure, success, type ConvertErrorPath, type Result } from '../../result.ts'
+import { mergeAdjacentText } from '../../adf/editor-normal.ts'
 import { normalizeLabel, readInlineTarget, readLabel } from '../link-syntax.ts'
-import { serializeCanonicalJson } from '../../canonical-json.ts'
 
 export type InlineContent = { image: AdfNode; nodes?: undefined } | { image?: undefined; nodes: AdfNode[] }
 
@@ -13,13 +14,14 @@ export type LinkDefinitions = ReadonlyMap<string, LinkDefinition>
 
 type Bracket = { active: boolean; image: boolean; kind: 'open'; start: number }
 
+type Pairing = EmphasisPairing<Run>
+
 type Piece = Bracket | { kind: 'nodes'; nodes: AdfNode[] } | { canClose: boolean; canOpen: boolean; character: string; kind: 'run'; length: number }
 
 type Run = { canClose: boolean; canOpen: boolean; character: string; index: number; length: number }
 
 type Scan = { definitions: LinkDefinitions; image: AdfNode | undefined; path: ConvertErrorPath; pending: string; pieces: Piece[]; source: string }
 
-const emphasisCharacters = '*_~'
 const hardBreakSpaces = / {2,}$/
 const imageAlone = 'an image fits only as a paragraph of its own'
 const trailingSpace = /[ \t]+$/
@@ -28,76 +30,103 @@ export function parseInlineContent(source: string, definitions: LinkDefinitions,
   const scan: Scan = { definitions, image: undefined, path, pending: '', pieces: [], source }
   let index = 0
   while (index < source.length) {
-    const character = source.charAt(index)
-    if (character === '\\' && source.charAt(index + 1) === '\n') {
-      // CommonMark strips the spaces the two-space break is spelled with, and keeps those before a backslash.
-      flush(scan, false)
-      pushNode(scan, { type: 'hardBreak' })
-      index += 2
-      continue
-    }
-    if (backslashEscape(source, index) !== undefined) {
-      scan.pending += source.slice(index, index + 2)
-      index += 2
-      continue
-    }
-    if (character === '\n') {
-      const hard = hardBreakSpaces.test(scan.pending)
-      flush(scan, true)
-      if (hard) pushNode(scan, { type: 'hardBreak' })
-      else scan.pending = ' '
-      index += 1
-      continue
-    }
-    if (character === '`') {
-      const span = readCodeSpan(source, index)
-      if (span === undefined) {
-        const run = backtickRun(source, index)
-        scan.pending += source.slice(index, index + run)
-        index += run
-        continue
+    switch (source.charAt(index)) {
+      case '\\':
+        index = readBackslash(scan, index)
+        break
+      case '\n':
+        index = readLineEnding(scan, index)
+        break
+      case '`':
+        index = readBackticks(scan, index)
+        break
+      case '<': {
+        const angle = readAngle(scan, index)
+        if (!angle.ok) return angle
+        index = angle.value
+        break
       }
-      flush(scan, false)
-      pushNode(scan, { marks: [{ type: 'code' }], text: span.text, type: 'text' })
-      index = span.end
-      continue
-    }
-    if (character === '<') {
-      const autolink = readAutolink(source, index)
-      if (autolink !== undefined) {
-        flush(scan, false)
-        pushNode(scan, autolink.node)
-        index += autolink.length
-        continue
+      case '!':
+      case '[':
+        index = openBracket(scan, index)
+        break
+      case ']': {
+        const closed = closeBracket(scan, index)
+        if (!closed.ok) return closed
+        index = closed.value
+        break
       }
-      const construct = inlineHtmlConstruct(source, index)
-      if (construct !== undefined) return failure('unmappable-html', `no ADF node carries ${construct}`, path)
+      case '*':
+      case '_':
+      case '~':
+        index = readDelimiterRun(scan, index)
+        break
+      default:
+        scan.pending += source.charAt(index)
+        index += 1
     }
-    if (character === '[' || (character === '!' && source.charAt(index + 1) === '[')) {
-      const image = character === '!'
-      const width = image ? 2 : 1
-      flush(scan, false)
-      scan.pieces.push({ active: true, image, kind: 'open', start: index + width })
-      index += width
-      continue
-    }
-    if (character === ']') {
-      const closed = closeBracket(scan, index)
-      if (!closed.ok) return closed
-      index = closed.value
-      continue
-    }
-    if (emphasisCharacters.includes(character)) {
-      index = readDelimiterRun(scan, index)
-      continue
-    }
-    scan.pending += character
-    index += 1
   }
   flush(scan, true)
   return assemble(scan)
 }
 
+function readBackslash(scan: Scan, index: number): number {
+  if (scan.source.charAt(index + 1) === '\n') {
+    // CommonMark strips the spaces the two-space break is spelled with, and keeps those before a backslash.
+    flush(scan, false)
+    pushNode(scan, { type: 'hardBreak' })
+    return index + 2
+  }
+  const width = backslashEscape(scan.source, index) === undefined ? 1 : 2
+  scan.pending += scan.source.slice(index, index + width)
+  return index + width
+}
+
+function readLineEnding(scan: Scan, index: number): number {
+  const hard = hardBreakSpaces.test(scan.pending)
+  flush(scan, true)
+  if (hard) pushNode(scan, { type: 'hardBreak' })
+  else scan.pending = ' '
+  return index + 1
+}
+
+function readBackticks(scan: Scan, index: number): number {
+  const span = readCodeSpan(scan.source, index)
+  if (span === undefined) {
+    const run = backtickRun(scan.source, index)
+    scan.pending += scan.source.slice(index, index + run)
+    return index + run
+  }
+  flush(scan, false)
+  pushNode(scan, { marks: [{ type: 'code' }], text: span.text, type: 'text' })
+  return span.end
+}
+
+function readAngle(scan: Scan, index: number): Result<number> {
+  const autolink = readAutolink(scan.source, index)
+  if (autolink !== undefined) {
+    flush(scan, false)
+    pushNode(scan, autolink.node)
+    return success(index + autolink.length)
+  }
+  const construct = inlineHtmlConstruct(scan.source, index)
+  if (construct !== undefined) return failure('unmappable-html', `no ADF node carries ${construct}`, scan.path)
+  scan.pending += '<'
+  return success(index + 1)
+}
+
+function openBracket(scan: Scan, index: number): number {
+  const image = scan.source.charAt(index) === '!'
+  if (image && scan.source.charAt(index + 1) !== '[') {
+    scan.pending += '!'
+    return index + 1
+  }
+  const width = image ? 2 : 1
+  flush(scan, false)
+  scan.pieces.push({ active: true, image, kind: 'open', start: index + width })
+  return index + width
+}
+
 function flush(scan: Scan, strip: boolean): void {
   const raw = strip ? scan.pending.replace(trailingSpace, '') : scan.pending
   scan.pending = ''
@@ -209,11 +238,23 @@ function buildImage(scan: Scan, inner: readonly Piece[], definition: LinkDefinit
 
 function resolveNodes(pieces: readonly Piece[]): AdfNode[] {
   const nodes = pieces.map((piece) => (piece.kind === 'nodes' ? piece.nodes : piece.kind === 'open' ? bracketNodes(piece) : []))
+  const runs = delimiterRuns(pieces)
+  const pairings = matchEmphasis(runs)
+  writeUnpaired(nodes, runs, pairings)
+  markPairings(nodes, pairings)
+  return mergeAdjacentText(nodes.flat())
+}
+
+function delimiterRuns(pieces: readonly Piece[]): Run[] {
   const runs: Run[] = []
   for (const [index, piece] of pieces.entries()) {
     if (piece.kind === 'run') runs.push({ canClose: piece.canClose, canOpen: piece.canOpen, character: piece.character, index, length: piece.length })
   }
-  const pairings = matchEmphasis(runs)
+  return runs
+}
+
+// A run gives its delimiters up from the head closing and the tail opening; what is left between them is text.
+function writeUnpaired(nodes: AdfNode[][], runs: readonly Run[], pairings: readonly Pairing[]): void {
   const heads = new Map<Run, number>()
   const tails = new Map<Run, number>()
   for (const pairing of pairings) {
@@ -225,13 +266,14 @@ function resolveNodes(pieces: readonly Piece[]): AdfNode[] {
     const tail = tails.get(run) ?? run.length
     if (tail > head) nodes[run.index] = [{ text: run.character.repeat(tail - head), type: 'text' }]
   }
+}
+
+// Innermost pairing first, so prepending leaves the marks array outermost first (spec/flavour.md, Marks).
+function markPairings(nodes: AdfNode[][], pairings: readonly Pairing[]): void {
   for (const pairing of pairings) {
     const mark: AdfMark = { type: markType(pairing.opener.character, pairing.used) }
-    for (let index = pairing.opener.index + 1; index < pairing.closer.index; index += 1) {
-      nodes[index] = applyMark(nodes[index] ?? [], mark)
-    }
+    for (let index = pairing.opener.index + 1; index < pairing.closer.index; index += 1) nodes[index] = applyMark(nodes[index] ?? [], mark)
   }
-  return mergeText(nodes.flat())
 }
 
 function markType(character: string, used: number): string {
@@ -239,8 +281,7 @@ function markType(character: string, used: number): string {
   return used === 2 ? 'strong' : 'em'
 }
 
-// CommonMark nests a spelling inside its own kind (`*(*a*)*`); the mark it names is idempotent, and
-// a node carrying it twice is the shape AGENTS.md §14 has the emitter refuse.
+// A node cannot carry one mark type twice (AGENTS.md §14).
 function applyMark(nodes: readonly AdfNode[], mark: AdfMark): AdfNode[] {
   return nodes.map((node) => {
     const marks = node.marks ?? []
@@ -248,24 +289,6 @@ function applyMark(nodes: readonly AdfNode[], mark: AdfMark): AdfNode[] {
   })
 }
 
-// Editor-normal (AGENTS.md §2): adjacent text nodes carrying identical marks are one node.
-function mergeText(nodes: readonly AdfNode[]): AdfNode[] {
-  const merged: AdfNode[] = []
-  for (const node of nodes) {
-    const previous = merged[merged.length - 1]
-    if (previous !== undefined && previous.type === 'text' && node.type === 'text' && markKey(previous) === markKey(node)) {
-      merged[merged.length - 1] = { ...previous, text: `${previous.text ?? ''}${node.text ?? ''}` }
-      continue
-    }
-    merged.push(node)
-  }
-  return merged
-}
-
-function markKey(node: AdfNode): string {
-  return (node.marks ?? []).map((mark) => `${mark.type}${serializeCanonicalJson(mark.attrs ?? {}, 'compact')}`).join(' ')
-}
-
 function readCodeSpan(source: string, index: number): { end: number; text: string } | undefined {
   const opener = backtickRun(source, index)
   const closer = closingBacktickRun(source, index + opener, opener)