pub enum Node {
Show 17 variants
Heading {
level: u8,
text: String,
},
Paragraph {
text: String,
},
CheckboxItem {
checked: bool,
text: String,
},
ListItem {
ordered: bool,
number: u64,
first_in_list: bool,
text: String,
level: u8,
marker: Option<String>,
location: Option<[u16; 4]>,
dclx: Option<ListItemDclx>,
href: Option<String>,
layer: Option<ContentLayer>,
},
Code {
language: Option<String>,
text: String,
},
Table(Table),
Picture {
caption: Option<String>,
image: Option<PictureImage>,
},
Chart {
kind: String,
table: Table,
},
Group {
label: String,
children: Vec<Node>,
},
FieldRegion {
items: Vec<FieldItem>,
},
InlineGroup {
unwrapped: bool,
runs: Vec<InlineRun>,
md_text: String,
},
Furniture {
layer: ContentLayer,
inner: Box<Node>,
},
Located {
location: [u16; 4],
inner: Box<Node>,
},
PageFurniture {
footer: bool,
location: [u16; 4],
text: String,
},
PageBreak,
DoclangOnly(Box<Node>),
TextDump(String),
}Expand description
A single piece of document content.
Variants§
Heading
A heading. level is 1-6.
Paragraph
A run of body text.
CheckboxItem
A form checkbox (docling’s checkbox_selected/checkbox_unselected): its
clean label text with the checked state. DocLang emits a <checkbox>
element head; Markdown/JSON render the task-list form (- [x] /- [ ] ).
ListItem
A single list item at the given nesting level (0 = top). For ordered
items, number is the display number (honoring the list’s start); it
is unused for unordered items. first_in_list marks the first item of a
list so the serializer can blank-line-separate adjacent sibling lists.
marker is the DocLang enumeration marker ("1.", "1.1.", …) when the
backend provides one — HTML and DOCX set it for enumerated items, so
DocLang emits <ldiv><marker>…</marker></ldiv>; Markdown and the other
declarative backends leave it None, giving a bare <ldiv/> (matching
docling, whose Markdown backend passes no marker).
Fields
location: Option<[u16; 4]>Optional layout provenance (x0,y0,x1,y1, normalized to 0–511): the
four DocLang <location> values emitted inside the <list> right
after the item’s <ldiv>. Set only by backends with real geometry
(e.g. PPTX shapes); None for the declarative backends. Kept on the
item itself (rather than a Node::Located wrapper) so consecutive
items still group into one <list>.
dclx: Option<ListItemDclx>DocLang-only override for items whose DocLang form diverges from their
flat Markdown text. Markdown/JSON always render the fields above; the
DocLang serializer, when this is Some, takes the list kind, marker,
and content from here instead. Used for docx multilevel numbering
(Markdown shows - 1.1. x, DocLang an ordered <marker>1.1.</marker>
with clean text) and inline equations/formatting in list items.
href: Option<String>The item’s hyperlink target, when its content is a link — docling’s
HTML backend emits it as an <href uri=…/> in the item head, and the
anchor’s Markdown link markup is stripped from the rendered content.
None for a plain item; ignored by Markdown/JSON.
layer: Option<ContentLayer>Non-body content layer (docling’s HTML site chrome before the first
heading → furniture). DocLang emits a <layer value=…/> in the item
head; Markdown/JSON drop a non-body item entirely.
Code
A fenced code block.
Table(Table)
A table. The first row is treated as the header.
Picture
A picture/figure, with an optional caption and (when a backend extracts it) the embedded image itself.
Chart
A chart (docling’s PictureItem classified as a chart, carrying a
PictureTabularChartData annotation). Markdown and JSON render it exactly
like a Node::Picture placeholder (an <!-- image --> / picture
item); the DocLang serializer emits <picture class="chart"> with a
<label value="{kind}"/> and the data table as a <tabular>.
Fields
Group
A logical grouping of child nodes (e.g. a list, a section).
FieldRegion
A form key-value region (docling’s field_region): a set of form fields,
each pairing an optional marker, key, and value. Backends detect these
from form structure (e.g. HTML’s keyN / keyN_valueM / keyN_marker
id-convention); the serializers render each item’s parts as separate
labelled texts (marker / field_key / field_value).
InlineGroup
Rich inline content — docling’s InlineGroup: a run of styled text
segments that a backend captured with formatting (<bold>, <italic>,
<underline>, <strikethrough>, sub/superscript, inline <code>) the
flat Markdown text cannot represent. Markdown/JSON render this exactly
like Paragraph { text: md_text } (so their output is unchanged); the
DocLang serializer uses the structured runs. unwrapped is set when the
group’s docling parent is a heading/text (no enclosing <text> wrapper).
Furniture
A node in a non-body content layer — furniture (page headers/footers,
the HTML <title>, site navigation/chrome) or notes (docx comments).
Markdown and JSON omit these layers by default; DocLang renders the wrapped
node with a <layer value="{layer}"/> head.
Located
A node carrying layout provenance — the four DocLang <location> values
(x0,y0,x1,y1, normalized to 0–511) docling attaches to elements from
backends with real geometry (e.g. the slide shapes in PPTX). Markdown and
JSON render the wrapped node unchanged; DocLang emits the <location>
tokens as the element’s first children.
PageFurniture
A PDF page header or footer (docling’s page_header/page_footer
furniture): DocLang emits <page_header>/<page_footer> with a
<layer value="furniture"/> head, the four <location> tokens, then the
text. Markdown and JSON omit it like other furniture.
PageBreak
A page boundary — docling’s implicit page break between pages. The PPTX
backend emits one between consecutive slides. DocLang renders it as
<page_break/>; Markdown and JSON omit it (matching docling’s default
exports, which carry page breaks only in the document model).
DoclangOnly(Box<Node>)
A node docling keeps in the document model (and DocLang) but leaves out
of the Markdown and JSON exports — e.g. an ODF presentation’s pictures
and charts, which appear in the .dclx body but not in its .md/.json.
DocLang renders the wrapped node in place; Markdown and JSON skip it.
TextDump(String)
A verbatim plain-text dump — docling’s plain-text backend emits the whole
file as a single text item (used for legacy USPTO APS .txt grants, which
docling routes to plain text rather than its APS parser). The stored string
is the file body, one record per line. Markdown/JSON render it as one text
block; the DocLang serializer reproduces minidom’s per-line layout, CDATA-
escaping only the lines that need it (see emit_text_dump).