Enum Node 

pub enum Node {
    Document(Vec<Node>),
    ThematicBreak,
    Heading {
        level: u8,
        content: Vec<Node>,
        heading_type: HeadingType,
    },
    CodeBlock {
        language: Option<EcoString>,
        content: EcoString,
        block_type: CodeBlockType,
    },
    HtmlBlock(EcoString),
    LinkReferenceDefinition {
        label: EcoString,
        destination: EcoString,
        title: Option<EcoString>,
    },
    Paragraph(Vec<Node>),
    BlockQuote(Vec<Node>),
    OrderedList {
        start: u32,
        items: Vec<ListItem>,
    },
    UnorderedList(Vec<ListItem>),
    Table {
        headers: Vec<Node>,
        rows: Vec<Vec<Node>>,
    },
    InlineCode(EcoString),
    Emphasis(Vec<Node>),
    Strong(Vec<Node>),
    Strikethrough(Vec<Node>),
    Link {
        url: EcoString,
        title: Option<EcoString>,
        content: Vec<Node>,
    },
    ReferenceLink {
        label: EcoString,
        content: Vec<Node>,
    },
    Image {
        url: EcoString,
        title: Option<EcoString>,
        alt: Vec<Node>,
    },
    Autolink {
        url: EcoString,
        is_email: bool,
    },
    ExtendedAutolink(EcoString),
    HtmlElement(HtmlElement),
    HardBreak,
    SoftBreak,
    Text(EcoString),
    Custom(Box<dyn CustomNode>),
}

Main node type, representing an element in a CommonMark document

Variants

Document(Vec<Node>)

Root document node, contains child nodes

ThematicBreak

Thematic break (horizontal rule)

Heading

Heading, contains level (1-6) and inline content

Fields

level: u8

Heading level, 1-6

content: Vec<Node>

Heading content, containing inline elements

heading_type: HeadingType

Heading type (ATX or Setext)

CodeBlock

Code block, containing optional language identifier and content

Fields

language: Option<EcoString>

Optional language identifier (None for indented code blocks, Some for fenced code blocks)

content: EcoString

Code content

block_type: CodeBlockType

The type of code block (Indented or Fenced)

HtmlBlock(EcoString)

HTML block

LinkReferenceDefinition

Link reference definition

Fields

label: EcoString

Link label (used for reference)

destination: EcoString

Link destination URL

title: Option<EcoString>

Optional link title

Paragraph(Vec<Node>)

Paragraph node, containing inline elements

BlockQuote(Vec<Node>)

Block quote, containing any block-level elements

OrderedList

Ordered list, containing starting number and list items

Fields

start: u32

List starting number

items: Vec<ListItem>

List items

UnorderedList(Vec<ListItem>)

Unordered list, containing list items

Table

Table (extension to CommonMark)

Fields

headers: Vec<Node>

Header cells

rows: Vec<Vec<Node>>

Table rows, each row containing multiple cells

InlineCode(EcoString)

Inline code

Emphasis(Vec<Node>)

Emphasis (italic)

Strong(Vec<Node>)

Strong emphasis (bold)

Strikethrough(Vec<Node>)

Strikethrough (GFM extension)

Link

Link

Fields

url: EcoString

Link URL

title: Option<EcoString>

Optional link title

content: Vec<Node>

Link text

ReferenceLink

Reference link

Fields

label: EcoString

Link reference label

content: Vec<Node>

Link text content (optional, if empty it’s a shortcut reference)

Image

Image

Fields

url: EcoString

Image URL

title: Option<EcoString>

Optional image title

alt: Vec<Node>

Alternative text, containing inline elements

Autolink

Autolink (URI or email wrapped in < and >)

Fields

url: EcoString

Link URL

is_email: bool

Whether this is an email autolink

ExtendedAutolink(EcoString)

GFM Extended Autolink (without angle brackets, automatically detected)

HtmlElement(HtmlElement)

HTML inline element

HardBreak

Hard break (two spaces followed by a line break, or backslash followed by a line break)

SoftBreak

Soft break (single line break)

Text(EcoString)

Plain text

Custom(Box<dyn CustomNode>)

Custom node that allows users to implement their own writing behavior

Implementations

impl Node

pub fn is_block(&self) -> bool

Check if a node is a block-level node

pub fn is_inline(&self) -> bool

Check if a node is an inline node

pub fn heading(level: u8, content: Vec<Node>) -> Self

Create a heading node

Arguments

• level - Heading level (1-6)
• content - Heading content

Returns

A new heading node, default ATX type

pub fn code_block(language: Option<EcoString>, content: EcoString) -> Self

Create a code block node

Arguments

• language - Optional language identifier
• content - Code content

Returns

A new code block node, default Fenced type

pub fn strikethrough(content: Vec<Node>) -> Self

Create a strikethrough node

Arguments

• content - Content to be struck through

Returns

A new strikethrough node

pub fn as_custom_type<T: CustomNode + 'static>(&self) -> Option<&T>

Check if a custom node is of a specific type, and return a reference to that type

pub fn is_custom_type<T: CustomNode + 'static>(&self) -> bool

Check if a node is a custom node of a specific type

Trait Implementations

impl Clone for Node

fn clone(&self) -> Node

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Node

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

Formats the value using the given formatter.

impl Default for Node

fn default() -> Self

Returns the “default value” for a type.

impl Display for Node

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

Formats the value using the given formatter.

impl PartialEq for Node

fn eq(&self, other: &Node) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Node