Extract content parser state to its own module

src/syntax/content/parser/context.rs

@@ -1,5 +1,5 @@
 use crate::syntax::content::parser::{
-    State,
+    state::State,
     token::{Token, paragraph::Paragraph, preformat::PreFormat},
 };
 

src/syntax/content/parser/context/anchor.rs

@@ -1,19 +1,17 @@
 use crate::{
     prelude::*,
     syntax::content::parser::{
-        State, context::Inline, lexeme::Lexeme, token::Token,
+        state::State, context::Inline, lexeme::Lexeme, token::Token,
     },
 };
 
 /// Handles open anchor contexts until an anchor token is fully parsed.
 ///
-/// This function is only called if the current inline context is Anchor.
-///
 /// A return of `true` will trigger a continue in the outer parser,
 /// skipping any further parsing of the current lexeme.
 ///
 /// # Panics
-/// This function will panic if can't determine the destination of an anchor.
+/// If it can't determine the destination of an anchor.
 pub fn parse(
     lexeme: &Lexeme,
     state: &mut State,

src/syntax/content/parser/state.rs

@@ -0,0 +1,76 @@
+use std::collections::{HashMap};
+
+use crate::syntax::content::parser::{
+    token::{anchor::Anchor},
+    context::{Context, Block, Inline},
+};
+
+#[derive(Clone, Debug)]
+pub struct State {
+    pub context: Context,
+    pub dom_ids: HashMap<String, Vec<String>>,
+    pub buffers: Buffers,
+}
+
+#[derive(Clone, Debug)]
+pub struct Buffers {
+    pub anchor: AnchorBuffer,
+}
+
+#[derive(Clone, Debug)]
+pub struct AnchorBuffer {
+    pub candidate: Anchor,
+    pub text: String,
+    pub destination: String,
+}
+
+impl AnchorBuffer {
+    pub fn clear(&mut self) {
+        self.candidate = Anchor::default();
+        self.text = String::new();
+        self.destination = String::new();
+    }
+}
+
+impl std::fmt::Display for AnchorBuffer {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        let display_text = if self.text.is_empty() {
+            String::new()
+        } else {
+            format!("text: {:?}", self.text)
+        };
+        let display_destination = if self.destination.is_empty() {
+            String::new()
+        } else {
+            format!(", dest: {:?}", self.destination)
+        };
+
+        let display_text_and_destination =
+            format!("{display_text}{display_destination}");
+
+        write!(
+            f,
+            "AnchorBuffer [{display_text_and_destination}] >> {}",
+            self.candidate,
+        )
+    }
+}
+
+impl State {
+    pub fn new() -> State {
+        State {
+            context: Context {
+                inline: Inline::None,
+                block: Block::None,
+            },
+            dom_ids: HashMap::new(),
+            buffers: Buffers {
+                anchor: AnchorBuffer {
+                    candidate: Anchor::default(),
+                    text: String::new(),
+                    destination: String::new(),
+                },
+            },
+        }
+    }
+}

src/syntax/content/parser/token/anchor.rs

@@ -45,12 +45,14 @@ impl std::fmt::Display for Anchor {
         use crate::dev::wrap;
 
         let display_destination = match self.destination {
-            Some(ref destination) => { if destination.is_empty() {
-                "<empty>"
-            } else {
-                destination
-            }},
-            None => "<unknown>"
+            Some(ref destination) => {
+                if destination.is_empty() {
+                    "<empty>"
+                } else {
+                    destination
+                }
+            },
+            None => "<unknown>",
         };
 
         let mut tail = String::new();

src/syntax/content/parser/token/header.rs

@@ -122,7 +122,7 @@ impl std::fmt::Display for Header {
 
         let display_dom_id = match self.dom_id {
             Some(ref dom_id) => format!(" DOM ID {dom_id}"),
-            None => String::new()
+            None => String::new(),
         };
 
         write!(

src/syntax/content/parser/token/paragraph.rs

@@ -43,8 +43,14 @@ impl Parseable for Paragraph {
 impl std::fmt::Display for Paragraph {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         let display_open_state = match self.open {
-            Some(open_state) => { if open_state { "open" } else { "closed" } },
-            None => "unknown"
+            Some(open_state) => {
+                if open_state {
+                    "open"
+                } else {
+                    "closed"
+                }
+            },
+            None => "unknown",
         };
         write!(f, "Paragraph [{display_open_state}]")
     }

src/syntax/content/parser/token/span.rs

@@ -38,8 +38,13 @@ impl std::fmt::Display for Span {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         let display_open_state = match self.open {
             Some(ref open_state) => {
-            if *open_state { "open" } else { "closed" }},
-                None => "unknown"
+                if *open_state {
+                    "open"
+                } else {
+                    "closed"
+                }
+            },
+            None => "unknown",
         };
         write!(f, "Span [{display_open_state}]")
     }