Struct LineInfo 

pub struct LineInfo {

    pub byte_offset: usize,
    pub byte_len: usize,
    pub indent: usize,
    pub visual_indent: usize,
    pub is_blank: bool,
    pub in_code_block: bool,
    pub in_front_matter: bool,
    pub in_html_block: bool,
    pub in_list_block: bool,
    pub in_table_block: bool,
    pub in_html_comment: bool,
    pub list_item: Option<Box<ListItemInfo>>,
    pub heading: Option<Box<HeadingInfo>>,
    pub is_setext_heading_text: bool,
    pub blockquote: Option<Box<BlockquoteInfo>>,
    pub in_mkdocstrings: bool,
    pub in_esm_block: bool,
    pub in_code_span_continuation: bool,
    pub is_horizontal_rule: bool,
    pub in_math_block: bool,
    pub in_pandoc_div: bool,
    pub is_div_marker: bool,
    pub is_container_marker: bool,
    pub in_jsx_expression: bool,
    pub in_mdx_comment: bool,
    pub in_admonition: bool,
    pub in_content_tab: bool,
    pub in_mkdocs_html_markdown: bool,
    pub in_definition_list: bool,
    pub in_obsidian_comment: bool,
    pub in_pymdown_block: bool,
    pub in_kramdown_extension_block: bool,
    pub is_kramdown_block_ial: bool,
    pub in_jsx_block: bool,
    pub in_footnote_definition: bool,
    pub in_myst_directive: bool,
    pub is_myst_comment: bool,
}

Pre-computed information about a line

Fields

byte_offset: usize

Byte offset where this line starts in the document

byte_len: usize

Length of the line in bytes (without newline)

indent: usize

Number of bytes of leading whitespace (for substring extraction)

visual_indent: usize

Visual column width of leading whitespace (with proper tab expansion) Per CommonMark, tabs expand to the next column that is a multiple of 4. Use this for numeric comparisons like checking for indented code blocks (>= 4).

is_blank: bool

Whether the line is blank (empty or only whitespace)

in_code_block: bool

Whether this line is inside a code block

in_front_matter: bool

Whether this line is inside front matter

in_html_block: bool

Whether this line is inside an HTML block

in_list_block: bool

Whether this line is part of a list block (precomputed for O(1) lookup)

in_table_block: bool

Whether this line is part of a table block (precomputed for O(1) lookup)

in_html_comment: bool

Whether this line is inside an HTML comment

list_item: Option<Box<ListItemInfo>>

List item information if this line starts a list item Boxed to reduce LineInfo size: most lines are not list items

heading: Option<Box<HeadingInfo>>

Heading information if this line is a heading: an ATX heading line, or the last text line of a setext heading, whose underline is the line after Boxed to reduce LineInfo size: most lines are not headings

is_setext_heading_text: bool

Whether the line holds text of a setext heading: one of the lines of the paragraph the underline below them makes a heading of. The heading is recorded in heading on the last of those lines, with text_lines counting them. A setext heading inside a blockquote is reported through headings() and leaves this unset, as it leaves heading unset.

blockquote: Option<Box<BlockquoteInfo>>

Blockquote information if this line is a blockquote Boxed to reduce LineInfo size: most lines are not blockquotes

in_mkdocstrings: bool

Whether this line is inside a mkdocstrings autodoc block

in_esm_block: bool

Whether this line is part of an ESM import/export block (MDX only)

in_code_span_continuation: bool

Whether this line is a continuation of a multi-line code span from a previous line

is_horizontal_rule: bool

Whether this line is a horizontal rule (—, ***, ___, etc.) Pre-computed for consistent detection across all rules

in_math_block: bool

Whether this line is inside a math block ($$ … $$)

in_pandoc_div: bool

Whether this line is inside a Pandoc/Quarto div block (::: … :::)

is_div_marker: bool

Whether this line is a Quarto/Pandoc div marker (opening ::: {.class} or closing :::) Analogous to is_horizontal_rule — marks structural delimiters that are not paragraph text

is_container_marker: bool

Whether the line is the marker of a container whose body is Markdown: a MkDocs admonition or content tab opener, a PyMdown block fence, or a MyST colon fence. Like is_div_marker, a structural delimiter rather than paragraph text: the body below the marker is the container’s own content, not a continuation of the marker line.

in_jsx_expression: bool

Whether this line contains or is inside a JSX expression (MDX only)

in_mdx_comment: bool

Whether this line is inside an MDX comment {/* … */} (MDX only)

in_admonition: bool

Whether this line is inside an MkDocs admonition block (!!! or ???)

in_content_tab: bool

Whether this line is inside an MkDocs content tab block (===)

in_mkdocs_html_markdown: bool

Whether this line is inside an HTML block with markdown attribute (MkDocs grid cards, etc.)

in_definition_list: bool

Whether this line is a definition list item (: definition)

in_obsidian_comment: bool

Whether this line is inside an Obsidian comment (%%…%% syntax, Obsidian flavor only)

in_pymdown_block: bool

Whether this line is inside a PyMdown Blocks region (/// … ///, MkDocs flavor only)

in_kramdown_extension_block: bool

Whether this line is inside a kramdown extension block ({::comment}…{:/comment}, {::nomarkdown}…{:/nomarkdown})

is_kramdown_block_ial: bool

Whether this line is a kramdown block IAL ({:.class #id}) or ALD ({:ref: .class})

in_jsx_block: bool

Whether this line is inside a JSX component block (MDX only, e.g. <Tabs>...</Tabs>)

in_footnote_definition: bool

Whether this line is inside a footnote definition body (continuation lines)

in_myst_directive: bool

Whether this line is inside a MyST directive block (colon or backtick fence with {name})

is_myst_comment: bool

Whether this line is a MyST comment (% comment)

Implementations

impl LineInfo

pub fn content<'a>(&self, source: &'a str) -> &'a str

Get the line content as a string slice from the source document

pub fn in_mkdocs_container(&self) -> bool

Check if this line is inside MkDocs-specific indented content (admonitions, tabs, or markdown HTML). This content uses 4-space indentation which pulldown-cmark would interpret as code blocks, but in MkDocs flavor it’s actually container content that should be preserved.

pub fn is_valid_heading(&self) -> bool

Whether this line is a heading in the document’s structure.

An ATX line without a space after its #s is recorded as a heading so MD018 can report it, with is_valid carrying heading detection’s verdict on whether a heading was meant: #2, #3 and #hashtag read as paragraph text (is_valid == false), ##hashtag and #Hashtag as headings missing their space. Structurally an invalid one is paragraph text: it continues a list item and does not separate two lists. Structural code asks this instead of heading.is_some().

pub fn is_paragraph_context(&self) -> bool

Whether this line could be part of a paragraph block (CommonMark paragraph token).

Returns true for ordinary prose lines, including those inside blockquotes and list items. Returns false for lines that belong to non-paragraph blocks: headings, code blocks, HTML blocks, math blocks, horizontal rules, front matter, structural div markers, and flavor-specific extension blocks. This is the per-line view; cross-line constructs like setext underlines aren’t visible here and need additional context to detect.

Used by rules (e.g. MD009 strict mode) that need to distinguish “trailing whitespace could produce a meaningful <br>” from “trailing whitespace is on a structural boundary.”

pub fn in_flavor_container(&self) -> bool

Whether the line sits in a flavor container whose body is ordinary Markdown: a fenced div, a MyST directive, a MkDocs admonition or content tab, an mkdocstrings block, a PyMdown block, a kramdown extension block, or an HTML block opted in with markdown="1".

Each flag is populated by the flavor’s own detection, so a marker written in a flavor that gives it no meaning sets none of them and the line stays ordinary paragraph text. A container’s opening line carries its own container’s flag, so this is true on the opener as well as on the body, at every nesting depth.

Trait Implementations

impl Clone for LineInfo

fn clone(&self) -> LineInfo

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for LineInfo

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.