@yassimba/pi-loom-mermaid 0.2.0

package/src/loom-mermaid/diagrams/sequence.ts

@@ -0,0 +1,305 @@
+/**
+ * `sequenceDiagram`: participants, messages, notes and block dividers.
+ * Lenient: an unreadable statement is dropped and recorded in `warnings`.
+ *
+ * Sequence diagrams have their own model — participants in declaration order
+ * plus a flat list of items — and their own geometry in `layout-seq.ts`.
+ */
+
+import { MAX_EDGES, MAX_NODES } from '../graph.ts'
+import { asciiLower, cleanLabel, decodeHtmlEntities } from '../labels.ts'
+import { layoutSequence } from '../layout-seq.ts'
+import type { Diagram } from '../registry.ts'
+import { firstWord, headerKind, nonEmpty, splitOnce, statementsOf } from '../statements.ts'
+
+export const sequence: Diagram = {
+  kind: 'sequence',
+  headers: ['sequencediagram'],
+  render(src, limits) {
+    const seq = parseSequence(src)
+    if (seq === null) return null
+    const canvas = layoutSequence(seq, limits)
+    if (canvas === null) return null
+    return { canvas, warnings: seq.warnings, classDefs: {} }
+  },
+}
+
+type SeqHead = 'arrow' | 'cross'
+
+/** Message operators, longest-first so `-->>` wins over `-->`. */
+const SEQ_OPS: [string, boolean, SeqHead][] = [
+  ['-->>', true, 'arrow'],
+  ['->>', false, 'arrow'],
+  ['--x', true, 'cross'],
+  ['-x', false, 'cross'],
+  ['--)', true, 'arrow'],
+  ['-)', false, 'arrow'],
+  ['-->', true, 'arrow'],
+  ['->', false, 'arrow'],
+]
+
+const MAX_SEQ_OP = 4
+
+export type NoteAnchor =
+  | { kind: 'over'; from: number; to: number }
+  | { kind: 'left'; at: number }
+  | { kind: 'right'; at: number }
+
+export type SeqItem =
+  | {
+      kind: 'message'
+      from: number
+      to: number
+      text: string | null
+      dashed: boolean
+      head: SeqHead
+    }
+  | { kind: 'note'; anchor: NoteAnchor; text: string }
+  | { kind: 'divider'; text: string }
+
+/** A hot span of one lifeline: item indices, `to === null` while still open. */
+interface Activation {
+  at: number
+  from: number
+  to: number | null
+}
+
+export class Sequence {
+  labels: string[] = []
+  index = new Map<string, number>()
+  items: SeqItem[] = []
+  activations: Activation[] = []
+  /** Set when a size cap was hit; the parser stops and renders the prefix. */
+  truncated: string | null = null
+  /** Statements the grammar could not read and dropped. */
+  warnings: string[] = []
+
+  participant(id: string, label: string | null): number | null {
+    const existing = this.index.get(id)
+    if (existing !== undefined) {
+      if (label !== null) this.labels[existing] = label
+      return existing
+    }
+    if (this.labels.length >= MAX_NODES) {
+      this.truncated ??= `participant cap (${MAX_NODES}) reached`
+      return null
+    }
+    this.index.set(id, this.labels.length)
+    this.labels.push(label ?? id)
+    return this.labels.length - 1
+  }
+
+  /** Append an item, or flag `truncated` when the item cap is reached. */
+  pushItem(item: SeqItem): void {
+    if (this.items.length >= MAX_EDGES) this.truncated ??= `item cap (${MAX_EDGES}) reached`
+    else this.items.push(item)
+  }
+
+  /** Record an unreadable statement; skipped once truncated. */
+  drop(st: string): void {
+    if (this.truncated === null) this.warnings.push(`dropped, unreadable statement: "${st}"`)
+  }
+
+  /** Open an activation at item `from`. */
+  activate(at: number, from: number): void {
+    this.activations.push({ at, from, to: null })
+  }
+
+  /** Close the innermost open activation of `at` at item `to`. */
+  deactivate(at: number, to: number): void {
+    for (let i = this.activations.length - 1; i >= 0; i--) {
+      const a = this.activations[i]
+      if (a.at === at && a.to === null) {
+        a.to = to
+        return
+      }
+    }
+  }
+}
+
+function parseSequence(src: string): Sequence | null {
+  const statements = statementsOf(src)
+  const kind = headerKind(statements)
+  if (kind === null || !sequence.headers.includes(kind)) return null
+
+  const seq = new Sequence()
+  let autonumber = false
+  let msgCount = 0
+  /** One entry per open block; `true` when it draws a divider on `end`. */
+  const blocks: boolean[] = []
+
+  for (const st of statements.slice(1)) {
+    const first = firstWord(st)
+    const lower = asciiLower(first)
+
+    if (lower === 'participant' || lower === 'actor') {
+      const rest = st.slice(first.length).trim()
+      if (rest === '') {
+        seq.drop(st)
+      } else {
+        const as = splitOnce(rest, ' as ')
+        seq.participant(as ? as[0].trim() : rest, as ? cleanLabel(as[1]) : null)
+      }
+    } else if (lower === 'autonumber') {
+      autonumber = true
+    } else if (lower === 'activate' || lower === 'deactivate') {
+      // Applies to the preceding message's row.
+      const who = seq.index.get(st.slice(first.length).trim())
+      if (who !== undefined && seq.items.length > 0) {
+        if (lower === 'activate') seq.activate(who, seq.items.length - 1)
+        else seq.deactivate(who, seq.items.length - 1)
+      }
+    } else if (
+      [
+        'create',
+        'destroy',
+        'title',
+        'acctitle',
+        'accdescr',
+        'links',
+        'link',
+        'properties',
+      ].includes(lower)
+    ) {
+      // No layout meaning.
+    } else if (lower === 'note') {
+      const note = parseNoteAnchor(st.slice(first.length).trim(), seq)
+      if (!note) seq.drop(st)
+      else seq.pushItem({ kind: 'note', anchor: note.anchor, text: note.text })
+    } else if (
+      ['loop', 'alt', 'opt', 'par', 'critical', 'break', 'else', 'and', 'option'].includes(lower)
+    ) {
+      // A continuation only divides a block that opened one.
+      const continues = ['else', 'and', 'option'].includes(lower)
+      if (!continues) blocks.push(true)
+      if (!continues || blocks.at(-1) === true) {
+        seq.pushItem({ kind: 'divider', text: decodeHtmlEntities(st) })
+      }
+    } else if (lower === 'rect' || lower === 'box') {
+      blocks.push(false)
+    } else if (lower === 'end') {
+      if (blocks.pop() === true) seq.pushItem({ kind: 'divider', text: 'end' })
+    } else {
+      const msg = parseSeqMessage(st, seq)
+      if (!msg) {
+        seq.drop(st)
+      } else {
+        let text = msg.text
+        if (autonumber) {
+          msgCount++
+          text = text === null ? `${msgCount}.` : `${msgCount}. ${text}`
+        }
+        const item = seq.items.length
+        seq.pushItem({
+          kind: 'message',
+          from: msg.from,
+          to: msg.to,
+          text,
+          dashed: msg.dashed,
+          head: msg.head,
+        })
+        // `+` activates the receiver on this row; `-` deactivates the sender.
+        // Only once the item was accepted — an activation pointing past the
+        // item cap would dereference a message that does not exist.
+        if (seq.items.length === item + 1) {
+          if (msg.marks.includes('+')) seq.activate(msg.to, item)
+          if (msg.marks.includes('-')) seq.deactivate(msg.from, item)
+        }
+      }
+    }
+    if (seq.truncated !== null) {
+      seq.warnings.push(`diagram truncated: ${seq.truncated}`)
+      break
+    }
+  }
+
+  return seq.labels.length === 0 ? null : seq
+}
+
+function parseNoteAnchor(rest: string, seq: Sequence): { text: string; anchor: NoteAnchor } | null {
+  const lower = asciiLower(rest)
+  let kind: NoteAnchor['kind']
+  let idsAndText: string
+  if (lower.startsWith('over ')) {
+    kind = 'over'
+    idsAndText = rest.slice('over '.length)
+  } else if (lower.startsWith('left of ')) {
+    kind = 'left'
+    idsAndText = rest.slice('left of '.length)
+  } else if (lower.startsWith('right of ')) {
+    kind = 'right'
+    idsAndText = rest.slice('right of '.length)
+  } else {
+    return null
+  }
+
+  const split = splitOnce(idsAndText, ':')
+  if (!split) return null
+  const text = decodeHtmlEntities(split[1].trim())
+  const parts = split[0]
+    .split(',')
+    .map((s) => s.trim())
+    .filter((s) => s !== '')
+  if (parts.length === 0) return null
+  const a = seq.participant(parts[0], null)
+  if (a === null) return null
+
+  if (kind !== 'over') return { text, anchor: { kind, at: a } }
+  let b = a
+  if (parts[1] !== undefined) {
+    const second = seq.participant(parts[1], null)
+    if (second === null) return null
+    b = second
+  }
+  return { text, anchor: { kind: 'over', from: Math.min(a, b), to: Math.max(a, b) } }
+}
+
+function parseSeqMessage(
+  st: string,
+  seq: Sequence,
+): {
+  from: number
+  to: number
+  text: string | null
+  dashed: boolean
+  head: SeqHead
+  marks: string
+} | null {
+  const chars = [...st]
+  let found: { pos: number; op: string; dashed: boolean; head: SeqHead } | null = null
+  outer: for (let pos = 0; pos < chars.length; pos++) {
+    const tail = chars.slice(pos, pos + MAX_SEQ_OP).join('')
+    for (const [op, dashed, head] of SEQ_OPS) {
+      if (tail.startsWith(op)) {
+        // `-x` / `-)` embedded in a hyphenated token (`pre-x->>B`) is not an
+        // operator — the real one follows. Require a non-link char after.
+        const after = chars[pos + op.length]
+        if ((op.endsWith('x') || op.endsWith(')')) && (after === '-' || after === '>')) continue
+        found = { pos, op, dashed, head }
+        break outer
+      }
+    }
+  }
+  if (!found) return null
+
+  const fromId = chars.slice(0, found.pos).join('').trim()
+  if (fromId === '') return null
+  // `+` activates the receiver, `-` deactivates the sender.
+  const afterOp = chars
+    .slice(found.pos + [...found.op].length)
+    .join('')
+    .trimStart()
+  const marks = afterOp.match(/^[+-]+/)?.[0] ?? ''
+  const rest = afterOp.slice(marks.length)
+
+  const split = splitOnce(rest, ':')
+  const toId = (split ? split[0] : rest).trim()
+  const text = split ? nonEmpty(decodeHtmlEntities(split[1].trim())) : null
+  if (toId === '') return null
+
+  const from = seq.participant(fromId, null)
+  if (from === null) return null
+  const to = seq.participant(toId, null)
+  if (to === null) return null
+  return { from, to, text, dashed: found.dashed, head: found.head, marks }
+}

package/src/loom-mermaid/diagrams/state.ts

@@ -0,0 +1,279 @@
+/**
+ * `stateDiagram` / `stateDiagram-v2`: states, transitions, descriptions and
+ * composite states. Lenient: an unreadable statement is dropped and recorded
+ * in `warnings`.
+ *
+ * A composite (`state X { ... }`) becomes a `Group`, drawn as a titled frame
+ * by the same machinery flowchart subgraphs use; `--` splits a composite into
+ * unlabelled sibling region groups. `[*]` is scoped per group, so an inner
+ * start dot is a different node from the outer one.
+ */
+
+import { Graph, MAX_GROUP_DEPTH, MAX_GROUPS, parseDir, type Shape } from '../graph.ts'
+import { asciiLower, decodeHtmlEntities } from '../labels.ts'
+import { layoutFlowchart, layoutGrouped } from '../graph-render.ts'
+import type { Diagram } from '../registry.ts'
+import {
+  firstWord,
+  headerKind,
+  nonEmpty,
+  parseClassAssign,
+  parseClassDef,
+  splitColon,
+  splitOnce,
+  statementsOf,
+  takeTags,
+  words,
+} from '../statements.ts'
+
+export const state: Diagram = {
+  kind: 'state',
+  headers: ['statediagram', 'statediagram-v2'],
+  render(src, limits) {
+    const graph = parseState(src)
+    if (graph === null) return null
+    const canvas = graph.groups.length === 0 ? layoutFlowchart(graph, limits) : layoutGrouped(graph, limits)
+    if (canvas === null) return null
+    return { canvas, warnings: graph.warnings, classDefs: graph.classDefs }
+  },
+}
+
+function parseState(src: string): Graph | null {
+  const statements = statementsOf(src)
+  const kind = headerKind(statements)
+  if (kind === null || !state.headers.includes(kind)) return null
+
+  const graph = new Graph()
+  let inNote = false
+  /** `class A,B name` assignments, applied after the walk. */
+  const classAssignments: [string[], string[]][] = []
+  /** Open composites: the group itself and its current `--` region, if any. */
+  const stack: { base: number; region: number | null }[] = []
+
+  /** New group under the current scope, or `null` once a cap is hit. */
+  const newGroup = (id: string, label: string): number | null => {
+    if (graph.groups.length >= MAX_GROUPS || stack.length >= MAX_GROUP_DEPTH) {
+      graph.truncated ??= `subgraph cap (${MAX_GROUPS} groups, depth ${MAX_GROUP_DEPTH}) reached`
+      return null
+    }
+    graph.groups.push({ id, label, parent: graph.curGroup })
+    return graph.groups.length - 1
+  }
+  const scopeOf = (): number | null => {
+    const top = stack.at(-1)
+    return top === undefined ? null : (top.region ?? top.base)
+  }
+
+  for (const st of statements.slice(1)) {
+    if (inNote) {
+      if (asciiLower(st) === 'end note') inNote = false
+      continue
+    }
+    const first = asciiLower(firstWord(st))
+    if (first === 'direction') {
+      graph.dir = parseDir(words(st)[1] ?? '')
+    } else if (first === 'note') {
+      // A single-line `note ... : text` needs no terminator.
+      if (!st.includes(':')) inNote = true
+    } else if (first === 'state') {
+      const rest = st.slice(firstWord(st).length).trim()
+      const open = rest.endsWith('{')
+      const body = open ? rest.slice(0, -1).trim() : rest
+      if (!open) {
+        if (parseStateDecl(body, graph) === null) graph.drop(st)
+      } else {
+        // A composite. An unreadable declaration still opens an anonymous
+        // frame: the `{` was consumed, so the `}` balance must hold.
+        const named = compositeName(body)
+        if (named === null) graph.drop(st)
+        const gi = newGroup(named?.id ?? `anon ${graph.groups.length}`, named?.label ?? '')
+        if (gi !== null) {
+          stack.push({ base: gi, region: null })
+          graph.curGroup = gi
+        }
+      }
+    } else if (first === '}') {
+      stack.pop()
+      graph.curGroup = scopeOf()
+    } else if (first === '--') {
+      // Region divider: members so far move into region 1 on the first `--`;
+      // each divider opens the next unlabelled sibling region.
+      const top = stack.at(-1)
+      if (top !== undefined) {
+        if (top.region === null) {
+          const r1 = newGroup(`region ${graph.groups.length}`, '')
+          if (r1 !== null) {
+            graph.nodeGroup.forEach((g, i) => {
+              if (g === top.base) graph.nodeGroup[i] = r1
+            })
+            graph.groups.forEach((g, i) => {
+              if (i !== r1 && g.parent === top.base) g.parent = r1
+            })
+          }
+        }
+        graph.curGroup = top.base
+        const next = newGroup(`region ${graph.groups.length}`, '')
+        top.region = next
+        graph.curGroup = next ?? top.base
+      }
+    } else if (first === 'classdef') {
+      const def = parseClassDef(st.slice(firstWord(st).length))
+      if (def) for (const name of def.names) graph.classDefs[name] = def.props
+    } else if (first === 'class') {
+      const assign = parseClassAssign(st.slice(firstWord(st).length))
+      if (assign) classAssignments.push(assign)
+    } else if (['hide', 'scale'].includes(first)) {
+      // Styling directives carry no layout meaning.
+    } else if (st.includes('-->')) {
+      if (parseTransition(st, graph) === null) graph.drop(st)
+    } else if (parseStateDesc(st, graph) === null) {
+      graph.drop(st)
+    }
+    if (graph.truncated !== null) {
+      graph.warnings.push(`diagram truncated: ${graph.truncated}`)
+      break
+    }
+  }
+
+  graph.applyClasses(classAssignments)
+
+  return graph.nodes.length === 0 ? null : graph
+}
+
+/** The id and label of a composite declaration body, or `null`. */
+function compositeName(body: string): { id: string; label: string } | null {
+  if (body.startsWith('"')) {
+    const close = body.indexOf('"', 1)
+    if (close === -1) return null
+    const label = decodeHtmlEntities(body.slice(1, close))
+    const after = body.slice(close + 1).trim()
+    // A `:::` tag on a composite is dropped: groups paint no classed cells.
+    const id = takeTags(after.startsWith('as') ? after.slice(2).trim() : label).id
+    return id === '' ? null : { id, label }
+  }
+  // A stereotype on a composite carries no drawing of its own; keep the name.
+  const id = takeTags(body.split('<<')[0].trim()).id
+  return id === '' || /\s/.test(id) ? null : { id, label: id }
+}
+
+/** `state "Label" as id` or `state id <<choice>>` — the non-composite forms. */
+function parseStateDecl(rest: string, graph: Graph): true | null {
+  if (rest === '') return true
+
+  if (rest.startsWith('"')) {
+    const close = rest.indexOf('"', 1)
+    if (close === -1) return null
+    const label = rest.slice(1, close)
+    const after = rest.slice(close + 1).trim()
+    const { id, classes } = takeTags(after.startsWith('as') ? after.slice(2).trim() : label)
+    const idx = graph.nodeLabel(id, decodeHtmlEntities(label))
+    if (idx === null) return null
+    for (const cls of classes) graph.addClass(idx, cls)
+    return true
+  }
+
+  let shape: Shape = 'round'
+  let token = rest
+  let stereotyped = false
+  const pos = rest.indexOf('<<')
+  if (pos !== -1) {
+    const stereo = rest
+      .slice(pos + 2)
+      .replace(/>>$/, '')
+      .trim()
+    if (stereo === 'choice') shape = 'diamond'
+    token = rest.slice(0, pos).trim()
+    stereotyped = true
+  }
+  const { id, classes } = takeTags(token)
+  if (id === '' || /\s/.test(id)) return null
+  const idx = graph.nodeIndex(id, stereotyped ? id : null, shape)
+  if (idx === null) return null
+  for (const cls of classes) graph.addClass(idx, cls)
+  return true
+}
+
+/** `A --> B: label`, including chains `A --> B --> C`. */
+function parseTransition(st: string, graph: Graph): true | null {
+  let rest = st
+  let prev: number | null = null
+
+  for (;;) {
+    const split = splitOnce(rest, '-->')
+    if (!split) break
+    const [lhs, rhs] = split
+
+    const fromTok = takeTags(lhs.trimEnd().replace(/-+$/, '').trim())
+    let from: number
+    if (prev !== null) {
+      // Mid-chain: the source is the previous target, so nothing may precede.
+      if (fromTok.id !== '') return null
+      from = prev
+    } else {
+      if (fromTok.id === '') return null
+      const f = stateEndpoint(graph, fromTok.id, true)
+      if (f === null) return null
+      for (const cls of fromTok.classes) graph.addClass(f, cls)
+      from = f
+    }
+
+    // After the label colon it is all label — mermaid never chains past a
+    // label, so an arrow inside one (`: go "x --> y"`) is text, not a link.
+    const nextArrow = rhs.indexOf('-->')
+    const colon = splitColon(rhs)
+    const labelFirst = colon !== null && (nextArrow === -1 || colon[0].length < nextArrow)
+    const toPart = labelFirst ? colon[0] : nextArrow === -1 ? rhs : rhs.slice(0, nextArrow)
+    const label = labelFirst ? nonEmpty(decodeHtmlEntities(colon[1].trim())) : null
+    const tail = labelFirst || nextArrow === -1 ? '' : rhs.slice(nextArrow)
+
+    const toTok = takeTags(
+      toPart.trimStart().replace(/^>+/, '').trimEnd().replace(/-+$/, '').trim(),
+    )
+    if (toTok.id === '') return null
+    const to = stateEndpoint(graph, toTok.id, false)
+    if (to === null) return null
+    for (const cls of toTok.classes) graph.addClass(to, cls)
+
+    if (!graph.pushEdge({ from, to, label, headTo: 'arrow', headFrom: 'none', line: 'solid' })) {
+      return true
+    }
+    prev = to
+    rest = tail
+  }
+  return true
+}
+
+/**
+ * `[*]` is start or end depending on which side of the arrow it sits, and is
+ * scoped to the enclosing composite — each frame has its own start and end.
+ */
+function stateEndpoint(graph: Graph, id: string, isSource: boolean): number | null {
+  if (id === '[*]') {
+    const scope = graph.curGroup === null ? '' : ` g${graph.curGroup}`
+    return graph.nodeIndex(`[*]${isSource ? 'start' : 'end'}${scope}`, '●', 'round')
+  }
+  return graph.nodeIndex(id, null, 'round')
+}
+
+/** `id: description`, or a bare state name; either may carry `:::` tags. */
+function parseStateDesc(st: string, graph: Graph): true | null {
+  const split = splitColon(st)
+  const { id, classes } = takeTags((split ? split[0] : st).trim())
+  let idx: number | null
+  if (split) {
+    const desc = split[1].trim()
+    if (id === '' || /\s/.test(id) || desc === '') return null
+    // Repeated descriptions accumulate (mermaid stacks them as lines; here
+    // they join and wrap). A bare node's label is its id — that one replaces.
+    const prev = graph.index.get(id)
+    const before = prev === undefined ? null : graph.nodes[prev].label
+    const text = decodeHtmlEntities(desc)
+    idx = graph.nodeLabel(id, before !== null && before !== id ? `${before} ${text}` : text)
+  } else {
+    if (id === '' || /\s/.test(id)) return null
+    idx = graph.nodeIndex(id, null, 'round')
+  }
+  if (idx === null) return null
+  for (const cls of classes) graph.addClass(idx, cls)
+  return true
+}

package/src/loom-mermaid/diagrams/timeline.ts

@@ -0,0 +1,117 @@
+/**
+ * `timeline`: periods and their events as a vertical list — one row per
+ * event, the period named on its first row. Lenient: an unreadable statement
+ * is dropped and recorded in `warnings`.
+ */
+
+import { Canvas, drawText } from '../canvas.ts'
+import { MAX_EDGES } from '../graph.ts'
+import { decodeHtmlEntities, fitLabel, type Limits } from '../labels.ts'
+import type { Diagram } from '../registry.ts'
+import { headerKind, nonEmpty, statementsOf, words } from '../statements.ts'
+import { stringWidth } from '../width.ts'
+
+/** One output row: a period cell (blank on continuations) and an event. */
+interface Row {
+  period: string
+  event: string
+  /** Section headers occupy a row of their own. */
+  section?: boolean
+}
+
+export const timeline: Diagram = {
+  kind: 'timeline',
+  headers: ['timeline'],
+  render(src, limits) {
+    const parsed = parseTimeline(src, limits)
+    if (parsed === null) return null
+    const { title, rows, warnings } = parsed
+
+    const periodW = Math.max(...rows.map((r) => (r.section ? 0 : stringWidth(r.period))))
+    const top = title === null ? 0 : 1
+    const width = Math.max(
+      title === null ? 0 : stringWidth(title) + 6,
+      ...rows.map((r) => (r.section ? stringWidth(r.event) : periodW + 3 + stringWidth(r.event))),
+    )
+    const canvas = new Canvas(width, top + rows.length)
+
+    if (title !== null) {
+      const t = ` ${title} `
+      const x = Math.max(0, Math.floor((width - stringWidth(t) - 4) / 2))
+      drawText(canvas, '──', x, 0, 'edge')
+      drawText(canvas, t, x + 2, 0, 'title')
+      drawText(canvas, '──', x + 2 + stringWidth(t), 0, 'edge')
+    }
+    rows.forEach((row, i) => {
+      const y = top + i
+      if (row.section) {
+        drawText(canvas, row.event, 0, y, 'title')
+        return
+      }
+      drawText(canvas, row.period, 0, y, 'text')
+      if (row.event === '') return
+      drawText(canvas, '─', periodW + 1, y, 'edge')
+      drawText(canvas, row.event, periodW + 3, y, 'edgeLabel')
+    })
+    return { canvas, warnings, classDefs: {} }
+  },
+}
+
+function parseTimeline(
+  src: string,
+  limits: Limits,
+): { title: string | null; rows: Row[]; warnings: string[] } | null {
+  const statements = statementsOf(src)
+  if (headerKind(statements) !== 'timeline') return null
+
+  let title: string | null = null
+  const rows: Row[] = []
+  const warnings: string[] = []
+  let truncated = false
+  let lastPeriod = false
+
+  for (const st of statements.slice(1)) {
+    if (rows.length >= MAX_EDGES) {
+      truncated = true
+      break
+    }
+    const first = words(st)[0]?.toLowerCase()
+    if (first === 'title') {
+      title = nonEmpty(st.slice(st.toLowerCase().indexOf('title') + 5).trim())
+      continue
+    }
+    if (first === 'section') {
+      const name = st.slice(st.toLowerCase().indexOf('section') + 7).trim()
+      rows.push({ period: '', event: clean(name, limits.label), section: true })
+      lastPeriod = false
+      continue
+    }
+    // `period : event : event`; a statement of only `: event`s continues the
+    // previous period (the `;`-split form of mermaid's multi-line events).
+    const parts = st.split(':').map((p) => clean(p, limits.label))
+    const period = parts.shift() ?? ''
+    if (period === '' && parts.length > 0 && lastPeriod) {
+      for (const event of parts) rows.push({ period: '', event })
+      continue
+    }
+    // A bare period renders event-less, as mermaid draws it.
+    if (period !== '' && parts.length === 0) {
+      rows.push({ period, event: '' })
+      lastPeriod = true
+      continue
+    }
+    if (period === '' || parts.some((p) => p === '')) {
+      warnings.push(`dropped, unreadable statement: "${st}"`)
+      continue
+    }
+    parts.forEach((event, i) => {
+      rows.push({ period: i === 0 ? period : '', event })
+    })
+    lastPeriod = true
+  }
+  if (truncated) warnings.push(`diagram truncated: event cap (${MAX_EDGES}) reached`)
+
+  return rows.length === 0 ? null : { title, rows, warnings }
+}
+
+const clean = (s: string, max: number): string => fitLabel(decodeHtmlEntities(s.trim()), max)