Struct Session 

pub struct Session {
    pub title: TextContent,
    pub marker: Option<SequenceMarker>,
    pub children: SessionContainer,
    pub annotations: Vec<Annotation>,
    pub location: Range,
}

A session represents a hierarchical container with a title

Fields

title: TextContent

marker: Option<SequenceMarker>

children: SessionContainer

annotations: Vec<Annotation>

location: Range

Implementations

impl Session

pub fn new(title: TextContent, children: Vec<SessionContent>) -> Self

pub fn with_title(title: String) -> Self

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

Preferred builder

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

Annotations attached to this session header/content block.

pub fn header_location(&self) -> Option<&Range>

Range covering only the session title line, if available.

pub fn body_location(&self) -> Option<Range>

Bounding range covering only the session’s children.

pub fn title_text(&self) -> &str

Get the title text without the sequence marker

Returns the title with any leading sequence marker removed. For example, “1. Introduction” becomes “Introduction”.

Examples

let session = parse_session("1. Introduction:\n\n    Content");
assert_eq!(session.title_text(), "Introduction");

pub fn full_title(&self) -> &str

Get the full title including any sequence marker

Returns the complete title as it appears in the source, including any sequence marker prefix.

Examples

let session = parse_session("1. Introduction:\n\n    Content");
assert_eq!(session.full_title(), "1. Introduction");

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

Mutable access to session annotations.

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

Iterate over annotation blocks in source order.

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

Iterate over all content items nested inside attached annotations.

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

Iterate over immediate content items

pub fn iter_paragraphs(&self) -> impl Iterator<Item = &Paragraph>

Iterate over immediate paragraph children

pub fn iter_sessions(&self) -> impl Iterator<Item = &Session>

Iterate over immediate session children

pub fn iter_lists(&self) -> impl Iterator<Item = &List>

Iterate over immediate list children

pub fn iter_verbatim_blocks(&self) -> impl Iterator<Item = &Verbatim>

Iterate over immediate verbatim block children

pub fn iter_all_nodes(&self) -> Box<dyn Iterator<Item = &ContentItem> + '_>

Iterate all nodes in the session tree (depth-first pre-order traversal)

pub fn iter_all_nodes_with_depth( &self, ) -> Box<dyn Iterator<Item = (&ContentItem, usize)> + '_>

Iterate all nodes with their depth (0 = immediate children)

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

Recursively iterate all paragraphs at any depth

pub fn iter_sessions_recursive(&self) -> Box<dyn Iterator<Item = &Session> + '_>

Recursively iterate all sessions at any depth

pub fn iter_lists_recursive(&self) -> Box<dyn Iterator<Item = &List> + '_>

Recursively iterate all lists at any depth

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

Recursively iterate all verbatim blocks at any depth

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

Recursively iterate all list items at any depth

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

Recursively iterate all definitions at any depth

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

Recursively iterate all annotations at any depth

pub fn first_paragraph(&self) -> Option<&Paragraph>

Get the first paragraph (returns None if not found)

pub fn first_session(&self) -> Option<&Session>

Get the first session (returns None if not found)

pub fn first_list(&self) -> Option<&List>

Get the first list (returns None if not found)

pub fn first_definition(&self) -> Option<&Definition>

Get the first definition (returns None if not found)

pub fn first_annotation(&self) -> Option<&Annotation>

Get the first annotation (returns None if not found)

pub fn first_verbatim(&self) -> Option<&Verbatim>

Get the first verbatim block (returns None if not found)

pub fn expect_paragraph(&self) -> &Paragraph

Get the first paragraph, panicking if none found

pub fn expect_session(&self) -> &Session

Get the first session, panicking if none found

pub fn expect_list(&self) -> &List

Get the first list, panicking if none found

pub fn expect_definition(&self) -> &Definition

Get the first definition, panicking if none found

pub fn expect_annotation(&self) -> &Annotation

Get the first annotation, panicking if none found

pub fn expect_verbatim(&self) -> &Verbatim

Get the first verbatim block, panicking if none found

pub fn find_paragraphs<F>(&self, predicate: F) -> Vec<&Paragraph>

where F: Fn(&Paragraph) -> bool,

Find all paragraphs matching a predicate

pub fn find_sessions<F>(&self, predicate: F) -> Vec<&Session>

where F: Fn(&Session) -> bool,

Find all sessions matching a predicate

pub fn find_lists<F>(&self, predicate: F) -> Vec<&List>

where F: Fn(&List) -> bool,

Find all lists matching a predicate

pub fn find_definitions<F>(&self, predicate: F) -> Vec<&Definition>

where F: Fn(&Definition) -> bool,

Find all definitions matching a predicate

pub fn find_annotations<F>(&self, predicate: F) -> Vec<&Annotation>

where F: Fn(&Annotation) -> bool,

Find all annotations matching a predicate

pub fn find_nodes<F>(&self, predicate: F) -> Vec<&ContentItem>

where F: Fn(&ContentItem) -> bool,

Find all nodes matching a generic predicate

pub fn find_nodes_at_depth(&self, target_depth: usize) -> Vec<&ContentItem>

Find all nodes at a specific depth

pub fn find_nodes_in_depth_range( &self, min_depth: usize, max_depth: usize, ) -> Vec<&ContentItem>

Find all nodes within a depth range

pub fn find_nodes_with_depth<F>( &self, target_depth: usize, predicate: F, ) -> Vec<&ContentItem>

where F: Fn(&ContentItem) -> bool,

Find nodes at a specific depth matching a predicate

pub fn count_by_type(&self) -> (usize, usize, usize, usize)

Count immediate children by type

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 find_nodes_at_position(&self, position: Position) -> Vec<&dyn AstNode>

Returns the deepest AST node at the given position, if any

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

Returns the path of nodes at the given position, starting from this session

pub fn format_at_position(&self, position: Position) -> String

Formats information about nodes located at a given position

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 session 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) = session.find_annotation_by_label("42") {
    // Jump to this annotation in go-to-definition
}

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 session tree. Multiple annotations might share the same label.

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 = session.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 session tree, parses inline content, and yields all reference inline nodes (e.g., [42], [@citation], [^note]).

Note: This method does not currently return source ranges for individual references. Use the paragraph’s location as a starting point for finding references in the source.

Returns

An iterator of references to ReferenceInline nodes

Example

for reference in session.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 = session.find_references_to("42");
println!("Found {} references to footnote 42", refs.len());

impl Session

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

Find all links at any depth in this session

This searches recursively through all content to find:

• URL references: [https://example.com]
• File references: [./path/to/file.txt]
• Verbatim src parameters: src=./image.png

Returns

Vector of all links found in this session and its descendants

Example

let links = session.find_all_links();
for link in links {
    println!("Found {} link: {}", link.link_type, link.target);
}

Trait Implementations

impl AstNode for Session

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 Session

fn clone(&self) -> Session

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Container for Session

fn label(&self) -> &str

fn children(&self) -> &[ContentItem]

fn children_mut(&mut self) -> &mut Vec<ContentItem>

impl Debug for Session

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

Formats the value using the given formatter.

impl Display for Session

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

Formats the value using the given formatter.

impl PartialEq for Session

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

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

Execute this transformation on the input

impl Runnable<Session, Session> for ParseInlines

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

Execute this transformation on the input

impl VisualStructure for Session

fn is_source_line_node(&self) -> bool

Whether this node corresponds to a line in the source document

fn has_visual_header(&self) -> bool

Whether this node has a visual header line separate from its content

fn collapses_with_children(&self) -> bool

Whether this is a homogeneous container whose children can collapse with parent icon

impl StructuralPartialEq for Session