@perspective-dev/viewer 5.0.0 → 5.2.0

package/src/rust/agent/markdown/block.rs

@@ -0,0 +1,509 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+// ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+// ┃ This file is part of the Perspective library, distributed under the terms ┃
+// ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+//! Block-level markdown: a line-oriented pass over container structure
+//! (blockquotes, list items) via prefix-stripping recursion, with nom
+//! recognizers for the line classifiers. Deliberately NOT combinator-driven
+//! at the top level — block structure is indentation-context state, which
+//! fits a line loop better than a grammar.
+
+use nom::IResult;
+use nom::branch::alt;
+use nom::character::complete::{digit1, one_of};
+use nom::combinator::{map, verify};
+use nom::sequence::terminated;
+
+use super::events::{Align, Event, Tag};
+use super::inline;
+
+pub fn parse(text: &str) -> Vec<Event> {
+    let lines = text.lines().map(str::to_owned).collect::<Vec<_>>();
+    let mut events = vec![];
+    parse_blocks(&lines, &mut events);
+    events
+}
+
+fn parse_blocks(lines: &[String], events: &mut Vec<Event>) {
+    let mut i = 0;
+    while i < lines.len() {
+        let line = &lines[i];
+        let trimmed = line.trim_start_matches(' ');
+        let indent = line.len() - trimmed.len();
+        if trimmed.is_empty() {
+            i += 1;
+        } else if indent <= 3
+            && let Some((fence, fence_len, lang)) = fence_open(trimmed)
+        {
+            i = parse_fence(lines, i, indent, fence, fence_len, lang, events);
+        } else if indent >= 4 {
+            i = parse_indented_code(lines, i, events);
+        } else if let Some((level, content)) = atx_heading(trimmed) {
+            events.push(Event::Start(Tag::Heading(level)));
+            inline::parse_into(content, events);
+            events.push(Event::End);
+            i += 1;
+        } else if thematic_break(trimmed) {
+            events.push(Event::Rule);
+            i += 1;
+        } else if trimmed.starts_with('>') {
+            i = parse_quote(lines, i, events);
+        } else if let Some(aligns) = table_start(lines, i) {
+            i = parse_table(lines, i, aligns, events);
+        } else if let Some((_, start, content_col)) = list_marker(line) {
+            i = parse_list(lines, i, start, content_col, events);
+        } else {
+            i = parse_paragraph(lines, i, events);
+        }
+    }
+}
+
+/// ` ```lang ` / `~~~lang` — 3+ fence chars, optional info string whose
+/// first word is the language.
+fn fence_open(trimmed: &str) -> Option<(char, usize, Option<String>)> {
+    let fence = trimmed.chars().next().filter(|x| *x == '`' || *x == '~')?;
+    let len = trimmed.chars().take_while(|x| *x == fence).count();
+    if len < 3 {
+        return None;
+    }
+
+    let info = trimmed[len..].trim();
+    if fence == '`' && info.contains('`') {
+        return None;
+    }
+
+    Some((
+        fence,
+        len,
+        info.split_whitespace().next().map(str::to_owned),
+    ))
+}
+
+#[allow(clippy::too_many_arguments)]
+fn parse_fence(
+    lines: &[String],
+    i: usize,
+    indent: usize,
+    fence: char,
+    fence_len: usize,
+    lang: Option<String>,
+    events: &mut Vec<Event>,
+) -> usize {
+    let mut content = String::new();
+    let mut j = i + 1;
+    while j < lines.len() {
+        let line = &lines[j];
+        let trimmed = line.trim_start_matches(' ');
+        let close_len = trimmed.chars().take_while(|x| *x == fence).count();
+        if close_len >= fence_len && trimmed[close_len..].trim().is_empty() {
+            j += 1;
+            break;
+        }
+
+        // Strip up to the opening fence's indentation.
+        let strip = line.chars().take_while(|x| *x == ' ').count().min(indent);
+
+        content.push_str(&line[strip..]);
+        content.push('\n');
+        j += 1;
+    }
+
+    events.push(Event::Start(Tag::CodeBlock(lang)));
+    events.push(Event::Text(content));
+    events.push(Event::End);
+    j
+}
+
+fn parse_indented_code(lines: &[String], i: usize, events: &mut Vec<Event>) -> usize {
+    let mut collected: Vec<String> = vec![];
+    let mut j = i;
+    while j < lines.len() {
+        let line = &lines[j];
+        if line.trim().is_empty() {
+            collected.push(String::new());
+        } else if indent_of(line) >= 4 {
+            collected.push(line[4..].to_owned());
+        } else {
+            break;
+        }
+
+        j += 1;
+    }
+
+    while collected.last().is_some_and(|x| x.is_empty()) {
+        collected.pop();
+    }
+
+    events.push(Event::Start(Tag::CodeBlock(None)));
+    events.push(Event::Text(collected.join("\n") + "\n"));
+    events.push(Event::End);
+    j
+}
+
+/// 1–6 `#` + space (or end of line); optional closing `#` run stripped.
+fn atx_heading(trimmed: &str) -> Option<(u8, &str)> {
+    let level = trimmed.chars().take_while(|x| *x == '#').count();
+    if level == 0 || level > 6 {
+        return None;
+    }
+
+    let rest = &trimmed[level..];
+    if !rest.is_empty() && !rest.starts_with(' ') {
+        return None;
+    }
+
+    let content = rest.trim();
+    let stripped = content.trim_end_matches('#');
+    let content =
+        if stripped.len() < content.len() && (stripped.is_empty() || stripped.ends_with(' ')) {
+            stripped.trim_end()
+        } else {
+            content
+        };
+
+    Some((level as u8, content))
+}
+
+/// 3+ of the same `-`/`_`/`*` char, optionally space-separated, alone on
+/// the line. Checked before list markers so `---` is a rule.
+fn thematic_break(trimmed: &str) -> bool {
+    for fence in ['-', '_', '*'] {
+        if trimmed.chars().all(|x| x == fence || x == ' ')
+            && trimmed.chars().filter(|x| *x == fence).count() >= 3
+        {
+            return true;
+        }
+    }
+
+    false
+}
+
+/// Consecutive `>`-prefixed lines; no lazy continuation.
+fn parse_quote(lines: &[String], i: usize, events: &mut Vec<Event>) -> usize {
+    let mut inner = vec![];
+    let mut j = i;
+    while j < lines.len() {
+        let trimmed = lines[j].trim_start_matches(' ');
+        let Some(rest) = trimmed.strip_prefix('>') else {
+            break;
+        };
+
+        inner.push(rest.strip_prefix(' ').unwrap_or(rest).to_owned());
+        j += 1;
+    }
+
+    events.push(Event::Start(Tag::BlockQuote));
+    parse_blocks(&inner, events);
+    events.push(Event::End);
+    j
+}
+
+fn nom_bullet(input: &str) -> IResult<&str, Option<u64>> {
+    map(one_of("-*+"), |_| None)(input)
+}
+
+fn nom_ordered(input: &str) -> IResult<&str, Option<u64>> {
+    map(
+        terminated(verify(digit1, |x: &str| x.len() <= 9), one_of(".)")),
+        |x: &str| Some(x.parse().unwrap_or(1)),
+    )(input)
+}
+
+/// `- ` / `* ` / `+ ` / `1. ` / `1) ` → (indent, `List` payload, column
+/// where item content begins).
+fn list_marker(line: &str) -> Option<(usize, Option<u64>, usize)> {
+    let indent = indent_of(line);
+    if indent > 3 {
+        return None;
+    }
+
+    let rest = &line[indent..];
+    let (after, start) = alt((nom_bullet, nom_ordered))(rest).ok()?;
+    if !after.is_empty() && !after.starts_with(' ') {
+        return None;
+    }
+
+    let width = rest.len() - after.len();
+    Some((indent, start, indent + width + 1))
+}
+
+fn parse_list(
+    lines: &[String],
+    i: usize,
+    start: Option<u64>,
+    content_col: usize,
+    events: &mut Vec<Event>,
+) -> usize {
+    events.push(Event::Start(Tag::List(start)));
+    let mut j = i;
+    let mut col = content_col;
+    loop {
+        // One item: the marker line's remainder, plus blank or
+        // content-indented continuation lines, prefix-stripped.
+        let mut item = vec![line_from(&lines[j], col)];
+        j += 1;
+        while j < lines.len() {
+            let line = &lines[j];
+            if line.trim().is_empty() {
+                item.push(String::new());
+            } else if indent_of(line) >= col {
+                item.push(line_from(line, col));
+            } else {
+                break;
+            }
+
+            j += 1;
+        }
+
+        while item.last().is_some_and(|x| x.is_empty()) {
+            item.pop();
+        }
+
+        let mut item_events = vec![];
+        parse_blocks(&item, &mut item_events);
+        events.push(Event::Start(Tag::Item));
+        events.extend(strip_item_paragraphs(item_events));
+        events.push(Event::End);
+
+        // Another marker of the same list kind continues the list.
+        match lines.get(j).and_then(|x| list_marker(x)) {
+            Some((_, next_start, next_col)) if next_start.is_some() == start.is_some() => {
+                col = next_col;
+            },
+            _ => break,
+        }
+    }
+
+    events.push(Event::End);
+    j
+}
+
+/// All lists render tight: top-level paragraph wrappers inside an item are
+/// stripped (adjacent stripped paragraphs separated by a hard break), so
+/// `<li>` holds inline content directly, with nested blocks intact.
+fn strip_item_paragraphs(item_events: Vec<Event>) -> Vec<Event> {
+    let mut out = Vec::with_capacity(item_events.len());
+    let mut depth = 0usize;
+    let mut stripped = vec![];
+    let mut pending_break = false;
+    for event in item_events {
+        match event {
+            Event::Start(Tag::Paragraph) if depth == 0 => {
+                if pending_break {
+                    out.push(Event::HardBreak);
+                    pending_break = false;
+                }
+
+                stripped.push(depth);
+                depth += 1;
+            },
+            Event::Start(tag) => {
+                if depth == 0 {
+                    pending_break = false;
+                }
+
+                depth += 1;
+                out.push(Event::Start(tag));
+            },
+            Event::End => {
+                depth -= 1;
+                if stripped.last() == Some(&depth) {
+                    stripped.pop();
+                    pending_break = true;
+                } else {
+                    out.push(Event::End);
+                }
+            },
+            event => {
+                if depth == 0 {
+                    pending_break = false;
+                }
+
+                out.push(event);
+            },
+        }
+    }
+
+    out
+}
+
+/// A table begins at a line containing `|` whose successor is a delimiter
+/// row with a MATCHING column count — the count check keeps prose containing
+/// pipes (and `---` rules) from false-positives.
+fn table_start(lines: &[String], i: usize) -> Option<Vec<Align>> {
+    if !lines[i].contains('|') {
+        return None;
+    }
+
+    let aligns = delimiter_row(lines.get(i + 1)?)?;
+    (split_row(&lines[i]).len() == aligns.len()).then_some(aligns)
+}
+
+fn delimiter_row(line: &str) -> Option<Vec<Align>> {
+    if !line.contains('|') {
+        return None;
+    }
+
+    let cells = split_row(line);
+    if cells.is_empty() {
+        return None;
+    }
+
+    cells
+        .iter()
+        .map(|cell| {
+            let cell = cell.trim();
+            let dashes = cell.trim_start_matches(':').trim_end_matches(':');
+            if dashes.is_empty() || !dashes.chars().all(|x| x == '-') {
+                return None;
+            }
+
+            Some(match (cell.starts_with(':'), cell.ends_with(':')) {
+                (true, true) => Align::Center,
+                (true, false) => Align::Left,
+                (false, true) => Align::Right,
+                (false, false) => Align::None,
+            })
+        })
+        .collect()
+}
+
+/// Split on unescaped `|` outside backtick code spans; outer pipes dropped,
+/// cells trimmed. Per GFM, `\|` unescapes HERE (before inline parsing) —
+/// that's how a pipe gets into a cell's code span; other escapes are left
+/// for the inline pass.
+fn split_row(line: &str) -> Vec<String> {
+    let chars = line.trim().chars().collect::<Vec<_>>();
+    let mut cells = vec![];
+    let mut cell = String::new();
+    let mut code: Option<usize> = None;
+    let mut i = 0;
+    while i < chars.len() {
+        match chars[i] {
+            '\\' if i + 1 < chars.len() => {
+                if chars[i + 1] != '|' {
+                    cell.push('\\');
+                }
+
+                cell.push(chars[i + 1]);
+                i += 2;
+            },
+            '`' => {
+                let run = chars[i..].iter().take_while(|x| **x == '`').count();
+                code = match code {
+                    None => Some(run),
+                    Some(open) if open == run => None,
+                    open => open,
+                };
+
+                cell.extend(std::iter::repeat_n('`', run));
+                i += run;
+            },
+            '|' if code.is_none() => {
+                cells.push(cell.trim().to_owned());
+                cell.clear();
+                i += 1;
+            },
+            c => {
+                cell.push(c);
+                i += 1;
+            },
+        }
+    }
+
+    cells.push(cell.trim().to_owned());
+    if cells.first().is_some_and(|x| x.is_empty()) {
+        cells.remove(0);
+    }
+
+    if cells.last().is_some_and(|x| x.is_empty()) {
+        cells.pop();
+    }
+
+    cells
+}
+
+fn parse_table(lines: &[String], i: usize, aligns: Vec<Align>, events: &mut Vec<Event>) -> usize {
+    let columns = aligns.len();
+    events.push(Event::Start(Tag::Table(aligns)));
+    events.push(Event::Start(Tag::TableHead));
+    for cell in split_row(&lines[i]) {
+        events.push(Event::Start(Tag::TableCell));
+        inline::parse_into(&cell, events);
+        events.push(Event::End);
+    }
+
+    events.push(Event::End);
+    let mut j = i + 2;
+    while j < lines.len() && !lines[j].trim().is_empty() && lines[j].contains('|') {
+        let cells = split_row(&lines[j]);
+        events.push(Event::Start(Tag::TableRow));
+        for c in 0..columns {
+            events.push(Event::Start(Tag::TableCell));
+            inline::parse_into(cells.get(c).map(String::as_str).unwrap_or(""), events);
+            events.push(Event::End);
+        }
+
+        events.push(Event::End);
+        j += 1;
+    }
+
+    events.push(Event::End);
+    j
+}
+
+/// Non-blank lines accumulate until a blank or a construct that interrupts
+/// a paragraph; indented lines join it (indented code cannot interrupt).
+fn parse_paragraph(lines: &[String], i: usize, events: &mut Vec<Event>) -> usize {
+    let mut text = String::new();
+    let mut j = i;
+    while j < lines.len() {
+        let line = &lines[j];
+        let trimmed = line.trim_start_matches(' ');
+        let indent = line.len() - trimmed.len();
+        if trimmed.is_empty()
+            || j > i
+                && indent <= 3
+                && (fence_open(trimmed).is_some()
+                    || atx_heading(trimmed).is_some()
+                    || thematic_break(trimmed)
+                    || trimmed.starts_with('>')
+                    || list_marker(line).is_some()
+                    || table_start(lines, j).is_some())
+        {
+            break;
+        }
+
+        if j > i {
+            text.push('\n');
+        }
+
+        // Trailing spaces are significant (hard breaks) — only CR is
+        // stripped.
+        text.push_str(line.trim_end_matches('\r'));
+        j += 1;
+    }
+
+    events.push(Event::Start(Tag::Paragraph));
+    inline::parse_into(text.trim_start(), events);
+    events.push(Event::End);
+    j
+}
+
+fn indent_of(line: &str) -> usize {
+    line.chars().take_while(|x| *x == ' ').count()
+}
+
+/// The tail of `line` from byte column `col` (always a char boundary — the
+/// prefix is ASCII spaces/markers), or empty when the line is shorter.
+fn line_from(line: &str, col: usize) -> String {
+    line.get(col..).unwrap_or("").to_owned()
+}

package/src/rust/agent/markdown/entity.rs

@@ -0,0 +1,52 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+// ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+// ┃ This file is part of the Perspective library, distributed under the terms ┃
+// ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+//! Minimal HTML entity decoding: numeric references plus the named entities
+//! that actually occur in LLM output. An unrecognized entity stays literal
+//! text — a cosmetic divergence from CommonMark's 2,000-entry table, never a
+//! correctness one (this module exists so we don't link that table).
+
+const NAMED: &[(&str, char)] = &[
+    ("amp", '&'),
+    ("lt", '<'),
+    ("gt", '>'),
+    ("quot", '"'),
+    ("apos", '\''),
+    ("nbsp", '\u{a0}'),
+    ("mdash", '—'),
+    ("ndash", '–'),
+    ("hellip", '…'),
+    ("copy", '©'),
+    ("reg", '®'),
+    ("trade", '™'),
+    ("deg", '°'),
+    ("times", '×'),
+    ("plusmn", '±'),
+    ("middot", '·'),
+];
+
+/// Try to decode an entity reference at the start of `text` (which begins
+/// just AFTER the `&`). Returns the decoded char and the length consumed
+/// (excluding the `&`).
+pub fn decode(text: &str) -> Option<(char, usize)> {
+    let semi = text.find(';').filter(|x| *x <= 10)?;
+    let name = &text[..semi];
+    let decoded = if let Some(hex) = name.strip_prefix("#x").or_else(|| name.strip_prefix("#X")) {
+        char::from_u32(u32::from_str_radix(hex, 16).ok()?)?
+    } else if let Some(dec) = name.strip_prefix('#') {
+        char::from_u32(dec.parse().ok()?)?
+    } else {
+        NAMED.iter().find(|(n, _)| *n == name)?.1
+    };
+
+    Some((decoded, semi + 1))
+}

package/src/rust/agent/markdown/events.rs

@@ -0,0 +1,71 @@
+// ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+// ┃ ██████ ██████ ██████       █      █      █      █      █ █▄  ▀███ █       ┃
+// ┃ ▄▄▄▄▄█ █▄▄▄▄▄ ▄▄▄▄▄█  ▀▀▀▀▀█▀▀▀▀▀ █ ▀▀▀▀▀█ ████████▌▐███ ███▄  ▀█ █ ▀▀▀▀▀ ┃
+// ┃ █▀▀▀▀▀ █▀▀▀▀▀ █▀██▀▀ ▄▄▄▄▄ █ ▄▄▄▄▄█ ▄▄▄▄▄█ ████████▌▐███ █████▄   █ ▄▄▄▄▄ ┃
+// ┃ █      ██████ █  ▀█▄       █ ██████      █      ███▌▐███ ███████▄ █       ┃
+// ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+// ┃ Copyright (c) 2017, the Perspective Authors.                              ┃
+// ┃ ╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌ ┃
+// ┃ This file is part of the Perspective library, distributed under the terms ┃
+// ┃ of the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0). ┃
+// ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+
+//! The parser→renderer event vocabulary — the closed set of constructs the
+//! chat renderer emits. Anything the parser can't classify degrades to
+//! `Text`, so content is never lost, only unstyled.
+
+/// GFM table column alignment.
+#[derive(Clone, Debug, PartialEq)]
+pub enum Align {
+    None,
+    Left,
+    Center,
+    Right,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum Tag {
+    Paragraph,
+
+    /// ATX heading level, `1..=6`.
+    Heading(u8),
+
+    BlockQuote,
+
+    /// A code block; the payload is the fence's language word, if any.
+    CodeBlock(Option<String>),
+
+    /// `None` renders `<ul>`; `Some(start)` renders `<ol>`.
+    List(Option<u64>),
+
+    Item,
+    Emphasis,
+    Strong,
+    Strikethrough,
+    Link {
+        dest_url: String,
+        title: String,
+    },
+    Image {
+        dest_url: String,
+    },
+    Table(Vec<Align>),
+    TableHead,
+    TableRow,
+    TableCell,
+}
+
+/// `Start`/`End` are emitted in balanced pairs by construction — both come
+/// from the same lexical scope in the parser.
+#[derive(Clone, Debug, PartialEq)]
+pub enum Event {
+    Start(Tag),
+    End,
+    Text(String),
+
+    /// An inline code span (block-level code is `Tag::CodeBlock` + `Text`).
+    Code(String),
+    SoftBreak,
+    HardBreak,
+    Rule,
+}