Container

jotdown

Enum Container 

Source 
pub enum Container<'s> {

Show 32 variants    Blockquote,
    List {
        kind: ListKind,
        tight: bool,
    },
    ListItem,
    TaskListItem {
        checked: bool,
    },
    DescriptionList,
    DescriptionDetails,
    Footnote {
        label: Cow<'s, str>,
    },
    Table,
    TableRow {
        head: bool,
    },
    Section {
        id: Cow<'s, str>,
    },
    Div {
        class: Cow<'s, str>,
    },
    Paragraph,
    Heading {
        level: u16,
        has_section: bool,
        id: Cow<'s, str>,
    },
    TableCell {
        alignment: Alignment,
        head: bool,
    },
    Caption,
    DescriptionTerm,
    LinkDefinition {
        label: Cow<'s, str>,
    },
    RawBlock {
        format: Cow<'s, str>,
    },
    CodeBlock {
        language: Cow<'s, str>,
    },
    Span,
    Link(Cow<'s, str>, LinkType),
    Image(Cow<'s, str>, SpanLinkType),
    Verbatim,
    Math {
        display: bool,
    },
    RawInline {
        format: Cow<'s, str>,
    },
    Subscript,
    Superscript,
    Insert,
    Delete,
    Strong,
    Emphasis,
    Mark,

}
Expand description

A container that may contain other elements.

There are three types of containers:

  • inline, may only contain inline elements,
  • block leaf, may only contain inline elements,
  • block container, may contain any block-level elements.

Variants§

§

Blockquote

A blockquote element.

§Examples

let src = concat!(
    "> a\n",
    "> b\n",
);
let events: Vec<_> = Parser::new(src).collect();
assert_eq!(
    &events,
    &[
        Event::Start(Container::Blockquote, Attributes::new()),
        Event::Start(Container::Paragraph, Attributes::new()),
        Event::Str("a".into()),
        Event::Softbreak,
        Event::Str("b".into()),
        Event::End(Container::Paragraph),
        Event::End(Container::Blockquote),
    ],
);
let html = concat!(
    "<blockquote>\n",
    "<p>a\n",
    "b</p>\n",
    "</blockquote>\n",
);
assert_eq!(&html::render_to_string(events.into_iter()), html);
§

List

A list.

§Examples

let src = concat!(
    "- a\n",
    "\n",
    "- b\n",
);
let events: Vec<_> = Parser::new(src).collect();
assert_eq!(
    &events,
    &[
        Event::Start(
            Container::List {
                kind: ListKind::Unordered(ListBulletType::Dash),
                tight: false,
            },
            Attributes::new(),
        ),
        Event::Start(Container::ListItem, Attributes::new()),
        Event::Start(Container::Paragraph, Attributes::new()),
        Event::Str("a".into()),
        Event::End(Container::Paragraph),
        Event::Blankline,
        Event::End(Container::ListItem),
        Event::Start(Container::ListItem, Attributes::new()),
        Event::Start(Container::Paragraph, Attributes::new()),
        Event::Str("b".into()),
        Event::End(Container::Paragraph),
        Event::End(Container::ListItem),
        Event::End(Container::List {
            kind: ListKind::Unordered(ListBulletType::Dash),
            tight: false
        }),
    ],
);
let html = concat!(
    "<ul>\n",
    "<li>\n",
    "<p>a</p>\n",
    "</li>\n",
    "<li>\n",
    "<p>b</p>\n",
    "</li>\n",
    "</ul>\n",
);
assert_eq!(&html::render_to_string(events.into_iter()), html);

Fields

§kind: ListKind
§tight: bool
§

ListItem

An item of a list

§Examples

let src = "- a";
let events: Vec<_> = Parser::new(src).collect();
assert_eq!(
    &events,
    &[
        Event::Start(
            Container::List {
                kind: ListKind::Unordered(ListBulletType::Dash),
                tight: true,
            },
            Attributes::new(),
        ),
        Event::Start(Container::ListItem, Attributes::new()),
        Event::Start(Container::Paragraph, Attributes::new()),
        Event::Str("a".into()),
        Event::End(Container::Paragraph),
        Event::End(Container::ListItem),
        Event::End(Container::List {
            kind: ListKind::Unordered(ListBulletType::Dash),
            tight: true,
        }),
    ],
);
let html = concat!(
    "<ul>\n",
    "<li>\n",
    "a\n",
    "</li>\n",
    "</ul>\n",
);
assert_eq!(&html::render_to_string(events.into_iter()), html);
§

TaskListItem

An item of a task list, either checked or unchecked.

§Examples

let src = "- [x] a";
let events: Vec<_> = Parser::new(src).collect();
assert_eq!(
    &events,
    &[
        Event::Start(
            Container::List {
                kind: ListKind::Task(ListBulletType::Dash),
                tight: true
            },
            Attributes::new(),
        ),
        Event::Start(
            Container::TaskListItem { checked: true },
            Attributes::new(),
        ),
        Event::Start(Container::Paragraph, Attributes::new()),
        Event::Str("a".into()),
        Event::End(Container::Paragraph),
        Event::End(Container::TaskListItem { checked: true }),
        Event::End(Container::List {
            kind: ListKind::Task(ListBulletType::Dash),
            tight: true,
        }),
    ],
);
let html = concat!(
    "<ul class=\"task-list\">\n",
    "<li>\n",
    "<input disabled=\"\" type=\"checkbox\" checked=\"\"/>\n",
    "a\n",
    "</li>\n",
    "</ul>\n",
);
assert_eq!(&html::render_to_string(events.into_iter()), html);

Fields

§checked: bool
§

DescriptionList

A description list.

§Examples

let src = concat!(
    ": orange\n",
    "\n",
    " citrus fruit\n",
    ": apple\n",
    "\n",
    " malus fruit\n",
);
let events: Vec<_> = Parser::new(src).collect();
assert_eq!(
    &events,
    &[
        Event::Start(Container::DescriptionList, Attributes::new()),
        Event::Start(Container::DescriptionTerm, Attributes::new()),
        Event::Str("orange".into()),
        Event::End(Container::DescriptionTerm),
        Event::Blankline,
        Event::Start(Container::DescriptionDetails, Attributes::new()),
        Event::Start(Container::Paragraph, Attributes::new()),
        Event::Str("citrus fruit".into()),
        Event::End(Container::Paragraph),
        Event::End(Container::DescriptionDetails),
        Event::Start(Container::DescriptionTerm, Attributes::new()),
        Event::Str("apple".into()),
        Event::End(Container::DescriptionTerm),
        Event::Blankline,
        Event::Start(Container::DescriptionDetails, Attributes::new()),
        Event::Start(Container::Paragraph, Attributes::new()),
        Event::Str("malus fruit".into()),
        Event::End(Container::Paragraph),
        Event::End(Container::DescriptionDetails),
        Event::End(Container::DescriptionList),
    ],
);
let html = concat!(
    "<dl>\n",
    "<dt>orange</dt>\n",
    "<dd>\n",
    "<p>citrus fruit</p>\n",
    "</dd>\n",
    "<dt>apple</dt>\n",
    "<dd>\n",
    "<p>malus fruit</p>\n",
    "</dd>\n",
    "</dl>\n",
);
assert_eq!(&html::render_to_string(events.into_iter()), html);
§

DescriptionDetails

Details describing a term within a description list.

§

Footnote

A footnote definition.

§Examples

let src = concat!(
    "txt[^nb]\n",
    "\n",
    "[^nb]: actually..\n",
);
let events: Vec<_> = Parser::new(src).collect();
assert_eq!(
    &events,
    &[
        Event::Start(Container::Paragraph, Attributes::new()),
        Event::Str("txt".into()),
        Event::FootnoteReference("nb".into()),
        Event::End(Container::Paragraph),
        Event::Blankline,
        Event::Start(
            Container::Footnote { label: "nb".into() },
            Attributes::new(),
        ),
        Event::Start(Container::Paragraph, Attributes::new()),
        Event::Str("actually..".into()),
        Event::End(Container::Paragraph),
        Event::End(Container::Footnote { label: "nb".into() }),
    ],
);
let html = concat!(
    "<p>txt<a id=\"fnref1\" href=\"#fn1\" role=\"doc-noteref\"><sup>1</sup></a></p>\n",
    "<section role=\"doc-endnotes\">\n",
    "<hr>\n",
    "<ol>\n",
    "<li id=\"fn1\">\n",
    "<p>actually..<a href=\"#fnref1\" role=\"doc-backlink\">↩\u{fe0e}</a></p>\n",
    "</li>\n",
    "</ol>\n",
    "</section>\n",
);
assert_eq!(&html::render_to_string(events.into_iter()), html);

Fields

§label: Cow<'s, str>
§

Table

A table element.

§Examples

let src = concat!(
    "| a | b |\n",
    "|---|--:|\n",
    "| 1 | 2 |\n",
);
let events: Vec<_> = Parser::new(src).collect();
assert_eq!(
    &events,
    &[
        Event::Start(Container::Table, Attributes::new()),
        Event::Start(
            Container::TableRow { head: true },
            Attributes::new(),
        ),
        Event::Start(
            Container::TableCell {
                alignment: Alignment::Unspecified,
                head: true
            },
            Attributes::new(),
        ),
        Event::Str("a".into()),
        Event::End(Container::TableCell {
            alignment: Alignment::Unspecified,
            head: true,
        }),
        Event::Start(
            Container::TableCell {
                alignment: Alignment::Right,
                head: true,
            },
            Attributes::new(),
        ),
        Event::Str("b".into()),
        Event::End(Container::TableCell {
            alignment: Alignment::Right,
            head: true,
        }),
        Event::End(Container::TableRow { head: true } ),
        Event::Start(
            Container::TableRow { head: false },
            Attributes::new(),
        ),
        Event::Start(
            Container::TableCell {
                alignment: Alignment::Unspecified,
                head: false
            },
            Attributes::new(),
        ),
        Event::Str("1".into()),
        Event::End(Container::TableCell {
            alignment: Alignment::Unspecified,
            head: false,
        }),
        Event::Start(
            Container::TableCell {
                alignment: Alignment::Right,
                head: false,
            },
            Attributes::new(),
        ),
        Event::Str("2".into()),
        Event::End(Container::TableCell {
            alignment: Alignment::Right,
            head: false,
        }),
        Event::End(Container::TableRow { head: false } ),
        Event::End(Container::Table),
    ],
);
let html = concat!(
    "<table>\n",
    "<tr>\n",
    "<th>a</th>\n",
    "<th style=\"text-align: right;\">b</th>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>1</td>\n",
    "<td style=\"text-align: right;\">2</td>\n",
    "</tr>\n",
    "</table>\n",
);
assert_eq!(&html::render_to_string(events.into_iter()), html);
§

TableRow

A row element of a table.

Fields

§head: bool
§

Section

A section belonging to a top level heading.

§Examples

let src = concat!(
    "# outer\n",
    "\n",
    "## inner\n",
);
let events: Vec<_> = Parser::new(src).collect();
assert_eq!(
    &events,
    &[
        Event::Start(
            Container::Section { id: "outer".into() },
            Attributes::new(),
        ),
        Event::Start(
            Container::Heading {
                level: 1,
                has_section: true,
                id: "outer".into(),
            },
            Attributes::new(),
        ),
        Event::Str("outer".into()),
        Event::End(Container::Heading {
            level: 1,
            has_section: true,
            id: "outer".into(),
        }),
        Event::Blankline,
        Event::Start(
            Container::Section { id: "inner".into() },
            Attributes::new(),
        ),
        Event::Start(
            Container::Heading {
                level: 2,
                has_section: true,
                id: "inner".into(),
            },
            Attributes::new(),
        ),
        Event::Str("inner".into()),
        Event::End(Container::Heading {
            level: 2,
            has_section: true,
            id: "inner".into(),
        }),
        Event::End(Container::Section { id: "inner".into() }),
        Event::End(Container::Section { id: "outer".into() }),
    ],
);
let html = concat!(
    "<section id=\"outer\">\n",
    "<h1>outer</h1>\n",
    "<section id=\"inner\">\n",
    "<h2>inner</h2>\n",
    "</section>\n",
    "</section>\n",
);
assert_eq!(&html::render_to_string(events.into_iter()), html);

Fields

§id: Cow<'s, str>
§

Div

A block-level divider element.

§Examples

let src = concat!(
    "::: note\n",
    "this is a note\n",
    ":::\n",
);
let events: Vec<_> = Parser::new(src).collect();
assert_eq!(
    &events,
    &[
        Event::Start(
            Container::Div { class: "note".into() },
            Attributes::new(),
        ),
        Event::Start(Container::Paragraph, Attributes::new()),
        Event::Str("this is a note".into()),
        Event::End(Container::Paragraph),
        Event::End(Container::Div { class: "note".into() }),
    ],
);
let html = concat!(
    "<div class=\"note\">\n",
    "<p>this is a note</p>\n",
    "</div>\n",
);
assert_eq!(&html::render_to_string(events.into_iter()), html);

Fields

§class: Cow<'s, str>
§

Paragraph

A paragraph.

§

Heading

A heading.

§Examples

let src = "# heading";
let events: Vec<_> = Parser::new(src).collect();
assert_eq!(
    &events,
    &[
        Event::Start(
            Container::Section { id: "heading".into() },
            Attributes::new(),
        ),
        Event::Start(
            Container::Heading {
                level: 1,
                has_section: true,
                id: "heading".into(),
            },
            Attributes::new(),
        ),
        Event::Str("heading".into()),
        Event::End(Container::Heading {
            level: 1,
            has_section: true,
            id: "heading".into(),
        }),
        Event::End(Container::Section { id: "heading".into() }),
    ],
);
let html = concat!(
    "<section id=\"heading\">\n",
    "<h1>heading</h1>\n",
    "</section>\n",
);
assert_eq!(&html::render_to_string(events.into_iter()), html);

Fields

§level: u16
§has_section: bool
§id: Cow<'s, str>
§

TableCell

A cell element of row within a table.

Fields

§alignment: Alignment
§head: bool
§

Caption

A caption within a table.

§Examples

let src = concat!(
    "|a|\n",
    "^ caption\n",
);
let events: Vec<_> = Parser::new(src).collect();
assert_eq!(
    &events,
    &[
        Event::Start(Container::Table, Attributes::new()),
        Event::Start(Container::Caption, Attributes::new()),
        Event::Str("caption".into()),
        Event::End(Container::Caption),
        Event::Start(
            Container::TableRow { head: false },
            Attributes::new(),
        ),
        Event::Start(
            Container::TableCell {
                alignment: Alignment::Unspecified,
                head: false
            },
            Attributes::new(),
        ),
        Event::Str("a".into()),
        Event::End(Container::TableCell {
            alignment: Alignment::Unspecified,
            head: false,
        }),
        Event::End(Container::TableRow { head: false } ),
        Event::End(Container::Table),
    ],
);
let html = concat!(
    "<table>\n",
    "<caption>caption</caption>\n",
    "<tr>\n",
    "<td>a</td>\n",
    "</tr>\n",
    "</table>\n",
);
assert_eq!(&html::render_to_string(events.into_iter()), html);
§

DescriptionTerm

A term within a description list.

§

LinkDefinition

A link definition.

§Examples

let src = "[label]: url";
let events: Vec<_> = Parser::new(src).collect();
assert_eq!(
    &events,
    &[
        Event::Start(
            Container::LinkDefinition { label: "label".into() },
            Attributes::new(),
        ),
        Event::Str("url".into()),
        Event::End(Container::LinkDefinition { label: "label".into() }),
    ],
);
let html = "\n";
assert_eq!(&html::render_to_string(events.into_iter()), html);

Fields

§label: Cow<'s, str>
§

RawBlock

A block with raw markup for a specific output format.

§Examples

let src = concat!(
    "```=html\n",
    "<tag>x</tag>\n",
    "```\n",
);
let events: Vec<_> = Parser::new(src).collect();
assert_eq!(
    &events,
    &[
        Event::Start(
            Container::RawBlock { format: "html".into() },
            Attributes::new(),
        ),
        Event::Str("<tag>x</tag>".into()),
        Event::End(Container::RawBlock { format: "html".into() }),
    ],
);
let html = "<tag>x</tag>\n";
assert_eq!(&html::render_to_string(events.into_iter()), html);

Fields

§format: Cow<'s, str>
§

CodeBlock

A block with code in a specific language.

§Examples

let src = concat!(
    "```html\n",
    "<tag>x</tag>\n",
    "```\n",
);
let events: Vec<_> = Parser::new(src).collect();
assert_eq!(
    &events,
    &[
        Event::Start(
            Container::CodeBlock { language: "html".into() },
            Attributes::new(),
        ),
        Event::Str("<tag>x</tag>\n".into()),
        Event::End(Container::CodeBlock { language: "html".into() }),
    ],
);
let html = concat!(
    "<pre><code class=\"language-html\">&lt;tag&gt;x&lt;/tag&gt;\n",
    "</code></pre>\n",
);
assert_eq!(&html::render_to_string(events.into_iter()), html);

Fields

§language: Cow<'s, str>
§

Span

An inline divider element.

§Examples

Can be used to add attributes:

let src = concat!(
    "word{#a}\n",
    "[two words]{#b}\n",
);
let events: Vec<_> = Parser::new(src).collect();
assert_eq!(
    &events,
    &[
        Event::Start(Container::Paragraph, Attributes::new()),
        Event::Start(
            Container::Span,
            [(AttributeKind::Id, "a".into())].into_iter().collect(),
        ),
        Event::Str("word".into()),
        Event::End(Container::Span),
        Event::Softbreak,
        Event::Start(
            Container::Span,
            [(AttributeKind::Id, "b".into())].into_iter().collect(),
        ),
        Event::Str("two words".into()),
        Event::End(Container::Span),
        Event::End(Container::Paragraph),
    ],
);
let html = concat!(
    "<p><span id=\"a\">word</span>\n",
    "<span id=\"b\">two words</span></p>\n",
);
assert_eq!(&html::render_to_string(events.into_iter()), html);

An inline link, the first field is either a destination URL or an unresolved tag.

§Examples

URLs or email addresses can be enclosed with angled brackets to create a hyperlink:

let src = concat!(
    "<https://example.com>\n",
    "<me@example.com>\n",
);
let events: Vec<_> = Parser::new(src).collect();
assert_eq!(
    &events,
    &[
        Event::Start(Container::Paragraph, Attributes::new()),
        Event::Start(
            Container::Link(
                "https://example.com".into(),
                LinkType::AutoLink,
            ),
            Attributes::new(),
        ),
        Event::Str("https://example.com".into()),
        Event::End(Container::Link(
            "https://example.com".into(),
            LinkType::AutoLink,
        )),
        Event::Softbreak,
        Event::Start(
            Container::Link(
                "me@example.com".into(),
                LinkType::Email,
            ),
            Attributes::new(),
        ),
        Event::Str("me@example.com".into()),
        Event::End(Container::Link(
            "me@example.com".into(),
            LinkType::Email,
        )),
        Event::End(Container::Paragraph),
    ],
);
let html = concat!(
    "<p><a href=\"https://example.com\">https://example.com</a>\n",
    "<a href=\"mailto:me@example.com\">me@example.com</a></p>\n",
);
assert_eq!(&html::render_to_string(events.into_iter()), html);

Anchor text and the URL can be specified inline:

let src = "[anchor](url)\n";
let events: Vec<_> = Parser::new(src).collect();
assert_eq!(
    &events,
    &[
        Event::Start(Container::Paragraph, Attributes::new()),
        Event::Start(
            Container::Link(
                "url".into(),
                LinkType::Span(SpanLinkType::Inline),
            ),
            Attributes::new(),
        ),
        Event::Str("anchor".into()),
        Event::End(
            Container::Link("url".into(),
            LinkType::Span(SpanLinkType::Inline)),
        ),
        Event::End(Container::Paragraph),
    ],
);
let html = "<p><a href=\"url\">anchor</a></p>\n";
assert_eq!(&html::render_to_string(events.into_iter()), html);

Alternatively, the URL can be retrieved from a link definition using hard brackets, if it exists:

let src = concat!(
    "[a][label]\n",
    "[b][non-existent]\n",
    "\n",
    "[label]: url\n",
);
let events: Vec<_> = Parser::new(src).collect();
assert_eq!(
    &events,
    &[
        Event::Start(Container::Paragraph, Attributes::new()),
        Event::Start(
            Container::Link(
                "url".into(),
                LinkType::Span(SpanLinkType::Reference),
            ),
            Attributes::new(),
        ),
        Event::Str("a".into()),
        Event::End(
            Container::Link("url".into(),
            LinkType::Span(SpanLinkType::Reference)),
        ),
        Event::Softbreak,
        Event::Start(
            Container::Link(
                "non-existent".into(),
                LinkType::Span(SpanLinkType::Unresolved),
            ),
            Attributes::new(),
        ),
        Event::Str("b".into()),
        Event::End(
            Container::Link("non-existent".into(),
            LinkType::Span(SpanLinkType::Unresolved)),
        ),
        Event::End(Container::Paragraph),
        Event::Blankline,
        Event::Start(
            Container::LinkDefinition { label: "label".into() },
            Attributes::new(),
        ),
        Event::Str("url".into()),
        Event::End(Container::LinkDefinition { label: "label".into() }),
    ],
);
let html = concat!(
    "<p><a href=\"url\">a</a>\n",
    "<a>b</a></p>\n",
);
assert_eq!(&html::render_to_string(events.into_iter()), html);
§

Image(Cow<'s, str>, SpanLinkType)

An inline image, the first field is either a destination URL or an unresolved tag.

§Examples

Inner Str objects compose the alternative text:

let src = "![alt text](img.png)";
let events: Vec<_> = Parser::new(src).collect();
assert_eq!(
    &events,
    &[
        Event::Start(Container::Paragraph, Attributes::new()),
        Event::Start(
            Container::Image("img.png".into(), SpanLinkType::Inline),
            Attributes::new(),
        ),
        Event::Str("alt text".into()),
        Event::End(
            Container::Image("img.png".into(), SpanLinkType::Inline),
        ),
        Event::End(Container::Paragraph),
    ],
);
let html = "<p><img alt=\"alt text\" src=\"img.png\"></p>\n";
assert_eq!(&html::render_to_string(events.into_iter()), html);
§

Verbatim

An inline verbatim string.

§Examples

let src = "inline `verbatim`";
let events: Vec<_> = Parser::new(src).collect();
assert_eq!(
    &events,
    &[
        Event::Start(Container::Paragraph, Attributes::new()),
        Event::Str("inline ".into()),
        Event::Start(Container::Verbatim, Attributes::new()),
        Event::Str("verbatim".into()),
        Event::End(Container::Verbatim),
        Event::End(Container::Paragraph),
    ],
);
let html = "<p>inline <code>verbatim</code></p>\n";
assert_eq!(&html::render_to_string(events.into_iter()), html);
§

Math

An inline or display math element.

§Examples

let src = concat!(
    "inline $`a\\cdot{}b` or\n",
    "display $$`\\frac{a}{b}`\n",
);
let events: Vec<_> = Parser::new(src).collect();
assert_eq!(
    &events,
    &[
        Event::Start(Container::Paragraph, Attributes::new()),
        Event::Str("inline ".into()),
        Event::Start(
            Container::Math { display: false },
            Attributes::new(),
        ),
        Event::Str(r"a\cdot{}b".into()),
        Event::End(Container::Math { display: false }),
        Event::Str(" or".into()),
        Event::Softbreak,
        Event::Str("display ".into()),
        Event::Start(
            Container::Math { display: true },
            Attributes::new(),
        ),
        Event::Str(r"\frac{a}{b}".into()),
        Event::End(Container::Math { display: true }),
        Event::End(Container::Paragraph),
    ],
);
let html = concat!(
    "<p>inline <span class=\"math inline\">\\(a\\cdot{}b\\)</span> or\n",
    "display <span class=\"math display\">\\[\\frac{a}{b}\\]</span></p>\n",
);
assert_eq!(&html::render_to_string(events.into_iter()), html);

Fields

§display: bool
§

RawInline

Inline raw markup for a specific output format.

§Examples

let src = "`<tag>a</tag>`{=html}";
let events: Vec<_> = Parser::new(src).collect();
assert_eq!(
    &events,
    &[
        Event::Start(Container::Paragraph, Attributes::new()),
        Event::Start(
            Container::RawInline { format: "html".into() }, Attributes::new(),
        ),
        Event::Str("<tag>a</tag>".into()),
        Event::End(Container::RawInline { format: "html".into() }),
        Event::End(Container::Paragraph),
    ],
);
let html = "<p><tag>a</tag></p>\n";
assert_eq!(&html::render_to_string(events.into_iter()), html);

Fields

§format: Cow<'s, str>
§

Subscript

A subscripted element.

§Examples

let src = "~SUB~";
let events: Vec<_> = Parser::new(src).collect();
assert_eq!(
    &events,
    &[
        Event::Start(Container::Paragraph, Attributes::new()),
        Event::Start(Container::Subscript, Attributes::new()),
        Event::Str("SUB".into()),
        Event::End(Container::Subscript),
        Event::End(Container::Paragraph),
    ],
);
let html = "<p><sub>SUB</sub></p>\n";
assert_eq!(&html::render_to_string(events.into_iter()), html);
§

Superscript

A superscripted element.

§Examples

let src = "^SUP^";
let events: Vec<_> = Parser::new(src).collect();
assert_eq!(
    &events,
    &[
        Event::Start(Container::Paragraph, Attributes::new()),
        Event::Start(Container::Superscript, Attributes::new()),
        Event::Str("SUP".into()),
        Event::End(Container::Superscript),
        Event::End(Container::Paragraph),
    ],
);
let html = "<p><sup>SUP</sup></p>\n";
assert_eq!(&html::render_to_string(events.into_iter()), html);
§

Insert

An inserted inline element.

§Examples

let src = "{+INS+}";
let events: Vec<_> = Parser::new(src).collect();
assert_eq!(
    &events,
    &[
        Event::Start(Container::Paragraph, Attributes::new()),
        Event::Start(Container::Insert, Attributes::new()),
        Event::Str("INS".into()),
        Event::End(Container::Insert),
        Event::End(Container::Paragraph),
    ],
);
let html = "<p><ins>INS</ins></p>\n";
assert_eq!(&html::render_to_string(events.into_iter()), html);
§

Delete

A deleted inline element.

§Examples

let src = "{-DEL-}";
let events: Vec<_> = Parser::new(src).collect();
assert_eq!(
    &events,
    &[
        Event::Start(Container::Paragraph, Attributes::new()),
        Event::Start(Container::Delete, Attributes::new()),
        Event::Str("DEL".into()),
        Event::End(Container::Delete),
        Event::End(Container::Paragraph),
    ],
);
let html = "<p><del>DEL</del></p>\n";
assert_eq!(&html::render_to_string(events.into_iter()), html);
§

Strong

An inline element emphasized with a bold typeface.

§Examples

let src = "*STRONG*";
let events: Vec<_> = Parser::new(src).collect();
assert_eq!(
    &events,
    &[
        Event::Start(Container::Paragraph, Attributes::new()),
        Event::Start(Container::Strong, Attributes::new()),
        Event::Str("STRONG".into()),
        Event::End(Container::Strong),
        Event::End(Container::Paragraph),
    ],
);
let html = "<p><strong>STRONG</strong></p>\n";
assert_eq!(&html::render_to_string(events.into_iter()), html);
§

Emphasis

An emphasized inline element.

§Examples

let src = "_EM_";
let events: Vec<_> = Parser::new(src).collect();
assert_eq!(
    &events,
    &[
        Event::Start(Container::Paragraph, Attributes::new()),
        Event::Start(Container::Emphasis, Attributes::new()),
        Event::Str("EM".into()),
        Event::End(Container::Emphasis),
        Event::End(Container::Paragraph),
    ],
);
let html = "<p><em>EM</em></p>\n";
assert_eq!(&html::render_to_string(events.into_iter()), html);
§

Mark

A highlighted inline element.

§Examples

let src = "{=MARK=}";
let events: Vec<_> = Parser::new(src).collect();
assert_eq!(
    &events,
    &[
        Event::Start(Container::Paragraph, Attributes::new()),
        Event::Start(Container::Mark, Attributes::new()),
        Event::Str("MARK".into()),
        Event::End(Container::Mark),
        Event::End(Container::Paragraph),
    ],
);
let html = "<p><mark>MARK</mark></p>\n";
assert_eq!(&html::render_to_string(events.into_iter()), html);

Implementations§

Source§

impl Container<'_>

Source

pub fn is_block(&self) -> bool

Is a block element.

Source

pub fn is_block_container(&self) -> bool

Is a block element that may contain children blocks.

Trait Implementations§

Source§

impl<'s> Clone for Container<'s>

Source§

fn clone(&self) -> Container<'s>

Returns a duplicate of the value. Read more
1.0.0 · Source§

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

Performs copy-assignment from source. Read more
Source§

impl<'s> Debug for Container<'s>

Source§

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

Formats the value using the given formatter. Read more
Source§

impl<'s> PartialEq for Container<'s>

Source§

fn eq(&self, other: &Container<'s>) -> bool

Tests for self and other values to be equal, and is used by ==.
1.0.0 · Source§

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

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

impl<'s> Eq for Container<'s>

Source§

impl<'s> StructuralPartialEq for Container<'s>

Auto Trait Implementations§

§

impl<'s> Freeze for Container<'s>

§

impl<'s> RefUnwindSafe for Container<'s>

§

impl<'s> Send for Container<'s>

§

impl<'s> Sync for Container<'s>

§

impl<'s> Unpin for Container<'s>

§

impl<'s> UnwindSafe for Container<'s>

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.