Struct Document 

pub struct Document {
    pub annotations: Vec<Annotation>,
    pub title: Option<DocumentTitle>,
    pub root: Session,
}

Fields

annotations: Vec<Annotation>

title: Option<DocumentTitle>

root: Session

Implementations

impl Document

pub fn diagnostics(&self) -> Vec<Diagnostic>

Get all diagnostics for this document

This collects diagnostics from various validation checks:

• Broken references (footnotes, citations, session links)
• Malformed structures (single-item lists, etc.)
• Invalid annotation syntax

Example

let doc = parse_document(source)?;
let diagnostics = doc.diagnostics();
for diag in diagnostics {
    eprintln!("{}", diag);
}

impl Document

pub fn new() -> Self

pub fn with_content(content: Vec<ContentItem>) -> Self

pub fn from_root(root: Session) -> Self

Construct a document from an existing root session.

pub fn from_title_and_root(title: Option<DocumentTitle>, root: Session) -> Self

Construct a document from a title and root session.

pub fn with_annotations_and_content( annotations: Vec<Annotation>, content: Vec<ContentItem>, ) -> Self

pub fn with_root_location(self, location: Range) -> Self

pub fn root_session(&self) -> &Session

pub fn root_session_mut(&mut self) -> &mut Session

pub fn into_root(self) -> Session

pub fn title(&self) -> &str

Get the document title text.

Returns the title string if a DocumentTitle is present, empty string otherwise.

pub fn set_title(&mut self, title: String)

Set the document title.

pub fn node_path_at_position(&self, pos: Position) -> Vec<&dyn AstNode>

Returns the path of nodes at the given position, starting from the document

pub fn element_at(&self, pos: Position) -> Option<&ContentItem>

Returns the deepest (most nested) element that contains the position

pub fn visual_line_at(&self, pos: Position) -> Option<&ContentItem>

Returns the visual line element at the given position

pub fn block_element_at(&self, pos: Position) -> Option<&ContentItem>

Returns the block element at the given position

pub fn annotations(&self) -> &[Annotation]

All annotations attached directly to the document (document-level metadata).

pub fn annotations_mut(&mut self) -> &mut Vec<Annotation>

Mutable access to document-level annotations.

pub fn iter_annotations(&self) -> Iter<'_, Annotation>

Iterate over document-level annotation blocks in source order.

pub fn iter_annotation_contents(&self) -> impl Iterator<Item = &ContentItem>

Iterate over all content items nested inside document-level annotations.

pub fn find_annotation_by_label(&self, label: &str) -> Option<&Annotation>

Find the first annotation with a matching label.

This searches recursively through all annotations in the document, including both document-level annotations and annotations in the content tree.

Arguments

• label - The label string to search for

Returns

The first annotation whose label matches exactly, or None if not found.

Example

// Find annotation with label "42" for reference [42]
if let Some(annotation) = document.find_annotation_by_label("42") {
    // Jump to this annotation in go-to-definition
}

pub fn find_annotation_by_label_in_origin( &self, label: &str, origin: Option<&Path>, ) -> Option<&Annotation>

Find the first annotation with label whose Range.origin_path matches origin.

Used after include resolution so that footnote references like [1] scope to the file they were authored in: a [1] in chapter.lex finds :: 1 :: defined in chapter.lex and not in some other included file that happens to also have a :: 1 ::. The reference’s origin is the Range.origin_path of the inline’s containing node (paragraph / session title / etc.).

Unlike Document::find_annotation_by_label, this walker checks both standalone annotations (children of containers) and attached annotations (those moved into a node’s .annotations field by AttachAnnotations). The bare find_annotation_by_label only sees standalone ones, which is fine for an unresolved tree (annotations live in children pre-attachment) but misses footnote definitions in any tree that has been through the parser’s attachment phase. After include resolution every annotation has either form, so the more thorough walker is the right one.

find_annotation_by_label (without origin filter) remains the right call when origin filtering is not needed and the caller knows annotations have not been attached.

pub fn find_annotations_by_label(&self, label: &str) -> Vec<&Annotation>

Find all annotations with a matching label.

This searches recursively through all annotations in the document, including both document-level annotations and annotations in the content tree.

Arguments

• label - The label string to search for

Returns

A vector of all annotations whose labels match exactly.

Example

// Find all annotations labeled "note"
let notes = document.find_annotations_by_label("note");
for note in notes {
    // Process each note annotation
}

pub fn iter_all_references( &self, ) -> Box<dyn Iterator<Item = ReferenceInline> + '_>

Iterate all inline references at any depth.

This method recursively walks the document tree, parses inline content, and yields all reference inline nodes (e.g., [42], [@citation], [::note]).

Returns

An iterator of references to ReferenceInline nodes

Example

for reference in document.iter_all_references() {
    match &reference.reference_type {
        ReferenceType::FootnoteNumber { number } => {
            // Find annotation with this number
        }
        ReferenceType::Citation(data) => {
            // Process citation
        }
        _ => {}
    }
}

pub fn find_references_to(&self, target: &str) -> Vec<ReferenceInline>

Find all references to a specific target label.

This method searches for inline references that point to the given target. For example, find all [42] references when looking for footnote “42”.

Arguments

• target - The target label to search for

Returns

A vector of references to ReferenceInline nodes that match the target

Example

// Find all references to footnote "42"
let refs = document.find_references_to("42");
println!("Found {} references to footnote 42", refs.len());

impl Document

pub fn find_all_links(&self) -> Vec<DocumentLink>

Find all links in the entire document

This searches the entire document tree to find all clickable links:

• URL references in text
• File references in text
• Verbatim block src parameters

Returns

Vector of all links found in the document

Example

let doc = parse_document(source)?;
let links = doc.find_all_links();
for link in links {
    // Make link clickable in LSP
    send_document_link(link.range, link.target);
}

Trait Implementations

impl AstNode for Document

fn node_type(&self) -> &'static str

fn display_label(&self) -> String

fn range(&self) -> &Range

fn accept(&self, visitor: &mut dyn Visitor)

Accept a visitor for traversing this node and its children

fn start_position(&self) -> Position

impl Clone for Document

fn clone(&self) -> Document

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Document

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

Formats the value using the given formatter.

impl Default for Document

fn default() -> Self

Returns the “default value” for a type.

impl Display for Document

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

Formats the value using the given formatter.

impl PartialEq for Document

fn eq(&self, other: &Document) -> 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 Runnable<BuildOutput, Document> for AttachRoot

fn run(&self, output: BuildOutput) -> Result<Document, TransformError>

Execute this transformation on the input

impl Runnable<Document, Document> for ApplyTableConfig

fn run(&self, input: Document) -> Result<Document, TransformError>

Execute this transformation on the input

impl Runnable<Document, Document> for AttachAnnotations

fn run(&self, input: Document) -> Result<Document, TransformError>

Execute this transformation on the input

impl StructuralPartialEq for Document