Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp
48.1 KB
Raw Blame
// SPDX-License-Identifier: AGPL-3.0-or-later

use crate::ast::{AlertType, ListItem, Node, ParserFlags, TableAlignment};
use crate::constants::{
    CODE_FENCE_LENGTH, MAX_AST_NODES, MAX_CODE_BLOCK_SEARCH_LINES, MAX_LINE_LENGTH,
};
use crate::links::{has_open_inline_code, has_valid_code_fence_language};
use crate::normalize::{normalize_nodes, replace_trailing_whitespace_with_newline};
use crate::parser::{MarkdownParser, ParseError, RuntimeState};
use crate::text::{
    Line, bounded_line_text, byte_at, concat, has_visible_content, line_as_text, lines_to_text,
    starts_with, trim, trim_line_window, trim_right, trim_start, trim_start_newline_whitespace,
};

#[derive(Clone, Debug)]
pub(crate) struct BlockParseResult {
    pub node: Option<Node>,
    pub new_line_index: usize,
    pub new_node_count: usize,
    pub extra_nodes: Option<Vec<Node>>,
}

#[derive(Clone, Debug)]
struct CodeBlockResult {
    node: Node,
    new_line_index: usize,
    extra_content: Option<ExtraContent>,
}

#[derive(Clone, Debug)]
struct ExtraContent {
    content: String,
    offset: usize,
}

#[derive(Clone, Debug)]
struct BlockSpoilerResult {
    node: Node,
    new_line_index: usize,
    new_node_count: usize,
    extra_content: Option<ExtraContent>,
}

#[derive(Clone, Debug)]
struct ClosingFence<'a> {
    fence_index: usize,
    backtick_count: usize,
    trailing_text: &'a str,
}

#[derive(Clone, Debug)]
pub(crate) struct ListMatch<'a> {
    ordered: bool,
    indent_level: usize,
    content: &'a str,
    ordinal: Option<usize>,
}

#[derive(Clone, Debug)]
struct ListResult {
    node: Node,
    new_line_index: usize,
    new_node_count: usize,
}

#[derive(Clone, Debug)]
struct TableResult {
    node: Node,
    new_line_index: usize,
    new_node_count: usize,
}

#[derive(Clone, Debug)]
struct TableCellText {
    text: String,
    offset: usize,
}

#[derive(Clone, Copy, Debug)]
struct TableLine<'a> {
    text: &'a str,
    offset: usize,
}

pub(crate) fn parse_block(state: &mut RuntimeState<'_>) -> Result<BlockParseResult, ParseError> {
    let current = state.current_line;
    let line = state.lines[current].text.clone();
    let line_offset = state.lines[current].offset;
    let trimmed = trim_start(&line);
    let trimmed_offset = line_offset + (line.len() - trimmed.len());

    if starts_with(trimmed, ">>> ") {
        if !ParserFlags::has(
            state.parser.flags(),
            ParserFlags::ALLOW_MULTILINE_BLOCKQUOTES,
        ) {
            return Ok(BlockParseResult {
                node: Some(Node::Text {
                    content: line_as_text(&state.lines, current),
                }),
                new_line_index: current + 1,
                new_node_count: state.parser.node_count + 1,
                extra_nodes: None,
            });
        }
        return parse_multiline_blockquote(
            state.parser,
            &state.lines,
            current,
            state.parser.node_count,
        );
    }
    if starts_with(trimmed, "> ") {
        if !ParserFlags::has(state.parser.flags(), ParserFlags::ALLOW_BLOCKQUOTES) {
            return Ok(no_block(current, state.parser.node_count));
        }
        return parse_blockquote(state.parser, &state.lines, current, state.parser.node_count);
    }

    if let Some(list_match) = match_list_item(&line) {
        if ParserFlags::has(state.parser.flags(), ParserFlags::ALLOW_LISTS) {
            let node_count = state.parser.node_count;
            let list = ListContext {
                parser: state.parser,
                lines: &state.lines,
                fences: &mut state.fences,
            }
            .parse_list(
                current,
                ListLevel {
                    ordered: list_match.ordered,
                    indent_level: list_match.indent_level,
                    depth: 1,
                },
                node_count,
            )?;
            return Ok(BlockParseResult {
                node: Some(list.node),
                new_line_index: list.new_line_index,
                new_node_count: list.new_node_count,
                extra_nodes: None,
            });
        }
        return Ok(BlockParseResult {
            node: Some(Node::Text { content: line }),
            new_line_index: current + 1,
            new_node_count: state.parser.node_count + 1,
            extra_nodes: None,
        });
    }

    if starts_with(trimmed, "||") && !trimmed[2..].contains("||") {
        if ParserFlags::has(state.parser.flags(), ParserFlags::ALLOW_SPOILERS) {
            let result = parse_block_spoiler(state.parser, &state.lines, current)?;
            if let Some(extra) = result.extra_content {
                state.replace_line(result.new_line_index, extra.content, extra.offset);
            }
            return Ok(BlockParseResult {
                node: Some(result.node),
                new_line_index: result.new_line_index,
                new_node_count: result.new_node_count,
                extra_nodes: None,
            });
        }
        return Ok(BlockParseResult {
            node: Some(Node::Text { content: line }),
            new_line_index: current + 1,
            new_node_count: state.parser.node_count + 1,
            extra_nodes: None,
        });
    }

    if ParserFlags::has(state.parser.flags(), ParserFlags::ALLOW_CODE_BLOCKS) {
        if let Some(fence_pos) = find_unescaped_fence(&line) {
            let starts_with_fence =
                starts_with(trimmed, "```") && fence_pos == line.len() - trimmed.len();
            if starts_with_fence {
                if let Some(result) =
                    parse_code_block(&state.lines, current, &line, line_offset, &mut state.fences)
                {
                    if let Some(extra) = result.extra_content {
                        state.replace_line(result.new_line_index, extra.content, extra.offset);
                    }
                    return Ok(BlockParseResult {
                        node: Some(result.node),
                        new_line_index: result.new_line_index,
                        new_node_count: state.parser.node_count + 1,
                        extra_nodes: None,
                    });
                }
                return Ok(no_block(current, state.parser.node_count));
            }
            let prefix = &line[..fence_pos];
            if has_open_inline_code(prefix) {
                return Ok(no_block(current, state.parser.node_count));
            }
            if let Some(code_result) = parse_code_block(
                &state.lines,
                current,
                &line[fence_pos..],
                line_offset + fence_pos,
                &mut state.fences,
            ) {
                let inline_nodes = crate::inline::parse_inline(state.parser, prefix, line_offset)?;
                let new_node_count = state.parser.node_count + inline_nodes.len() + 1;
                let new_line_index = code_result.new_line_index;
                if let Some(extra) = code_result.extra_content {
                    state.replace_line(new_line_index, extra.content, extra.offset);
                }
                let mut inline_nodes = inline_nodes.into_iter();
                let first_node = inline_nodes.next();
                let mut extra_nodes: Vec<Node> = inline_nodes.collect();
                let first_node = match first_node {
                    Some(first_node) => {
                        extra_nodes.push(code_result.node);
                        first_node
                    }
                    None => {
                        extra_nodes.push(code_result.node.clone());
                        code_result.node
                    }
                };
                return Ok(BlockParseResult {
                    node: Some(first_node),
                    extra_nodes: Some(extra_nodes),
                    new_line_index,
                    new_node_count,
                });
            }
        }
    } else if starts_with(trimmed, "```") {
        let mut content = line;
        let mut end_index = current + 1;
        while end_index < state.lines.len() {
            content.push('\n');
            content.push_str(&state.lines[end_index].text);
            if trim(&state.lines[end_index].text) == "```" {
                end_index += 1;
                break;
            }
            end_index += 1;
        }
        return Ok(BlockParseResult {
            node: Some(Node::Text { content }),
            new_line_index: end_index,
            new_node_count: state.parser.node_count + 1,
            extra_nodes: None,
        });
    }

    if starts_with(trimmed, "-#") {
        if ParserFlags::has(state.parser.flags(), ParserFlags::ALLOW_SUBTEXT)
            && let Some(node) = parse_subtext_node(state.parser, trimmed, trimmed_offset)?
        {
            return Ok(BlockParseResult {
                node: Some(node),
                new_line_index: current + 1,
                new_node_count: state.parser.node_count + 1,
                extra_nodes: None,
            });
        }
        return Ok(BlockParseResult {
            node: Some(Node::Text {
                content: line_as_text(&state.lines, current),
            }),
            new_line_index: current + 1,
            new_node_count: state.parser.node_count + 1,
            extra_nodes: None,
        });
    }

    if starts_with(trimmed, "#") {
        if ParserFlags::has(state.parser.flags(), ParserFlags::ALLOW_HEADINGS)
            && let Some(node) = parse_heading_node(state.parser, trimmed, trimmed_offset)?
        {
            return Ok(BlockParseResult {
                node: Some(node),
                new_line_index: current + 1,
                new_node_count: state.parser.node_count + 1,
                extra_nodes: None,
            });
        }
        return Ok(no_block(current, state.parser.node_count));
    }

    if trimmed.contains('|')
        && ParserFlags::has(state.parser.flags(), ParserFlags::ALLOW_TABLES)
        && let Some(table) = parse_table(state.parser, &state.lines, current)?
    {
        return Ok(BlockParseResult {
            node: Some(table.node),
            new_line_index: table.new_line_index,
            new_node_count: table.new_node_count,
            extra_nodes: None,
        });
    }

    Ok(no_block(current, state.parser.node_count))
}

fn no_block(current: usize, node_count: usize) -> BlockParseResult {
    BlockParseResult {
        node: None,
        new_line_index: current,
        new_node_count: node_count,
        extra_nodes: None,
    }
}

pub(crate) fn heading_content(trimmed_line: &str) -> Option<(usize, &str)> {
    let mut level = 0usize;
    while level < trimmed_line.len() && level < 4 && byte_at(trimmed_line, level) == b'#' {
        level += 1;
    }
    if !(1..=4).contains(&level)
        || level >= trimmed_line.len()
        || byte_at(trimmed_line, level) != b' '
    {
        return None;
    }
    let content = &trimmed_line[level + 1..];
    if !has_visible_content(content) && trim(content).is_empty() {
        return None;
    }
    Some((level, content))
}

fn parse_heading_node(
    parser: &mut MarkdownParser,
    trimmed_line: &str,
    offset: usize,
) -> Result<Option<Node>, ParseError> {
    let Some((level, content)) = heading_content(trimmed_line) else {
        return Ok(None);
    };
    let children = crate::inline::parse_inline(parser, content, offset + level + 1)?;
    Ok(Some(Node::Heading {
        level: level as u8,
        children,
    }))
}

fn parse_subtext_node(
    parser: &mut MarkdownParser,
    trimmed_line: &str,
    offset: usize,
) -> Result<Option<Node>, ParseError> {
    if !starts_with(trimmed_line, "-#") {
        return Ok(None);
    }
    if (trimmed_line.len() > 2 && byte_at(trimmed_line, 2) != b' ')
        || (trimmed_line.len() > 3 && byte_at(trimmed_line, 3) == b' ')
    {
        return Ok(None);
    }
    if trimmed_line.len() <= 3 {
        return Ok(None);
    }
    let content = &trimmed_line[3..];
    if !has_visible_content(content) {
        return Ok(None);
    }
    let children = crate::inline::parse_inline(parser, content, offset + 3)?;
    Ok(Some(Node::Subtext { children }))
}

fn parse_blockquote(
    parser: &mut MarkdownParser,
    lines: &[Line],
    current: usize,
    node_count: usize,
) -> Result<BlockParseResult, ParseError> {
    let mut child_lines = Vec::new();
    let mut content_len = 0usize;
    let mut index = current;
    while index < lines.len() {
        let trimmed_line = trim_start(&lines[index].text);
        let trimmed_offset = lines[index].text.len() - trimmed_line.len();
        let mut child_text = "";
        let mut child_offset = lines[index].offset + trimmed_offset;
        if trimmed_line == "> " || trimmed_line == ">  " {
            child_offset += 2;
        } else if starts_with(trimmed_line, "> ") {
            child_text = &trimmed_line[2..];
            child_offset += 2;
        } else {
            break;
        }
        child_lines.push(Line {
            text: bounded_line_text(child_text).to_owned(),
            offset: child_offset,
        });
        content_len += child_text.len() + 1;
        if content_len > MAX_LINE_LENGTH * 100 {
            break;
        }
        index += 1;
    }
    if child_lines.is_empty() {
        return Ok(no_block(index, node_count));
    }
    if ParserFlags::has(parser.flags(), ParserFlags::ALLOW_ALERTS)
        && let Some((alert, alert_node_count)) =
            parse_alert_lines(parser, &child_lines, node_count)?
    {
        return Ok(BlockParseResult {
            node: Some(alert),
            new_line_index: index,
            new_node_count: alert_node_count,
            extra_nodes: None,
        });
    }
    let mut child_parser =
        parser.child_with_flags(parser.flags() & !ParserFlags::ALLOW_BLOCKQUOTES);
    child_parser.node_count = node_count + 1;
    let mut child_nodes = child_parser.parse_lines(child_lines)?;
    normalize_nodes(&mut child_nodes, true);
    let blank_lines = if child_nodes.is_empty() {
        Some(index.saturating_sub(current))
    } else {
        None
    };
    Ok(BlockParseResult {
        node: Some(Node::Blockquote {
            children: child_nodes,
            blank_lines,
        }),
        new_line_index: index,
        new_node_count: child_parser.node_count,
        extra_nodes: None,
    })
}

fn parse_multiline_blockquote(
    parser: &mut MarkdownParser,
    lines: &[Line],
    current: usize,
    node_count: usize,
) -> Result<BlockParseResult, ParseError> {
    let trimmed_line = trim_start(&lines[current].text);
    if !starts_with(trimmed_line, ">>> ") {
        return Ok(BlockParseResult {
            node: Some(Node::Text {
                content: String::new(),
            }),
            new_line_index: current,
            new_node_count: node_count,
            extra_nodes: None,
        });
    }
    let trimmed_offset = lines[current].text.len() - trimmed_line.len();
    let mut child_lines = vec![Line {
        text: bounded_line_text(&trimmed_line[4..]).to_owned(),
        offset: lines[current].offset + trimmed_offset + 4,
    }];
    let mut content_len = trimmed_line[4..].len();
    let mut index = current + 1;
    while index < lines.len() {
        child_lines.push(lines[index].clone());
        content_len += lines[index].text.len() + 1;
        if content_len > MAX_LINE_LENGTH * 100 {
            break;
        }
        index += 1;
    }
    let mut child_parser = parser.child_with_flags(
        (parser.flags() & !ParserFlags::ALLOW_MULTILINE_BLOCKQUOTES)
            | ParserFlags::ALLOW_BLOCKQUOTES,
    );
    child_parser.node_count = node_count + 1;
    let child_nodes = child_parser.parse_lines(child_lines)?;
    let blank_lines = if child_nodes.is_empty() {
        Some(index.saturating_sub(current))
    } else {
        None
    };
    Ok(BlockParseResult {
        node: Some(Node::Blockquote {
            children: child_nodes,
            blank_lines,
        }),
        new_line_index: index,
        new_node_count: child_parser.node_count,
        extra_nodes: None,
    })
}

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
enum CodeBlockMode {
    Build,
    Probe,
}

#[derive(Clone, Debug)]
struct CodeBlockContent {
    mode: CodeBlockMode,
    text: String,
    len: usize,
    visible: bool,
}

impl CodeBlockContent {
    fn push_line(&mut self, line: &str) {
        self.len += line.len() + 1;
        self.visible = self.visible || has_visible_content(line);
        if self.mode == CodeBlockMode::Build {
            self.text.push_str(line);
            self.text.push('\n');
        }
    }

    fn settled(&self) -> bool {
        self.mode == CodeBlockMode::Probe && self.visible
    }
}

fn parse_code_block(
    lines: &[Line],
    current: usize,
    line: &str,
    line_offset: usize,
    fences: &mut ClosingFenceLines,
) -> Option<CodeBlockResult> {
    scan_code_block(
        lines,
        current,
        line,
        line_offset,
        fences,
        CodeBlockMode::Build,
    )
}

fn scan_code_block(
    lines: &[Line],
    current: usize,
    line: &str,
    line_offset: usize,
    fences: &mut ClosingFenceLines,
    mode: CodeBlockMode,
) -> Option<CodeBlockResult> {
    let trimmed_line = trim_start(line);
    let indent_spaces = line.len() - trimmed_line.len();
    let list_indent = &line[..indent_spaces];
    let mut fence_length = 0usize;
    while fence_length < trimmed_line.len() && byte_at(trimmed_line, fence_length) == b'`' {
        fence_length += 1;
    }
    if fence_length < CODE_FENCE_LENGTH {
        return None;
    }
    let language_part = &trimmed_line[fence_length..];
    let closing_fence = "`".repeat(fence_length);
    if let Some(closing_index) = language_part.find(&closing_fence) {
        let inline_content = &language_part[..closing_index];
        if !has_visible_content(inline_content) {
            return None;
        }
        let trailing = &language_part[closing_index + fence_length..];
        return Some(CodeBlockResult {
            node: Node::CodeBlock {
                language: None,
                content: inline_content.to_owned(),
            },
            new_line_index: if trailing.is_empty() {
                current + 1
            } else {
                current
            },
            extra_content: (!trailing.is_empty()).then(|| ExtraContent {
                content: trailing.to_owned(),
                offset: line_offset + (line.len() - trailing.len()),
            }),
        });
    }
    let treat_opening_as_language = has_valid_code_fence_language(language_part);
    let language = treat_opening_as_language.then(|| trim(language_part).to_owned());
    let closing_line = fences.next(lines, current + 1, &closing_fence)?;
    if closing_line - current - 1 > MAX_CODE_BLOCK_SEARCH_LINES {
        return None;
    }
    let mut content = CodeBlockContent {
        mode,
        text: String::new(),
        len: 0,
        visible: false,
    };
    if !treat_opening_as_language && !language_part.is_empty() {
        content.push_line(language_part);
    }
    let mut index = current + 1;
    while index < closing_line && !content.settled() {
        let current_line = &lines[index].text;
        let content_line = if indent_spaces > 0 && starts_with(current_line, list_indent) {
            &current_line[indent_spaces..]
        } else {
            current_line
        };
        content.push_line(content_line);
        if content.len > MAX_LINE_LENGTH * 100 {
            break;
        }
        index += 1;
    }
    let mut extra_content = None;
    if index == closing_line && !content.settled() {
        let current_line = &lines[index].text;
        let trimmed = trim_start(current_line);
        let closing = find_closing_fence(trimmed, &closing_fence, fence_length)?;
        let absolute_fence = current_line.find(&closing_fence).unwrap_or(0);
        let prefix = &current_line[..absolute_fence];
        let content_line = if indent_spaces > 0 && starts_with(prefix, list_indent) {
            &prefix[indent_spaces..]
        } else {
            prefix
        };
        if !content_line.is_empty() {
            content.push_line(content_line);
        }
        let extra_text = if !closing.trailing_text.is_empty() {
            closing.trailing_text
        } else if closing.backtick_count > fence_length {
            &trimmed[closing.fence_index + fence_length..]
        } else {
            ""
        };
        if extra_text.is_empty() {
            index += 1;
        } else {
            extra_content = Some(ExtraContent {
                content: extra_text.to_owned(),
                offset: lines[index].offset + (current_line.len() - extra_text.len()),
            });
        }
    }
    if !content.visible {
        return None;
    }
    Some(CodeBlockResult {
        node: Node::CodeBlock {
            language,
            content: content.text,
        },
        new_line_index: index,
        extra_content,
    })
}

#[derive(Clone, Debug, Default)]
pub(crate) struct ClosingFenceLines {
    next_by_fence: Vec<(usize, Vec<u32>)>,
    valid_from: usize,
}

impl ClosingFenceLines {
    pub(crate) fn line_replaced(&mut self, index: usize) {
        self.valid_from = self.valid_from.max(index + 1);
    }

    fn next(&mut self, lines: &[Line], from: usize, closing_fence: &str) -> Option<usize> {
        if from >= lines.len() {
            return None;
        }
        if from < self.valid_from {
            self.next_by_fence.clear();
            self.valid_from = 0;
        }
        let fence_length = closing_fence.len();
        let index = match self
            .next_by_fence
            .iter()
            .position(|(length, _)| *length == fence_length)
        {
            Some(index) => index,
            None => {
                self.next_by_fence
                    .push((fence_length, vec![0; lines.len()]));
                self.next_by_fence.len() - 1
            }
        };
        let next = &mut self.next_by_fence[index].1;
        let mut position = from;
        let found = loop {
            if position == lines.len() {
                break position;
            }
            if next[position] != 0 {
                break next[position] as usize - 1;
            }
            if find_closing_fence(
                trim_start(&lines[position].text),
                closing_fence,
                fence_length,
            )
            .is_some()
            {
                break position;
            }
            position += 1;
        };
        let stored = found as u32 + 1;
        next[from..position].fill(stored);
        if found == position && found < lines.len() {
            next[found] = stored;
        }
        (found < lines.len()).then_some(found)
    }
}

fn find_closing_fence<'a>(
    trimmed_line: &'a str,
    closing_fence: &str,
    fence_length: usize,
) -> Option<ClosingFence<'a>> {
    let fence_index = trimmed_line.find(closing_fence)?;
    let mut count = 0usize;
    let mut idx = fence_index;
    while idx < trimmed_line.len() && byte_at(trimmed_line, idx) == b'`' {
        count += 1;
        idx += 1;
    }
    let after = byte_at(trimmed_line, idx);
    let trailing = &trimmed_line[idx..];
    let only_whitespace_after = after == 0 || matches!(after, b' ' | b'\t' | b'`');
    if count >= fence_length && (only_whitespace_after || trailing.contains(closing_fence)) {
        return Some(ClosingFence {
            fence_index,
            backtick_count: count,
            trailing_text: trailing,
        });
    }
    None
}

fn parse_block_spoiler(
    parser: &mut MarkdownParser,
    lines: &[Line],
    current: usize,
) -> Result<BlockSpoilerResult, ParseError> {
    let mut found_end = false;
    let mut trailing_content: Option<ExtraContent> = None;
    let mut child_lines = Vec::new();
    let mut content_len = 0usize;
    let mut index = current;
    while index < lines.len() {
        let line = &lines[index].text;
        if index == current {
            if let Some(start) = line.find("||") {
                let child_text = &line[start + 2..];
                child_lines.push(Line {
                    text: bounded_line_text(child_text).to_owned(),
                    offset: lines[index].offset + start + 2,
                });
                content_len += child_text.len() + 1;
            }
        } else if let Some(end) = line.find("||") {
            let child_text = &line[..end];
            child_lines.push(Line {
                text: bounded_line_text(child_text).to_owned(),
                offset: lines[index].offset,
            });
            found_end = true;
            let trailing = &line[end + 2..];
            if !trailing.is_empty() {
                trailing_content = Some(ExtraContent {
                    content: trailing.to_owned(),
                    offset: lines[index].offset + (line.len() - trailing.len()),
                });
            }
            index += 1;
            break;
        } else {
            child_lines.push(lines[index].clone());
            content_len += line.len() + 1;
        }
        if content_len > MAX_LINE_LENGTH * 10 {
            break;
        }
        index += 1;
    }
    if !found_end {
        let content = lines_to_text(&child_lines);
        return Ok(BlockSpoilerResult {
            node: Node::Text {
                content: concat("||", trim_right(&content)),
            },
            new_line_index: index,
            new_node_count: parser.node_count + 1,
            extra_content: None,
        });
    }
    let mut child_parser = parser.child_with_flags(parser.flags());
    child_parser.node_count = parser.node_count + 1;
    let mut window = child_lines;
    if !has_visible_content(&lines_to_text(&window)) {
        return Ok(BlockSpoilerResult {
            node: Node::Text {
                content: lines_to_text(&lines[current..index]),
            },
            new_line_index: index,
            new_node_count: parser.node_count + 1,
            extra_content: None,
        });
    }
    let inner = child_parser.parse_lines(trim_line_window(&mut window))?;
    Ok(BlockSpoilerResult {
        node: Node::Spoiler {
            children: inner,
            is_block: Some(true),
        },
        new_line_index: if trailing_content.is_some() {
            index - 1
        } else {
            index
        },
        new_node_count: child_parser.node_count,
        extra_content: trailing_content,
    })
}

fn parse_alert_lines(
    parser: &mut MarkdownParser,
    lines: &[Line],
    node_count: usize,
) -> Result<Option<(Node, usize)>, ParseError> {
    if lines.is_empty() || !starts_with(&lines[0].text, "[!") {
        return Ok(None);
    }
    let Some(close) = lines[0].text.find(']') else {
        return Ok(None);
    };
    let label = &lines[0].text[2..close];
    let Some(alert_type) = alert_type(label) else {
        return Ok(None);
    };

    let mut content_lines = Vec::new();
    let after_label = &lines[0].text[close + 1..];
    let after_trimmed = trim_start_newline_whitespace(after_label);
    if !after_trimmed.is_empty() {
        content_lines.push(Line {
            text: bounded_line_text(after_trimmed).to_owned(),
            offset: lines[0].offset + close + 1 + (after_label.len() - after_trimmed.len()),
        });
    }
    if lines.len() > 1 {
        content_lines.extend(lines[1..].iter().cloned());
    }
    let mut child_parser = parser.child_with_flags(
        (parser.flags() & !ParserFlags::ALLOW_BLOCKQUOTES)
            | ParserFlags::ALLOW_LISTS
            | ParserFlags::ALLOW_HEADINGS,
    );
    child_parser.node_count = node_count + 1;
    let prepared = prepare_alert_content_lines(content_lines);
    let mut children = child_parser.parse_lines(prepared)?;
    children = post_process_alert_nodes(children);
    Ok(Some((
        Node::Alert {
            alert_type,
            children,
        },
        child_parser.node_count,
    )))
}

fn prepare_alert_content_lines(mut lines: Vec<Line>) -> Vec<Line> {
    let mut out = Vec::new();
    let mut blank_run = 0usize;
    for line in lines.drain(..) {
        let is_list_like = is_alert_list_like_line(trim(&line.text));
        let mut prepared = line;
        if is_list_like {
            prepared.text = bounded_line_text(&prepared.text).to_owned();
        } else {
            let left_trimmed = trim_start(&prepared.text);
            let leading_bytes = prepared.text.len() - left_trimmed.len();
            prepared.offset += leading_bytes;
            prepared.text = bounded_line_text(trim_right(left_trimmed)).to_owned();
        }
        if trim(&prepared.text).is_empty() {
            blank_run += 1;
            if blank_run > 2 {
                continue;
            }
            prepared.text.clear();
        } else {
            blank_run = 0;
        }
        out.push(prepared);
    }
    trim_line_window(&mut out)
}

fn is_alert_list_like_line(trimmed_line: &str) -> bool {
    if starts_with(trimmed_line, "-") {
        return true;
    }
    let mut index = 0usize;
    while index < trimmed_line.len() && byte_at(trimmed_line, index).is_ascii_digit() {
        index += 1;
    }
    index > 0 && index < trimmed_line.len() && byte_at(trimmed_line, index) == b'.'
}

fn post_process_alert_nodes(nodes: Vec<Node>) -> Vec<Node> {
    if nodes.len() <= 1 {
        return nodes;
    }
    let mut out = Vec::new();
    let mut nodes = nodes.into_iter().peekable();
    while let Some(node) = nodes.next() {
        match node {
            Node::Text { content } if matches!(nodes.peek(), Some(Node::List { .. })) => {
                let content = replace_trailing_whitespace_with_newline(&content);
                if !content.is_empty() {
                    out.push(Node::Text { content });
                }
            }
            node @ Node::List { .. } if nodes.peek().is_some() => {
                out.push(node);
                let trailing = match nodes.peek() {
                    Some(Node::Text { content }) if !trim(content).is_empty() => {
                        Some(concat("\n", trim(content)))
                    }
                    _ => None,
                };
                if let Some(content) = trailing {
                    nodes.next();
                    out.push(Node::Text { content });
                }
            }
            node => out.push(node),
        }
    }
    out
}

#[derive(Clone, Copy, Debug)]
struct ListLevel {
    ordered: bool,
    indent_level: usize,
    depth: usize,
}

struct ListContext<'a> {
    parser: &'a mut MarkdownParser,
    lines: &'a [Line],
    fences: &'a mut ClosingFenceLines,
}

impl ListContext<'_> {
    fn parse_list(
        &mut self,
        current: usize,
        level: ListLevel,
        node_count: usize,
    ) -> Result<ListResult, ParseError> {
        let ListLevel {
            ordered,
            indent_level,
            depth,
        } = level;
        let lines = self.lines;
        let mut items = Vec::new();
        let mut index = current;
        let mut new_count = node_count;
        while index < lines.len() {
            if new_count > MAX_AST_NODES {
                break;
            }
            let current_line = &lines[index].text;
            let trimmed_line = trim_start(current_line);
            if starts_with(trimmed_line, "#")
                || is_blockquote_start(trimmed_line, self.parser.flags())
            {
                break;
            }
            if let Some(item) = match_list_item(current_line) {
                let ordinal = normalise_ordinal(&items, item.ordinal, ordered);
                if item.indent_level < indent_level {
                    break;
                }
                if item.indent_level == indent_level {
                    if item.ordered != ordered {
                        break;
                    }
                    let mut children = Vec::new();
                    if let Some(inline_item) = match_list_item(item.content) {
                        let mut nested_items = Vec::new();
                        let inline_nodes = crate::inline::parse_inline(
                            self.parser,
                            inline_item.content,
                            lines[index].offset + (current_line.len() - inline_item.content.len()),
                        )?;
                        nested_items.push(ListItem {
                            children: inline_nodes,
                            ordinal: None,
                        });
                        if let Some(nested) =
                            self.try_parse_nested_list(index + 1, indent_level, depth, new_count)?
                        {
                            if let Node::List { items, .. } = nested.node {
                                nested_items.extend(items);
                                index = nested.new_line_index;
                                new_count = nested.new_node_count;
                            } else {
                                index += 1;
                                new_count += 1;
                            }
                        } else {
                            index += 1;
                            new_count += 1;
                        }
                        children.push(Node::List {
                            ordered: inline_item.ordered,
                            items: nested_items,
                        });
                    } else {
                        let content_nodes = crate::inline::parse_inline(
                            self.parser,
                            item.content,
                            lines[index].offset + (current_line.len() - item.content.len()),
                        )?;
                        let content_node_count = content_nodes.len();
                        children.extend(content_nodes);
                        if let Some(nested) =
                            self.try_parse_nested_list(index + 1, indent_level, depth, new_count)?
                        {
                            children.push(nested.node);
                            index = nested.new_line_index;
                            new_count = nested.new_node_count;
                        } else {
                            index += 1;
                            new_count += content_node_count;
                        }
                    }
                    items.push(ListItem { children, ordinal });
                } else if item.indent_level == indent_level + 1 && depth < 9 {
                    let nested = self.parse_list(
                        index,
                        ListLevel {
                            ordered: item.ordered,
                            indent_level: item.indent_level,
                            depth: depth + 1,
                        },
                        new_count,
                    )?;
                    if let Some(last) = items.last_mut() {
                        last.children.push(nested.node);
                    }
                    index = nested.new_line_index;
                    new_count = nested.new_node_count;
                } else {
                    break;
                }
            } else if is_list_continuation(current_line, indent_level) {
                if let Some(last) = items.last_mut() {
                    let trimmed = trim_start(current_line);
                    let parsed = crate::inline::parse_inline(
                        self.parser,
                        trimmed,
                        lines[index].offset + (current_line.len() - trimmed.len()),
                    )?;
                    new_count += parsed.len();
                    last.children.extend(parsed);
                }
                index += 1;
            } else {
                break;
            }
            if items.len() > MAX_AST_NODES {
                break;
            }
        }
        Ok(ListResult {
            node: Node::List { ordered, items },
            new_line_index: index,
            new_node_count: new_count,
        })
    }

    fn try_parse_nested_list(
        &mut self,
        current: usize,
        parent_indent: usize,
        depth: usize,
        node_count: usize,
    ) -> Result<Option<ListResult>, ParseError> {
        let lines = self.lines;
        if current >= lines.len() {
            return Ok(None);
        }
        let trimmed = trim_start(&lines[current].text);
        if starts_with(trimmed, "```")
            && let Some(result) = parse_code_block(
                lines,
                current,
                &lines[current].text,
                lines[current].offset,
                self.fences,
            )
        {
            return Ok(Some(ListResult {
                node: result.node,
                new_line_index: result.new_line_index,
                new_node_count: node_count + 1,
            }));
        }
        if let Some(item) = match_list_item(&lines[current].text)
            && item.indent_level > parent_indent
            && depth < 9
        {
            return self
                .parse_list(
                    current,
                    ListLevel {
                        ordered: item.ordered,
                        indent_level: item.indent_level,
                        depth: depth + 1,
                    },
                    node_count,
                )
                .map(Some);
        }
        Ok(None)
    }
}

pub(crate) fn match_list_item(line: &str) -> Option<ListMatch<'_>> {
    let mut indent = 0usize;
    while indent < line.len() && byte_at(line, indent) == b' ' {
        indent += 1;
    }
    let indent_level = indent / 2;
    if indent >= line.len() {
        return None;
    }
    let marker = byte_at(line, indent);
    if matches!(marker, b'*' | b'-') && indent + 1 < line.len() && byte_at(line, indent + 1) == b' '
    {
        return Some(ListMatch {
            ordered: false,
            indent_level,
            content: &line[indent + 2..],
            ordinal: None,
        });
    }
    if marker.is_ascii_digit() {
        let mut pos = indent;
        while pos < line.len() && byte_at(line, pos).is_ascii_digit() {
            pos += 1;
        }
        if pos < line.len()
            && byte_at(line, pos) == b'.'
            && pos + 1 < line.len()
            && byte_at(line, pos + 1) == b' '
        {
            return Some(ListMatch {
                ordered: true,
                indent_level,
                content: &line[pos + 2..],
                ordinal: line[indent..pos].parse::<usize>().ok().or(Some(1)),
            });
        }
    }
    None
}

fn parse_table(
    parser: &mut MarkdownParser,
    lines: &[Line],
    current: usize,
) -> Result<Option<TableResult>, ParseError> {
    let Some((header_cells, alignments)) = table_header(lines, current) else {
        return Ok(None);
    };
    let (header_row, header_node_count) = create_table_row(parser, &header_cells)?;
    let column_count = header_cells.len();
    let mut new_node_count = parser.node_count + 1 + header_node_count;
    let mut rows = Vec::new();
    let mut index = current + 2;
    while index < lines.len() && new_node_count <= MAX_AST_NODES {
        let line = trim_table_line(&lines[index]);
        if !is_table_body_line(line.text) {
            break;
        }
        let cells = normalize_column_count(split_table_cells(line), column_count);
        let (row, row_node_count) = create_table_row(parser, &cells)?;
        rows.push(row);
        new_node_count += row_node_count;
        index += 1;
    }
    Ok(Some(TableResult {
        node: Node::Table {
            header: Box::new(header_row),
            alignments,
            rows,
        },
        new_line_index: index,
        new_node_count,
    }))
}

fn table_header(
    lines: &[Line],
    current: usize,
) -> Option<(Vec<TableCellText>, Vec<TableAlignment>)> {
    if current + 2 >= lines.len() {
        return None;
    }
    let header_line = trim_table_line(&lines[current]);
    let align_line = trim_table_line(&lines[current + 1]);
    if !header_line.text.contains('|')
        || !align_line.text.contains('|')
        || !align_line.text.bytes().all(|byte| {
            matches!(
                byte,
                b' ' | b':' | b'-' | b'|' | b'\\' | b'\t' | b'\r' | b'\n'
            )
        })
        || !is_table_body_line(trim_table_line(&lines[current + 2]).text)
    {
        return None;
    }
    let header_cells = split_table_cells(header_line);
    if header_cells.is_empty() || !cells_have_content(&header_cells) {
        return None;
    }
    let alignments = parse_alignments(&split_table_cells(align_line))?;
    (header_cells.len() == alignments.len()).then_some((header_cells, alignments))
}

fn is_table_body_line(text: &str) -> bool {
    text.contains('|') && !is_table_block_break(text)
}

fn trim_table_line(line: &Line) -> TableLine<'_> {
    let left = trim_start(&line.text);
    TableLine {
        text: trim_right(left),
        offset: line.offset + (line.text.len() - left.len()),
    }
}

fn split_table_cells(source: TableLine<'_>) -> Vec<TableCellText> {
    let line = source.text;
    let bytes = line.as_bytes();
    let start = usize::from(line.starts_with('|'));
    let mut end = line.len();
    if end > start && line.ends_with('|') {
        end -= 1;
    }
    let mut cells = Vec::new();
    if start >= end {
        return cells;
    }
    let mut cell = String::new();
    let mut cell_offset = source.offset + start;
    let mut segment_start = start;
    let mut i = start;
    while i < end {
        if bytes[i] == b'\\' && i + 1 < end && bytes[i + 1] == b'|' {
            cell.push_str(&line[segment_start..i]);
            cell.push('|');
            i += 2;
            segment_start = i;
            continue;
        }
        if bytes[i] == b'|' {
            cell.push_str(&line[segment_start..i]);
            cells.push(TableCellText {
                text: std::mem::take(&mut cell),
                offset: cell_offset,
            });
            i += 1;
            segment_start = i;
            cell_offset = source.offset + i;
            continue;
        }
        i += 1;
    }
    cell.push_str(&line[segment_start..end]);
    cells.push(TableCellText {
        text: cell,
        offset: cell_offset,
    });
    cells
}

fn parse_alignments(cells: &[TableCellText]) -> Option<Vec<TableAlignment>> {
    if cells.is_empty() {
        return None;
    }
    let mut alignments = Vec::with_capacity(cells.len());
    for cell in cells {
        let value = trim(&cell.text);
        if value.is_empty() || !value.contains('-') {
            return None;
        }
        if !value
            .bytes()
            .all(|c| matches!(c, b' ' | b':' | b'-' | b'|'))
        {
            return None;
        }
        let left = value.starts_with(':');
        let right = value.ends_with(':');
        alignments.push(if left && right {
            TableAlignment::Center
        } else if left {
            TableAlignment::Left
        } else if right {
            TableAlignment::Right
        } else {
            TableAlignment::None
        });
    }
    Some(alignments)
}

fn create_table_row(
    parser: &mut MarkdownParser,
    cells: &[TableCellText],
) -> Result<(Node, usize), ParseError> {
    let mut out = Vec::new();
    let mut node_count = 1;
    for cell in cells {
        let left = trim_start(&cell.text);
        let value = trim_right(left);
        let offset = cell.offset + (cell.text.len() - left.len());
        let parsed = crate::inline::parse_inline(parser, value, offset)?;
        let children = if parsed.is_empty() {
            vec![Node::Text {
                content: value.to_owned(),
            }]
        } else {
            parsed
        };
        node_count += 1 + children.len();
        out.push(Node::TableCell { children });
    }
    Ok((Node::TableRow { cells: out }, node_count))
}

pub(crate) fn is_block_start(line: &str, flags: u32) -> bool {
    starts_with(line, "#")
        || (ParserFlags::has(flags, ParserFlags::ALLOW_SUBTEXT) && starts_with(line, "-#"))
        || (ParserFlags::has(flags, ParserFlags::ALLOW_CODE_BLOCKS) && starts_with(line, "```"))
        || (ParserFlags::has(flags, ParserFlags::ALLOW_LISTS) && match_list_item(line).is_some())
        || is_blockquote_start(line, flags)
}

pub(crate) fn opens_code_block_midline(
    lines: &[Line],
    index: usize,
    flags: u32,
    fences: &mut ClosingFenceLines,
) -> bool {
    if !ParserFlags::has(flags, ParserFlags::ALLOW_CODE_BLOCKS) || index >= lines.len() {
        return false;
    }
    let line = &lines[index].text;
    let Some(fence_pos) = find_unescaped_fence(line) else {
        return false;
    };
    let trimmed = trim_start(line);
    if starts_with(trimmed, "```") && fence_pos == line.len() - trimmed.len() {
        return false;
    }
    let prefix = &line[..fence_pos];
    if has_open_inline_code(prefix) {
        return false;
    }
    scan_code_block(
        lines,
        index,
        &line[fence_pos..],
        lines[index].offset + fence_pos,
        fences,
        CodeBlockMode::Probe,
    )
    .is_some()
}

pub(crate) fn is_table_start(lines: &[Line], index: usize, flags: u32) -> bool {
    ParserFlags::has(flags, ParserFlags::ALLOW_TABLES) && table_header(lines, index).is_some()
}

pub(crate) fn is_heading_start(line: &str, flags: u32) -> bool {
    if !ParserFlags::has(flags, ParserFlags::ALLOW_HEADINGS) || !starts_with(line, "#") {
        return false;
    }
    let mut level = 0usize;
    while level < line.len() && level < 4 && byte_at(line, level) == b'#' {
        level += 1;
    }
    (1..=4).contains(&level) && level < line.len() && byte_at(line, level) == b' '
}

pub(crate) fn is_blockquote_start(line: &str, flags: u32) -> bool {
    (ParserFlags::has(flags, ParserFlags::ALLOW_MULTILINE_BLOCKQUOTES) && starts_with(line, ">>> "))
        || (ParserFlags::has(flags, ParserFlags::ALLOW_BLOCKQUOTES) && starts_with(line, "> "))
}

fn alert_type(label: &str) -> Option<AlertType> {
    if label.eq_ignore_ascii_case("NOTE") {
        Some(AlertType::Note)
    } else if label.eq_ignore_ascii_case("TIP") {
        Some(AlertType::Tip)
    } else if label.eq_ignore_ascii_case("IMPORTANT") {
        Some(AlertType::Important)
    } else if label.eq_ignore_ascii_case("WARNING") {
        Some(AlertType::Warning)
    } else if label.eq_ignore_ascii_case("CAUTION") {
        Some(AlertType::Caution)
    } else {
        None
    }
}

fn find_unescaped_fence(line: &str) -> Option<usize> {
    let mut search = 0usize;
    while let Some(offset) = line[search..].find("```") {
        let fence_pos = search + offset;
        if !is_escaped_fence(line, fence_pos) {
            return Some(fence_pos);
        }
        search = fence_pos + 1;
    }
    None
}

fn is_escaped_fence(line: &str, fence_pos: usize) -> bool {
    let mut backslashes = 0usize;
    let mut index = fence_pos;
    while index > 0 && byte_at(line, index - 1) == b'\\' {
        backslashes += 1;
        index -= 1;
    }
    backslashes % 2 == 1
}

fn normalise_ordinal(items: &[ListItem], ordinal: Option<usize>, ordered: bool) -> Option<usize> {
    if !ordered {
        return None;
    }
    if items.is_empty() {
        return ordinal.or(Some(1));
    }
    let start = items[0].ordinal.or(ordinal).unwrap_or(1);
    Some(start + items.len())
}

fn is_list_continuation(line: &str, indent_level: usize) -> bool {
    let mut spaces = 0usize;
    while spaces < line.len() && byte_at(line, spaces) == b' ' {
        spaces += 1;
    }
    spaces > indent_level * 2
}

fn cells_have_content(cells: &[TableCellText]) -> bool {
    cells.iter().any(|cell| !trim(&cell.text).is_empty())
}

fn normalize_column_count(cells: Vec<TableCellText>, expected: usize) -> Vec<TableCellText> {
    if cells.len() == expected {
        return cells;
    }
    let mut cells = cells.into_iter();
    let mut out: Vec<TableCellText> = (0..expected)
        .map(|_| {
            cells.next().unwrap_or(TableCellText {
                text: String::new(),
                offset: 0,
            })
        })
        .collect();
    if let Some(last) = out.last_mut() {
        for extra in cells {
            last.text.push('|');
            last.text.push_str(&extra.text);
        }
    }
    out
}

fn is_table_block_break(text: &str) -> bool {
    if text.is_empty() {
        return false;
    }
    let first = byte_at(text, 0);
    if matches!(first, b'#' | b'>' | b'-' | b'*') {
        return true;
    }
    if text.len() >= 2 && byte_at(text, 0) == b'-' && byte_at(text, 1) == b'#' {
        return true;
    }
    if first.is_ascii_digit() {
        for i in 1..text.len().min(4) {
            if byte_at(text, i) == b'.' {
                return true;
            }
        }
    }
    false
}