5b3: merge the code list's duplicate causes, spell the list separator, claim the bare pipe table

src/markdown/parse/markdown-to-adf.ts

@@ -1,15 +1,18 @@
 import type { AdfDocument, AdfNode } from '../../adf/document.ts'
 import type { Block, DirectiveBlock } from './blocks.ts'
 import type { BlockDirectiveNode } from './directive-nodes.ts'
+import type { ConvertFault } from '../../result.ts'
 import type { LinkDefinitions } from './inline-content.ts'
 import { carryName, readCarriedBlock } from '../opaque-carry.ts'
 import { commonMarkSpelling } from '../emit/adf-to-markdown.ts'
 import { failure, faulted, positioned, success, type ConvertErrorPath, type ParseError, type Result, type SourcePosition } from '../../result.ts'
 import { languageSlot } from '../code-language.ts'
 import { largestNesting } from '../../nesting.ts'
+import { listBreakName, listBreakSpelling } from '../list-break.ts'
 import { parseBlocks } from './blocks.ts'
 import { parseInlineContent } from './inline-content.ts'
 import { readBlockDirectiveNode } from './directive-nodes.ts'
+import { unsupportedNodeShape } from '../directive-syntax.ts'
 
 const documentStart: SourcePosition = { line: 1, offset: 0 }
 
@@ -24,13 +27,32 @@ function blockNodes(blocks: readonly Block[], definitions: LinkDefinitions, path
   if (depth > largestNesting) return failure('unsupported-nesting-depth', `the input nests deeper than the ${largestNesting} levels the parser carries`, path)
   const content: AdfNode[] = []
   for (const [index, block] of blocks.entries()) {
-    const node = positioned(blockNode(block, definitions, [...path, 'content', index], depth), block.position)
+    const nodePath = [...path, 'content', content.length]
+    if (block.kind === 'directive' && block.name === listBreakName) {
+      const fault = listBreakFault(block, blocks[index - 1], blocks[index + 1])
+      if (fault !== undefined) return positioned(faulted(fault, nodePath), block.position)
+      continue
+    }
+    const node = positioned(blockNode(block, definitions, nodePath, depth), block.position)
     if (!node.ok) return node
     content.push(node.value)
   }
   return success(content)
 }
 
+// spec/flavour.md, Directives: the separator builds no node, so only the pair it parts spells it.
+function listBreakFault(block: DirectiveBlock, previous: Block | undefined, next: Block | undefined): ConvertFault | undefined {
+  if (block.blocks !== undefined || block.argument !== undefined || block.attributes.size > 0) {
+    return unsupportedNodeShape(`${listBreakName} spells the bare leaf form, ${listBreakSpelling}: this one spells more`)
+  }
+  if (previous?.kind !== 'bulletList' && previous?.kind !== 'orderedList') return partsFault()
+  return previous.kind === next?.kind ? undefined : partsFault()
+}
+
+function partsFault(): ConvertFault {
+  return unsupportedNodeShape(`${listBreakName} parts two adjacent lists of one type: this one parts something else`)
+}
+
 function blockNode(block: Block, definitions: LinkDefinitions, path: ConvertErrorPath, depth: number): Result<AdfNode> {
   switch (block.kind) {
     case 'blockquote':