Merge branch 'reduce_pub'

2023-09-11 15:37:33 -04:00 · 2023-09-11 15:37:33 -04:00 · 6589a755a6
commit 6589a755a6
parent a74319d381 a651b79e77
66 changed files with 273 additions and 257 deletions
--- a/build.rs
+++ b/build.rs
@ -74,7 +74,7 @@ fn write_header(test_file: &mut File) {
 use organic::compare_document;
 use organic::parser::parse;
 use organic::emacs_parse_anonymous_org_document;
-use organic::parser::sexp::sexp_with_padding;
+use organic::sexp;

 "#
    )
--- a/src/bin_compare.rs
+++ b/src/bin_compare.rs
@ -10,7 +10,7 @@ use organic::emacs_parse_file_org_document;
 use organic::get_emacs_version;
 use organic::get_org_mode_version;
 use organic::parser::parse_with_settings;
-use organic::parser::sexp::sexp_with_padding;
+use organic::sexp;
 use organic::GlobalSettings;
 use organic::LocalFileAccessInterface;

@ -66,8 +66,7 @@ fn run_anonymous_parse<P: AsRef<str>>(org_contents: P) -> Result<(), Box<dyn std
    eprintln!("Using org-mode version: {}", get_org_mode_version()?.trim());
    let rust_parsed = parse(org_contents)?;
    let org_sexp = emacs_parse_anonymous_org_document(org_contents)?;
-    let (_remaining, parsed_sexp) =
-        sexp_with_padding(org_sexp.as_str()).map_err(|e| e.to_string())?;
+    let (_remaining, parsed_sexp) = sexp(org_sexp.as_str()).map_err(|e| e.to_string())?;

    println!("{}\n\n\n", org_contents);
    println!("{}", org_sexp);
@ -103,8 +102,7 @@ fn run_parse_on_file<P: AsRef<Path>>(org_path: P) -> Result<(), Box<dyn std::err
    };
    let rust_parsed = parse_with_settings(org_contents, &global_settings)?;
    let org_sexp = emacs_parse_file_org_document(org_path)?;
-    let (_remaining, parsed_sexp) =
-        sexp_with_padding(org_sexp.as_str()).map_err(|e| e.to_string())?;
+    let (_remaining, parsed_sexp) = sexp(org_sexp.as_str()).map_err(|e| e.to_string())?;

    println!("{}\n\n\n", org_contents);
    println!("{}", org_sexp);
--- a/src/compare/diff.rs
+++ b/src/compare/diff.rs
@ -1,11 +1,11 @@
 use std::collections::BTreeSet;
 use std::collections::HashSet;

+use super::sexp::unquote;
+use super::sexp::Token;
 use super::util::assert_bounds;
 use super::util::assert_name;
 use super::util::get_property;
-use crate::parser::sexp::unquote;
-use crate::parser::sexp::Token;
 use crate::types::AngleLink;
 use crate::types::Bold;
 use crate::types::Citation;
@ -86,7 +86,7 @@ pub struct DiffResult<'s> {
 }

 #[derive(Debug, PartialEq)]
-pub enum DiffStatus {
+enum DiffStatus {
    Good,
    Bad,
 }
--- a/src/compare/mod.rs
+++ b/src/compare/mod.rs
@ -1,8 +1,10 @@
 mod diff;
 mod parse;
+mod sexp;
 mod util;
 pub use diff::compare_document;
 pub use parse::emacs_parse_anonymous_org_document;
 pub use parse::emacs_parse_file_org_document;
 pub use parse::get_emacs_version;
 pub use parse::get_org_mode_version;
+pub use sexp::sexp;
--- a/src/compare/sexp.rs
+++ b/src/compare/sexp.rs
@ -16,9 +16,6 @@ use nom::sequence::delimited;
 use nom::sequence::preceded;
 use nom::sequence::tuple;

-use super::org_source::convert_error;
-use super::org_source::OrgSource;
-use super::util::get_consumed;
 use crate::error::Res;

 #[derive(Debug)]
@ -31,8 +28,8 @@ pub enum Token<'s> {

 #[derive(Debug)]
 pub struct TextWithProperties<'s> {
-    pub text: &'s str,
-    pub properties: Vec<Token<'s>>,
+    pub(crate) text: &'s str,
+    pub(crate) properties: Vec<Token<'s>>,
 }

 enum ParseState {
@ -41,35 +38,39 @@ enum ParseState {
 }

 impl<'s> Token<'s> {
-    pub fn as_vector<'p>(&'p self) -> Result<&'p Vec<Token<'s>>, Box<dyn std::error::Error>> {
+    pub(crate) fn as_vector<'p>(
+        &'p self,
+    ) -> Result<&'p Vec<Token<'s>>, Box<dyn std::error::Error>> {
        Ok(match self {
            Token::Vector(children) => Ok(children),
            _ => Err(format!("wrong token type, expected vector: {:?}", self)),
        }?)
    }

-    pub fn as_list<'p>(&'p self) -> Result<&'p Vec<Token<'s>>, Box<dyn std::error::Error>> {
+    pub(crate) fn as_list<'p>(&'p self) -> Result<&'p Vec<Token<'s>>, Box<dyn std::error::Error>> {
        Ok(match self {
            Token::List(children) => Ok(children),
            _ => Err(format!("wrong token type, expected list: {:?}", self)),
        }?)
    }

-    pub fn as_atom<'p>(&'p self) -> Result<&'s str, Box<dyn std::error::Error>> {
+    pub(crate) fn as_atom<'p>(&'p self) -> Result<&'s str, Box<dyn std::error::Error>> {
        Ok(match self {
            Token::Atom(body) => Ok(*body),
            _ => Err(format!("wrong token type, expected atom: {:?}", self)),
        }?)
    }

-    pub fn as_text<'p>(&'p self) -> Result<&'p TextWithProperties<'s>, Box<dyn std::error::Error>> {
+    pub(crate) fn as_text<'p>(
+        &'p self,
+    ) -> Result<&'p TextWithProperties<'s>, Box<dyn std::error::Error>> {
        Ok(match self {
            Token::TextWithProperties(body) => Ok(body),
            _ => Err(format!("wrong token type, expected text: {:?}", self)),
        }?)
    }

-    pub fn as_map<'p>(
+    pub(crate) fn as_map<'p>(
        &'p self,
    ) -> Result<HashMap<&'s str, &'p Token<'s>>, Box<dyn std::error::Error>> {
        let mut hashmap = HashMap::new();
@ -95,7 +96,26 @@ impl<'s> Token<'s> {
    }
 }

-pub fn unquote(text: &str) -> Result<String, Box<dyn std::error::Error>> {
+/// Check if the child string slice is a slice of the parent string slice.
+fn is_slice_of(parent: &str, child: &str) -> bool {
+    let parent_start = parent.as_ptr() as usize;
+    let parent_end = parent_start + parent.len();
+    let child_start = child.as_ptr() as usize;
+    let child_end = child_start + child.len();
+    child_start >= parent_start && child_end <= parent_end
+}
+
+/// Get a slice of the string that was consumed in a parser using the original input to the parser and the remaining input after the parser.
+pub fn get_consumed<'s>(input: &'s str, remaining: &'s str) -> &'s str {
+    assert!(is_slice_of(input, remaining));
+    let source = {
+        let offset = remaining.as_ptr() as usize - input.as_ptr() as usize;
+        &input[..offset]
+    };
+    source.into()
+}
+
+pub(crate) fn unquote(text: &str) -> Result<String, Box<dyn std::error::Error>> {
    let mut out = String::with_capacity(text.len());
    if !text.starts_with(r#"""#) {
        return Err("Quoted text does not start with quote.".into());
@ -132,29 +152,20 @@ pub fn unquote(text: &str) -> Result<String, Box<dyn std::error::Error>> {
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn sexp_with_padding<'s>(input: &'s str) -> Res<&'s str, Token<'s>> {
+pub fn sexp<'s>(input: &'s str) -> Res<&'s str, Token<'s>> {
    let (remaining, _) = multispace0(input)?;
-    let remaining = OrgSource::new(remaining);
-    let (remaining, tkn) = token(remaining)
-        .map(|(rem, out)| (Into::<&str>::into(rem), out))
-        .map_err(convert_error)?;
+    let (remaining, tkn) = token(remaining).map(|(rem, out)| (Into::<&str>::into(rem), out))?;
    let (remaining, _) = multispace0(remaining)?;
    Ok((remaining, tkn))
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn sexp<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, Token<'s>> {
-    let (remaining, tkn) = token(input)?;
-    Ok((remaining, tkn))
-}
-
-#[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-fn token<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, Token<'s>> {
+fn token<'s>(input: &'s str) -> Res<&'s str, Token<'s>> {
    alt((list, vector, atom))(input)
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-fn list<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, Token<'s>> {
+fn list<'s>(input: &'s str) -> Res<&'s str, Token<'s>> {
    let (remaining, _) = tag("(")(input)?;
    let (remaining, children) = delimited(
        multispace0,
@ -166,7 +177,7 @@ fn list<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, Token<'s>> {
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-fn vector<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, Token<'s>> {
+fn vector<'s>(input: &'s str) -> Res<&'s str, Token<'s>> {
    let (remaining, _) = tag("[")(input)?;
    let (remaining, children) = delimited(
        multispace0,
@ -178,7 +189,7 @@ fn vector<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, Token<'s>> {
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-fn atom<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, Token<'s>> {
+fn atom<'s>(input: &'s str) -> Res<&'s str, Token<'s>> {
    not(peek(one_of(")]")))(input)?;
    alt((
        text_with_properties,
@ -189,7 +200,7 @@ fn atom<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, Token<'s>> {
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-fn unquoted_atom<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, Token<'s>> {
+fn unquoted_atom<'s>(input: &'s str) -> Res<&'s str, Token<'s>> {
    let (remaining, body) = take_till1(|c| match c {
        ' ' | '\t' | '\r' | '\n' | ')' | ']' => true,
        _ => false,
@ -198,7 +209,7 @@ fn unquoted_atom<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, Token<'s>> {
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-fn quoted_atom<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, Token<'s>> {
+fn quoted_atom<'s>(input: &'s str) -> Res<&'s str, Token<'s>> {
    let (remaining, _) = tag(r#"""#)(input)?;
    let (remaining, _) = escaped(
        take_till1(|c| match c {
@ -214,7 +225,7 @@ fn quoted_atom<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, Token<'s>> {
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-fn hash_notation<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, Token<'s>> {
+fn hash_notation<'s>(input: &'s str) -> Res<&'s str, Token<'s>> {
    let (remaining, _) = tag("#<")(input)?;
    let (remaining, _body) = take_till1(|c| match c {
        '>' => true,
@ -225,7 +236,7 @@ fn hash_notation<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, Token<'s>> {
    Ok((remaining, Token::Atom(source.into())))
 }

-fn text_with_properties<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, Token<'s>> {
+fn text_with_properties<'s>(input: &'s str) -> Res<&'s str, Token<'s>> {
    let (remaining, _) = tag("#(")(input)?;
    let (remaining, (text, props)) = delimited(
        multispace0,
@ -255,7 +266,7 @@ mod tests {
    #[test]
    fn simple() {
        let input = "  (foo bar baz )  ";
-        let (remaining, parsed) = sexp_with_padding(input).expect("Parse the input");
+        let (remaining, parsed) = sexp(input).expect("Parse the input");
        assert_eq!(remaining, "");
        assert!(match parsed {
            Token::Atom(_) => false,
@ -268,7 +279,7 @@ mod tests {
    #[test]
    fn quoted() {
        let input = r#"  ("foo" bar baz )  "#;
-        let (remaining, parsed) = sexp_with_padding(input).expect("Parse the input");
+        let (remaining, parsed) = sexp(input).expect("Parse the input");
        assert_eq!(remaining, "");
        assert!(match parsed {
            Token::Atom(_) => false,
@ -292,7 +303,7 @@ mod tests {
    #[test]
    fn quoted_containing_paren() {
        let input = r#"  (foo "b(a)r" baz )  "#;
-        let (remaining, parsed) = sexp_with_padding(input).expect("Parse the input");
+        let (remaining, parsed) = sexp(input).expect("Parse the input");
        assert_eq!(remaining, "");
        assert!(match parsed {
            Token::List(_) => true,
@ -328,7 +339,7 @@ mod tests {
    #[test]
    fn string_containing_escaped_characters() {
        let input = r#"  (foo "\\( x=2 \\)" bar)  "#;
-        let (remaining, parsed) = sexp_with_padding(input).expect("Parse the input");
+        let (remaining, parsed) = sexp(input).expect("Parse the input");
        assert_eq!(remaining, "");
        assert!(match parsed {
            Token::Atom(_) => false,
--- a/src/compare/util.rs
+++ b/src/compare/util.rs
@ -1,4 +1,4 @@
-use crate::parser::sexp::Token;
+use super::sexp::Token;
 use crate::types::Source;

 /// Check if the child string slice is a slice of the parent string slice.
@ -21,7 +21,10 @@ fn get_offsets<'s, S: Source<'s>>(source: &'s str, rust_object: &'s S) -> (usize
    (offset, end)
 }

-pub fn assert_name<'s>(emacs: &'s Token<'s>, name: &str) -> Result<(), Box<dyn std::error::Error>> {
+pub(crate) fn assert_name<'s>(
+    emacs: &'s Token<'s>,
+    name: &str,
+) -> Result<(), Box<dyn std::error::Error>> {
    let children = emacs.as_list()?;
    let first_child = children
        .first()
@ -37,7 +40,7 @@ pub fn assert_name<'s>(emacs: &'s Token<'s>, name: &str) -> Result<(), Box<dyn s
    Ok(())
 }

-pub fn assert_bounds<'s, S: Source<'s>>(
+pub(crate) fn assert_bounds<'s, S: Source<'s>>(
    source: &'s str,
    emacs: &'s Token<'s>,
    rust: &'s S,
@ -146,7 +149,7 @@ fn maybe_token_to_usize(
 /// Returns Ok(None) if value is nil.
 ///
 /// Returns error if the attribute is not specified on the token at all.
-pub fn get_property<'s, 'x>(
+pub(crate) fn get_property<'s, 'x>(
    emacs: &'s Token<'s>,
    key: &'x str,
 ) -> Result<Option<&'s Token<'s>>, Box<dyn std::error::Error>> {
--- a/src/context/context.rs
+++ b/src/context/context.rs
@ -14,7 +14,7 @@ use crate::error::Res;
 use crate::parser::OrgSource;

 #[derive(Debug)]
-pub enum ContextElement<'r, 's> {
+pub(crate) enum ContextElement<'r, 's> {
    /// Stores a parser that indicates that children should exit upon matching an exit matcher.
    ExitMatcherNode(ExitMatcherNode<'r>),

@ -28,13 +28,14 @@ pub enum ContextElement<'r, 's> {
    ConsumeTrailingWhitespace(bool),

    /// This is just here to use the 's lifetime until I'm sure we can eliminate it from ContextElement.
+    #[allow(dead_code)]
    Placeholder(PhantomData<&'s str>),
 }

-pub struct ExitMatcherNode<'r> {
+pub(crate) struct ExitMatcherNode<'r> {
    // TODO: Should this be "&'r DynContextMatcher<'c>" ?
-    pub exit_matcher: &'r DynContextMatcher<'r>,
-    pub class: ExitClass,
+    pub(crate) exit_matcher: &'r DynContextMatcher<'r>,
+    pub(crate) class: ExitClass,
 }

 impl<'r> std::fmt::Debug for ExitMatcherNode<'r> {
@ -46,13 +47,13 @@ impl<'r> std::fmt::Debug for ExitMatcherNode<'r> {
 }

 #[derive(Debug)]
-pub struct Context<'g, 'r, 's> {
+pub(crate) struct Context<'g, 'r, 's> {
    global_settings: &'g GlobalSettings<'g, 's>,
    tree: List<'r, &'r ContextElement<'r, 's>>,
 }

 impl<'g, 'r, 's> Context<'g, 'r, 's> {
-    pub fn new(
+    pub(crate) fn new(
        global_settings: &'g GlobalSettings<'g, 's>,
        tree: List<'r, &'r ContextElement<'r, 's>>,
    ) -> Self {
@ -62,38 +63,38 @@ impl<'g, 'r, 's> Context<'g, 'r, 's> {
        }
    }

-    pub fn with_additional_node(&'r self, new_element: &'r ContextElement<'r, 's>) -> Self {
+    pub(crate) fn with_additional_node(&'r self, new_element: &'r ContextElement<'r, 's>) -> Self {
        let new_tree = self.tree.push(new_element);
        Self::new(self.global_settings, new_tree)
    }

-    pub fn iter(&'r self) -> super::list::Iter<'r, &'r ContextElement<'r, 's>> {
+    pub(crate) fn iter(&'r self) -> super::list::Iter<'r, &'r ContextElement<'r, 's>> {
        self.tree.iter()
    }

-    pub fn iter_context(&'r self) -> Iter<'g, 'r, 's> {
+    fn iter_context(&'r self) -> Iter<'g, 'r, 's> {
        Iter {
            next: self.tree.iter_list(),
            global_settings: self.global_settings,
        }
    }

-    pub fn get_parent(&'r self) -> Option<Self> {
+    pub(crate) fn get_parent(&'r self) -> Option<Self> {
        self.tree.get_parent().map(|parent_tree| Self {
            global_settings: self.global_settings,
            tree: parent_tree.clone(),
        })
    }

-    pub fn get_data(&self) -> &ContextElement<'r, 's> {
+    fn get_data(&self) -> &ContextElement<'r, 's> {
        self.tree.get_data()
    }

-    pub fn get_global_settings(&self) -> &'g GlobalSettings<'g, 's> {
+    pub(crate) fn get_global_settings(&self) -> &'g GlobalSettings<'g, 's> {
        self.global_settings
    }

-    pub fn with_global_settings<'gg>(
+    pub(crate) fn with_global_settings<'gg>(
        &self,
        new_settings: &'gg GlobalSettings<'gg, 's>,
    ) -> Context<'gg, 'r, 's> {
@ -104,7 +105,7 @@ impl<'g, 'r, 's> Context<'g, 'r, 's> {
    }

    #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-    pub fn check_exit_matcher(
+    pub(crate) fn check_exit_matcher(
        &'r self,
        i: OrgSource<'s>,
    ) -> IResult<OrgSource<'s>, OrgSource<'s>, CustomError<OrgSource<'s>>> {
@ -133,7 +134,7 @@ impl<'g, 'r, 's> Context<'g, 'r, 's> {
    /// Indicates if elements should consume the whitespace after them.
    ///
    /// Defaults to true.
-    pub fn should_consume_trailing_whitespace(&self) -> bool {
+    pub(crate) fn should_consume_trailing_whitespace(&self) -> bool {
        self._should_consume_trailing_whitespace().unwrap_or(true)
    }

@ -158,7 +159,7 @@ fn document_end<'b, 'g, 'r, 's>(
    eof(input)
 }

-pub struct Iter<'g, 'r, 's> {
+struct Iter<'g, 'r, 's> {
    global_settings: &'g GlobalSettings<'g, 's>,
    next: super::list::IterList<'r, &'r ContextElement<'r, 's>>,
 }
@ -175,7 +176,7 @@ impl<'g, 'r, 's> Iterator for Iter<'g, 'r, 's> {
 }

 impl<'r, 's> ContextElement<'r, 's> {
-    pub fn document_context() -> Self {
+    pub(crate) fn document_context() -> Self {
        Self::ExitMatcherNode(ExitMatcherNode {
            exit_matcher: &document_end,
            class: ExitClass::Document,
--- a/src/context/exiting.rs
+++ b/src/context/exiting.rs
@ -1,5 +1,5 @@
 #[derive(Debug, Copy, Clone)]
-pub enum ExitClass {
+pub(crate) enum ExitClass {
    Document = 1,
    Alpha = 2,
    Beta = 3,
--- a/src/context/global_settings.rs
+++ b/src/context/global_settings.rs
@ -15,7 +15,7 @@ pub struct GlobalSettings<'g, 's> {
 }

 impl<'g, 's> GlobalSettings<'g, 's> {
-    pub fn new() -> GlobalSettings<'g, 's> {
+    fn new() -> GlobalSettings<'g, 's> {
        GlobalSettings {
            radio_targets: Vec::new(),
            file_access: &LocalFileAccessInterface {
--- a/src/context/list.rs
+++ b/src/context/list.rs
@ -1,7 +1,7 @@
 use std::fmt::Debug;

 #[derive(Debug, Clone)]
-pub struct List<'parent, T> {
+pub(crate) struct List<'parent, T> {
    data: T,
    parent: Link<'parent, T>,
 }
@ -9,30 +9,30 @@ pub struct List<'parent, T> {
 type Link<'parent, T> = Option<&'parent List<'parent, T>>;

 impl<'parent, T> List<'parent, T> {
-    pub fn new(first_item: T) -> Self {
+    pub(crate) fn new(first_item: T) -> Self {
        Self {
            data: first_item,
            parent: None,
        }
    }

-    pub fn get_data(&self) -> &T {
+    pub(crate) fn get_data(&self) -> &T {
        &self.data
    }

-    pub fn get_parent(&'parent self) -> Link<'parent, T> {
+    pub(crate) fn get_parent(&'parent self) -> Link<'parent, T> {
        self.parent
    }

-    pub fn iter(&self) -> Iter<'_, T> {
+    pub(crate) fn iter(&self) -> Iter<'_, T> {
        Iter { next: Some(self) }
    }

-    pub fn iter_list(&self) -> IterList<'_, T> {
+    pub(crate) fn iter_list(&self) -> IterList<'_, T> {
        IterList { next: Some(self) }
    }

-    pub fn push(&'parent self, item: T) -> Self {
+    pub(crate) fn push(&'parent self, item: T) -> Self {
        Self {
            data: item,
            parent: Some(self),
@ -40,7 +40,7 @@ impl<'parent, T> List<'parent, T> {
    }
 }

-pub struct Iter<'a, T> {
+pub(crate) struct Iter<'a, T> {
    next: Link<'a, T>,
 }

@ -54,7 +54,7 @@ impl<'a, T> Iterator for Iter<'a, T> {
    }
 }

-pub struct IterList<'a, T> {
+pub(crate) struct IterList<'a, T> {
    next: Link<'a, T>,
 }

--- a/src/context/mod.rs
+++ b/src/context/mod.rs
@ -8,22 +8,22 @@ mod global_settings;
 mod list;
 mod parser_with_context;

-pub type RefContext<'b, 'g, 'r, 's> = &'b Context<'g, 'r, 's>;
-pub trait ContextMatcher = for<'b, 'g, 'r, 's> Fn(
+pub(crate) type RefContext<'b, 'g, 'r, 's> = &'b Context<'g, 'r, 's>;
+pub(crate) trait ContextMatcher = for<'b, 'g, 'r, 's> Fn(
    RefContext<'b, 'g, 'r, 's>,
    OrgSource<'s>,
 ) -> Res<OrgSource<'s>, OrgSource<'s>>;
-pub type DynContextMatcher<'c> = dyn ContextMatcher + 'c;
-pub trait Matcher = for<'s> Fn(OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>>;
+type DynContextMatcher<'c> = dyn ContextMatcher + 'c;
+pub(crate) trait Matcher = for<'s> Fn(OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>>;
 #[allow(dead_code)]
-pub type DynMatcher<'c> = dyn Matcher + 'c;
+type DynMatcher<'c> = dyn Matcher + 'c;

-pub use context::Context;
-pub use context::ContextElement;
-pub use context::ExitMatcherNode;
-pub use exiting::ExitClass;
+pub(crate) use context::Context;
+pub(crate) use context::ContextElement;
+pub(crate) use context::ExitMatcherNode;
+pub(crate) use exiting::ExitClass;
 pub use file_access_interface::FileAccessInterface;
 pub use file_access_interface::LocalFileAccessInterface;
 pub use global_settings::GlobalSettings;
-pub use list::List;
+pub(crate) use list::List;
 pub(crate) use parser_with_context::parser_with_context;
--- a/src/error/error.rs
+++ b/src/error/error.rs
@ -2,7 +2,7 @@ use nom::error::ErrorKind;
 use nom::error::ParseError;
 use nom::IResult;

-pub type Res<T, U> = IResult<T, U, CustomError<T>>;
+pub(crate) type Res<T, U> = IResult<T, U, CustomError<T>>;

 // TODO: MyError probably shouldn't be based on the same type as the input type since it's used exclusively with static strings right now.
 #[derive(Debug)]
@ -13,7 +13,7 @@ pub enum CustomError<I> {
 }

 #[derive(Debug)]
-pub struct MyError<I>(pub I);
+pub struct MyError<I>(pub(crate) I);

 impl<I> ParseError<I> for CustomError<I> {
    fn from_error_kind(input: I, kind: ErrorKind) -> Self {
--- a/src/error/mod.rs
+++ b/src/error/mod.rs
@ -1,4 +1,4 @@
 mod error;
-pub use error::CustomError;
-pub use error::MyError;
-pub use error::Res;
+pub(crate) use error::CustomError;
+pub(crate) use error::MyError;
+pub(crate) use error::Res;
--- a/src/init_tracing.rs
+++ b/src/init_tracing.rs
@ -10,7 +10,7 @@ const SERVICE_NAME: &'static str = "organic";
 // Despite the obvious verbosity that fully-qualifying everything causes, in these functions I am fully-qualifying everything relating to tracing. This is because the tracing feature involves multiple libraries working together and so I think it is beneficial to see which libraries contribute which bits.

 #[cfg(feature = "tracing")]
-pub fn init_telemetry() -> Result<(), Box<dyn std::error::Error>> {
+pub(crate) fn init_telemetry() -> Result<(), Box<dyn std::error::Error>> {
    // by default it will hit http://localhost:4317 with a gRPC payload
    // TODO: I think the endpoint can be controlled by the OTEL_EXPORTER_OTLP_TRACES_ENDPOINT env variable instead of hard-coded into this code base. Regardless, I am the only developer right now so I am not too concerned.
    let exporter = opentelemetry_otlp::new_exporter()
@ -55,17 +55,17 @@ pub fn init_telemetry() -> Result<(), Box<dyn std::error::Error>> {
 }

 #[cfg(feature = "tracing")]
-pub fn shutdown_telemetry() -> Result<(), Box<dyn std::error::Error>> {
+pub(crate) fn shutdown_telemetry() -> Result<(), Box<dyn std::error::Error>> {
    opentelemetry::global::shutdown_tracer_provider();
    Ok(())
 }

 #[cfg(not(feature = "tracing"))]
-pub fn init_telemetry() -> Result<(), Box<dyn std::error::Error>> {
+pub(crate) fn init_telemetry() -> Result<(), Box<dyn std::error::Error>> {
    Ok(())
 }

 #[cfg(not(feature = "tracing"))]
-pub fn shutdown_telemetry() -> Result<(), Box<dyn std::error::Error>> {
+pub(crate) fn shutdown_telemetry() -> Result<(), Box<dyn std::error::Error>> {
    Ok(())
 }
--- a/src/lib.rs
+++ b/src/lib.rs
@ -15,11 +15,14 @@ pub use compare::emacs_parse_file_org_document;
 pub use compare::get_emacs_version;
 #[cfg(feature = "compare")]
 pub use compare::get_org_mode_version;
+#[cfg(feature = "compare")]
+pub use compare::sexp;

 mod context;
 mod error;
 pub mod parser;
 pub mod types;

+pub use context::FileAccessInterface;
 pub use context::GlobalSettings;
 pub use context::LocalFileAccessInterface;
--- a/src/parser/angle_link.rs
+++ b/src/parser/angle_link.rs
@ -18,7 +18,7 @@ use crate::parser::util::get_consumed;
 use crate::types::AngleLink;

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn angle_link<'b, 'g, 'r, 's>(
+pub(crate) fn angle_link<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, AngleLink<'s>> {
--- a/src/parser/citation.rs
+++ b/src/parser/citation.rs
@ -31,7 +31,7 @@ use crate::types::Citation;
 use crate::types::Object;

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn citation<'b, 'g, 'r, 's>(
+pub(crate) fn citation<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Citation<'s>> {
--- a/src/parser/citation_reference.rs
+++ b/src/parser/citation_reference.rs
@ -29,7 +29,7 @@ use crate::types::CitationReference;
 use crate::types::Object;

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn citation_reference<'b, 'g, 'r, 's>(
+pub(crate) fn citation_reference<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, CitationReference<'s>> {
@ -49,7 +49,7 @@ pub fn citation_reference<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn citation_reference_key<'b, 'g, 'r, 's>(
+pub(crate) fn citation_reference_key<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, OrgSource<'s>> {
@ -161,7 +161,7 @@ fn _key_suffix_end<'b, 'g, 'r, 's>(
    tag(";")(input)
 }

-pub fn must_balance_bracket<'s, F, O>(
+pub(crate) fn must_balance_bracket<'s, F, O>(
    mut inner: F,
 ) -> impl FnMut(OrgSource<'s>) -> Res<OrgSource<'s>, O>
 where
--- a/src/parser/clock.rs
+++ b/src/parser/clock.rs
@ -20,7 +20,7 @@ use crate::parser::util::start_of_line;
 use crate::types::Clock;

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn clock<'b, 'g, 'r, 's>(
+pub(crate) fn clock<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Clock<'s>> {
--- a/src/parser/comment.rs
+++ b/src/parser/comment.rs
@ -25,7 +25,7 @@ use crate::parser::util::start_of_line;
 use crate::types::Comment;

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn comment<'b, 'g, 'r, 's>(
+pub(crate) fn comment<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Comment<'s>> {
@ -68,7 +68,7 @@ fn comment_line<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn detect_comment<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
+pub(crate) fn detect_comment<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
    tuple((
        start_of_line,
        space0,
--- a/src/parser/diary_sexp.rs
+++ b/src/parser/diary_sexp.rs
@ -13,7 +13,7 @@ use crate::parser::util::start_of_line;
 use crate::types::DiarySexp;

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn diary_sexp<'b, 'g, 'r, 's>(
+pub(crate) fn diary_sexp<'b, 'g, 'r, 's>(
    _context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, DiarySexp<'s>> {
@ -32,7 +32,7 @@ pub fn diary_sexp<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn detect_diary_sexp<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
+pub(crate) fn detect_diary_sexp<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
    tuple((start_of_line, tag("%%(")))(input)?;
    Ok((input, ()))
 }
--- a/src/parser/document.rs
+++ b/src/parser/document.rs
@ -58,7 +58,7 @@ pub fn parse_with_settings<'g, 's>(
 ///
 /// This will not prevent additional settings from being learned during parsing, for example when encountering a "#+TODO".
 #[allow(dead_code)]
-pub fn document<'b, 'g, 'r, 's>(
+fn document<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: &'s str,
 ) -> Res<&'s str, Document<'s>> {
@ -157,7 +157,7 @@ fn _document<'b, 'g, 'r, 's>(
 }

 impl<'s> Document<'s> {
-    pub fn iter_tokens<'r>(&'r self) -> impl Iterator<Item = Token<'r, 's>> {
+    fn iter_tokens<'r>(&'r self) -> impl Iterator<Item = Token<'r, 's>> {
        AllTokensIterator::new(Token::Document(self))
    }
 }
--- a/src/parser/drawer.rs
+++ b/src/parser/drawer.rs
@ -32,7 +32,7 @@ use crate::types::Paragraph;
 use crate::types::SetSource;

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn drawer<'b, 'g, 'r, 's>(
+pub(crate) fn drawer<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Drawer<'s>> {
--- a/src/parser/dynamic_block.rs
+++ b/src/parser/dynamic_block.rs
@ -32,7 +32,7 @@ use crate::types::Paragraph;
 use crate::types::SetSource;

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn dynamic_block<'b, 'g, 'r, 's>(
+pub(crate) fn dynamic_block<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, DynamicBlock<'s>> {
--- a/src/parser/element_parser.rs
+++ b/src/parser/element_parser.rs
@ -40,7 +40,7 @@ use crate::parser::table::org_mode_table;
 use crate::types::Element;
 use crate::types::SetSource;

-pub const fn element(
+pub(crate) const fn element(
    can_be_paragraph: bool,
 ) -> impl for<'b, 'g, 'r, 's> Fn(
    RefContext<'b, 'g, 'r, 's>,
@ -127,7 +127,7 @@ fn _element<'b, 'g, 'r, 's>(
    Ok((remaining, element))
 }

-pub const fn detect_element(
+pub(crate) const fn detect_element(
    can_be_paragraph: bool,
 ) -> impl for<'b, 'g, 'r, 's> Fn(RefContext<'b, 'g, 'r, 's>, OrgSource<'s>) -> Res<OrgSource<'s>, ()>
 {
--- a/src/parser/entity.rs
+++ b/src/parser/entity.rs
@ -433,7 +433,7 @@ const ORG_ENTITIES: [&'static str; 413] = [
 ];

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn entity<'b, 'g, 'r, 's>(
+pub(crate) fn entity<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Entity<'s>> {
--- a/src/parser/export_snippet.rs
+++ b/src/parser/export_snippet.rs
@ -20,7 +20,7 @@ use crate::parser::util::get_consumed;
 use crate::types::ExportSnippet;

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn export_snippet<'b, 'g, 'r, 's>(
+pub(crate) fn export_snippet<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, ExportSnippet<'s>> {
--- a/src/parser/fixed_width_area.rs
+++ b/src/parser/fixed_width_area.rs
@ -21,7 +21,7 @@ use crate::parser::util::start_of_line;
 use crate::types::FixedWidthArea;

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn fixed_width_area<'b, 'g, 'r, 's>(
+pub(crate) fn fixed_width_area<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, FixedWidthArea<'s>> {
@ -57,7 +57,7 @@ fn fixed_width_area_line<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn detect_fixed_width_area<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
+pub(crate) fn detect_fixed_width_area<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
    tuple((
        start_of_line,
        space0,
--- a/src/parser/footnote_definition.rs
+++ b/src/parser/footnote_definition.rs
@ -33,7 +33,7 @@ use crate::parser::util::start_of_line;
 use crate::types::FootnoteDefinition;

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn footnote_definition<'b, 'g, 'r, 's>(
+pub(crate) fn footnote_definition<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, FootnoteDefinition<'s>> {
@ -93,7 +93,7 @@ pub fn footnote_definition<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn label<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>> {
+pub(crate) fn label<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>> {
    alt((
        digit1,
        take_while(|c| WORD_CONSTITUENT_CHARACTERS.contains(c) || "-_".contains(c)),
@ -122,7 +122,7 @@ fn footnote_definition_end<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn detect_footnote_definition<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
+pub(crate) fn detect_footnote_definition<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
    tuple((start_of_line, tag_no_case("[fn:"), label, tag("]")))(input)?;
    Ok((input, ()))
 }
--- a/src/parser/footnote_reference.rs
+++ b/src/parser/footnote_reference.rs
@ -23,7 +23,7 @@ use crate::parser::util::get_consumed;
 use crate::types::FootnoteReference;

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn footnote_reference<'b, 'g, 'r, 's>(
+pub(crate) fn footnote_reference<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, FootnoteReference<'s>> {
--- a/src/parser/greater_block.rs
+++ b/src/parser/greater_block.rs
@ -33,7 +33,7 @@ use crate::types::Paragraph;
 use crate::types::SetSource;

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn greater_block<'b, 'g, 'r, 's>(
+pub(crate) fn greater_block<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, GreaterBlock<'s>> {
--- a/src/parser/headline.rs
+++ b/src/parser/headline.rs
@ -36,7 +36,7 @@ use crate::types::Object;
 use crate::types::PriorityCookie;
 use crate::types::TodoKeywordType;

-pub const fn heading(
+pub(crate) const fn heading(
    parent_stars: usize,
 ) -> impl for<'b, 'g, 'r, 's> Fn(
    RefContext<'b, 'g, 'r, 's>,
@ -95,7 +95,7 @@ fn _heading<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn detect_headline<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
+pub(crate) fn detect_headline<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
    tuple((start_of_line, many1(tag("*")), space1))(input)?;
    Ok((input, ()))
 }
--- a/src/parser/horizontal_rule.rs
+++ b/src/parser/horizontal_rule.rs
@ -15,7 +15,7 @@ use crate::parser::util::start_of_line;
 use crate::types::HorizontalRule;

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn horizontal_rule<'b, 'g, 'r, 's>(
+pub(crate) fn horizontal_rule<'b, 'g, 'r, 's>(
    _context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, HorizontalRule<'s>> {
--- a/src/parser/in_buffer_settings.rs
+++ b/src/parser/in_buffer_settings.rs
@ -13,7 +13,7 @@ use crate::types::Keyword;
 use crate::GlobalSettings;

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn scan_for_in_buffer_settings<'s>(
+pub(crate) fn scan_for_in_buffer_settings<'s>(
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Vec<Keyword<'s>>> {
    // TODO: Optimization idea: since this is slicing the OrgSource at each character, it might be more efficient to do a parser that uses a search function like take_until, and wrap it in a function similar to consumed but returning the input along with the normal output, then pass all of that into a verify that confirms we were at the start of a line using the input we just returned.
@ -44,7 +44,7 @@ fn in_buffer_settings_key<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSou
    ))(input)
 }

-pub fn apply_in_buffer_settings<'g, 's, 'sf>(
+pub(crate) fn apply_in_buffer_settings<'g, 's, 'sf>(
    keywords: Vec<Keyword<'sf>>,
    original_settings: &'g GlobalSettings<'g, 's>,
 ) -> Result<GlobalSettings<'g, 's>, String> {
--- a/src/parser/inline_babel_call.rs
+++ b/src/parser/inline_babel_call.rs
@ -26,7 +26,7 @@ use crate::parser::util::get_consumed;
 use crate::types::InlineBabelCall;

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn inline_babel_call<'b, 'g, 'r, 's>(
+pub(crate) fn inline_babel_call<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, InlineBabelCall<'s>> {
--- a/src/parser/inline_source_block.rs
+++ b/src/parser/inline_source_block.rs
@ -28,7 +28,7 @@ use crate::parser::util::get_consumed;
 use crate::types::InlineSourceBlock;

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn inline_source_block<'b, 'g, 'r, 's>(
+pub(crate) fn inline_source_block<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, InlineSourceBlock<'s>> {
--- a/src/parser/keyword.rs
+++ b/src/parser/keyword.rs
@ -31,7 +31,7 @@ const ORG_ELEMENT_AFFILIATED_KEYWORDS: [&'static str; 13] = [
 ];
 const ORG_ELEMENT_DUAL_KEYWORDS: [&'static str; 2] = ["caption", "results"];

-pub fn filtered_keyword<F: Matcher>(
+pub(crate) fn filtered_keyword<F: Matcher>(
    key_parser: F,
 ) -> impl for<'s> Fn(OrgSource<'s>) -> Res<OrgSource<'s>, Keyword<'s>> {
    move |input| _filtered_keyword(&key_parser, input)
@ -83,7 +83,7 @@ fn _filtered_keyword<'s, F: Matcher>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn keyword<'b, 'g, 'r, 's>(
+pub(crate) fn keyword<'b, 'g, 'r, 's>(
    _context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Keyword<'s>> {
@ -91,7 +91,7 @@ pub fn keyword<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn affiliated_keyword<'b, 'g, 'r, 's>(
+pub(crate) fn affiliated_keyword<'b, 'g, 'r, 's>(
    _context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Keyword<'s>> {
@ -99,7 +99,7 @@ pub fn affiliated_keyword<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn babel_call_keyword<'b, 'g, 'r, 's>(
+pub(crate) fn babel_call_keyword<'b, 'g, 'r, 's>(
    _context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Keyword<'s>> {
@ -112,7 +112,7 @@ fn babel_call_key<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>>
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn table_formula_keyword<'b, 'g, 'r, 's>(
+pub(crate) fn table_formula_keyword<'b, 'g, 'r, 's>(
    _context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Keyword<'s>> {
--- a/src/parser/keyword_todo.rs
+++ b/src/parser/keyword_todo.rs
@ -19,7 +19,7 @@ use crate::error::Res;
 /// Parses the text in the value of a #+TODO keyword.
 ///
 /// Example input: "foo bar baz | lorem ipsum"
-pub fn todo_keywords<'s>(input: &'s str) -> Res<&'s str, (Vec<&'s str>, Vec<&'s str>)> {
+pub(crate) fn todo_keywords<'s>(input: &'s str) -> Res<&'s str, (Vec<&'s str>, Vec<&'s str>)> {
    let (remaining, mut before_pipe_words) = separated_list0(space1, todo_keyword_word)(input)?;
    let (remaining, after_pipe_words) = opt(tuple((
        tuple((space0, tag("|"), space0)),
--- a/src/parser/latex_environment.rs
+++ b/src/parser/latex_environment.rs
@ -25,7 +25,7 @@ use crate::parser::util::start_of_line;
 use crate::types::LatexEnvironment;

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn latex_environment<'b, 'g, 'r, 's>(
+pub(crate) fn latex_environment<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, LatexEnvironment<'s>> {
--- a/src/parser/latex_fragment.rs
+++ b/src/parser/latex_fragment.rs
@ -24,7 +24,7 @@ use crate::parser::util::get_consumed;
 use crate::types::LatexFragment;

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn latex_fragment<'b, 'g, 'r, 's>(
+pub(crate) fn latex_fragment<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, LatexFragment<'s>> {
@ -174,7 +174,7 @@ fn dollar_char_fragment<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn pre<'b, 'g, 'r, 's>(
+fn pre<'b, 'g, 'r, 's>(
    _context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, ()> {
@ -188,7 +188,7 @@ pub fn pre<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn post<'b, 'g, 'r, 's>(
+fn post<'b, 'g, 'r, 's>(
    _context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, ()> {
@ -226,7 +226,7 @@ fn bordered_dollar_fragment<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn open_border<'b, 'g, 'r, 's>(
+fn open_border<'b, 'g, 'r, 's>(
    _context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, OrgSource<'s>> {
@ -234,7 +234,7 @@ pub fn open_border<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn close_border<'b, 'g, 'r, 's>(
+fn close_border<'b, 'g, 'r, 's>(
    _context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, ()> {
--- a/src/parser/lesser_block.rs
+++ b/src/parser/lesser_block.rs
@ -35,7 +35,7 @@ use crate::types::SrcBlock;
 use crate::types::VerseBlock;

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn verse_block<'b, 'g, 'r, 's>(
+pub(crate) fn verse_block<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, VerseBlock<'s>> {
@ -90,7 +90,7 @@ pub fn verse_block<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn comment_block<'b, 'g, 'r, 's>(
+pub(crate) fn comment_block<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, CommentBlock<'s>> {
@ -130,7 +130,7 @@ pub fn comment_block<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn example_block<'b, 'g, 'r, 's>(
+pub(crate) fn example_block<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, ExampleBlock<'s>> {
@ -170,7 +170,7 @@ pub fn example_block<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn export_block<'b, 'g, 'r, 's>(
+pub(crate) fn export_block<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, ExportBlock<'s>> {
@ -211,7 +211,7 @@ pub fn export_block<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn src_block<'b, 'g, 'r, 's>(
+pub(crate) fn src_block<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, SrcBlock<'s>> {
--- a/src/parser/line_break.rs
+++ b/src/parser/line_break.rs
@ -13,7 +13,7 @@ use crate::parser::util::get_consumed;
 use crate::types::LineBreak;

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn line_break<'b, 'g, 'r, 's>(
+pub(crate) fn line_break<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, LineBreak<'s>> {
--- a/src/parser/mod.rs
+++ b/src/parser/mod.rs
@ -37,7 +37,6 @@ mod property_drawer;
 mod radio_link;
 mod regular_link;
 mod section;
-pub mod sexp;
 mod statistics_cookie;
 mod subscript_and_superscript;
 mod table;
@ -46,7 +45,6 @@ mod text_markup;
 mod timestamp;
 mod token;
 mod util;
-pub use document::document;
 pub use document::parse;
 pub use document::parse_with_settings;
-pub use org_source::OrgSource;
+pub(crate) use org_source::OrgSource;
--- a/src/parser/object_parser.rs
+++ b/src/parser/object_parser.rs
@ -32,7 +32,7 @@ use crate::parser::timestamp::timestamp;
 use crate::types::Object;

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn standard_set_object<'b, 'g, 'r, 's>(
+pub(crate) fn standard_set_object<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Object<'s>> {
@ -47,7 +47,7 @@ pub fn standard_set_object<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn minimal_set_object<'b, 'g, 'r, 's>(
+pub(crate) fn minimal_set_object<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Object<'s>> {
@ -140,7 +140,7 @@ fn minimal_set_object_sans_plain_text<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn detect_standard_set_object_sans_plain_text<'b, 'g, 'r, 's>(
+pub(crate) fn detect_standard_set_object_sans_plain_text<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, ()> {
@ -174,7 +174,7 @@ fn detect_minimal_set_object_sans_plain_text<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn regular_link_description_set_object<'b, 'g, 'r, 's>(
+pub(crate) fn regular_link_description_set_object<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Object<'s>> {
@ -221,7 +221,7 @@ fn regular_link_description_set_object_sans_plain_text<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn detect_regular_link_description_set_object_sans_plain_text<'b, 'g, 'r, 's>(
+fn detect_regular_link_description_set_object_sans_plain_text<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, ()> {
@ -238,7 +238,7 @@ pub fn detect_regular_link_description_set_object_sans_plain_text<'b, 'g, 'r, 's
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn table_cell_set_object<'b, 'g, 'r, 's>(
+pub(crate) fn table_cell_set_object<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Object<'s>> {
@ -253,7 +253,7 @@ pub fn table_cell_set_object<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn table_cell_set_object_sans_plain_text<'b, 'g, 'r, 's>(
+fn table_cell_set_object_sans_plain_text<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Object<'s>> {
@ -287,7 +287,7 @@ pub fn table_cell_set_object_sans_plain_text<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn detect_table_cell_set_object_sans_plain_text<'b, 'g, 'r, 's>(
+fn detect_table_cell_set_object_sans_plain_text<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, ()> {
--- a/src/parser/org_macro.rs
+++ b/src/parser/org_macro.rs
@ -18,7 +18,7 @@ use crate::parser::util::get_consumed;
 use crate::types::OrgMacro;

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn org_macro<'b, 'g, 'r, 's>(
+pub(crate) fn org_macro<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, OrgMacro<'s>> {
--- a/src/parser/org_source.rs
+++ b/src/parser/org_source.rs
@ -11,10 +11,10 @@ use nom::Slice;
 use crate::error::CustomError;
 use crate::error::MyError;

-pub type BracketDepth = i16;
+pub(crate) type BracketDepth = i16;

 #[derive(Copy, Clone)]
-pub struct OrgSource<'s> {
+pub(crate) struct OrgSource<'s> {
    full_source: &'s str,
    start: usize,
    end: usize, // exclusive
@ -37,7 +37,7 @@ impl<'s> OrgSource<'s> {
    /// Returns a wrapped string that keeps track of values we need for parsing org-mode.
    ///
    /// Only call this on the full original string. Calling this on a substring can result in invalid values.
-    pub fn new(input: &'s str) -> Self {
+    pub(crate) fn new(input: &'s str) -> Self {
        OrgSource {
            full_source: input,
            start: 0,
@ -51,37 +51,37 @@ impl<'s> OrgSource<'s> {
    }

    /// Get the text since the line break preceding the start of this WrappedInput.
-    pub fn text_since_line_break(&self) -> &'s str {
+    pub(crate) fn text_since_line_break(&self) -> &'s str {
        &self.full_source[self.start_of_line..self.start]
    }

-    pub fn len(&self) -> usize {
+    pub(crate) fn len(&self) -> usize {
        self.end - self.start
    }

-    pub fn get_preceding_character(&self) -> Option<char> {
+    pub(crate) fn get_preceding_character(&self) -> Option<char> {
        self.preceding_character
    }

-    pub fn is_at_start_of_line(&self) -> bool {
+    pub(crate) fn is_at_start_of_line(&self) -> bool {
        self.start == self.start_of_line
    }

-    pub fn get_until(&self, other: OrgSource<'s>) -> OrgSource<'s> {
+    pub(crate) fn get_until(&self, other: OrgSource<'s>) -> OrgSource<'s> {
        assert!(other.start >= self.start);
        assert!(other.end <= self.end);
        self.slice(..(other.start - self.start))
    }

-    pub fn get_bracket_depth(&self) -> BracketDepth {
+    pub(crate) fn get_bracket_depth(&self) -> BracketDepth {
        self.bracket_depth
    }

-    pub fn get_brace_depth(&self) -> BracketDepth {
+    pub(crate) fn get_brace_depth(&self) -> BracketDepth {
        self.brace_depth
    }

-    pub fn get_parenthesis_depth(&self) -> BracketDepth {
+    pub(crate) fn get_parenthesis_depth(&self) -> BracketDepth {
        self.parenthesis_depth
    }
 }
@ -306,7 +306,7 @@ impl<'s> InputTakeAtPosition for OrgSource<'s> {
    }
 }

-pub fn convert_error<'a, I: Into<CustomError<&'a str>>>(
+pub(crate) fn convert_error<'a, I: Into<CustomError<&'a str>>>(
    err: nom::Err<I>,
 ) -> nom::Err<CustomError<&'a str>> {
    match err {
--- a/src/parser/paragraph.rs
+++ b/src/parser/paragraph.rs
@ -22,7 +22,7 @@ use crate::parser::util::start_of_line;
 use crate::types::Paragraph;

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn paragraph<'b, 'g, 'r, 's>(
+pub(crate) fn paragraph<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Paragraph<'s>> {
--- a/src/parser/plain_link.rs
+++ b/src/parser/plain_link.rs
@ -53,7 +53,7 @@ const ORG_LINK_PARAMETERS: [&'static str; 23] = [
 ];

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn plain_link<'b, 'g, 'r, 's>(
+pub(crate) fn plain_link<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, PlainLink<'s>> {
@ -105,7 +105,7 @@ fn post<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn protocol<'b, 'g, 'r, 's>(
+pub(crate) fn protocol<'b, 'g, 'r, 's>(
    _context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, OrgSource<'s>> {
--- a/src/parser/plain_list.rs
+++ b/src/parser/plain_list.rs
@ -41,7 +41,7 @@ use crate::types::PlainList;
 use crate::types::PlainListItem;

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn detect_plain_list<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
+pub(crate) fn detect_plain_list<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
    if verify(
        tuple((
            start_of_line,
@ -63,7 +63,7 @@ pub fn detect_plain_list<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn plain_list<'b, 'g, 'r, 's>(
+pub(crate) fn plain_list<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, PlainList<'s>> {
@ -137,7 +137,7 @@ pub fn plain_list<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn plain_list_item<'b, 'g, 'r, 's>(
+fn plain_list_item<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, PlainListItem<'s>> {
--- a/src/parser/plain_text.rs
+++ b/src/parser/plain_text.rs
@ -16,7 +16,7 @@ use crate::error::Res;
 use crate::types::Object;
 use crate::types::PlainText;

-pub fn plain_text<F>(
+pub(crate) fn plain_text<F>(
    end_condition: F,
 ) -> impl for<'b, 'g, 'r, 's> Fn(
    RefContext<'b, 'g, 'r, 's>,
--- a/src/parser/planning.rs
+++ b/src/parser/planning.rs
@ -18,7 +18,7 @@ use crate::parser::util::start_of_line;
 use crate::types::Planning;

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn planning<'b, 'g, 'r, 's>(
+pub(crate) fn planning<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Planning<'s>> {
--- a/src/parser/property_drawer.rs
+++ b/src/parser/property_drawer.rs
@ -31,7 +31,7 @@ use crate::types::NodeProperty;
 use crate::types::PropertyDrawer;

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn property_drawer<'b, 'g, 'r, 's>(
+pub(crate) fn property_drawer<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, PropertyDrawer<'s>> {
--- a/src/parser/radio_link.rs
+++ b/src/parser/radio_link.rs
@ -23,7 +23,7 @@ use crate::types::RadioLink;
 use crate::types::RadioTarget;

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn radio_link<'b, 'g, 'r, 's>(
+pub(crate) fn radio_link<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, RadioLink<'s>> {
@ -47,7 +47,7 @@ pub fn radio_link<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn rematch_target<'x, 'b, 'g, 'r, 's>(
+pub(crate) fn rematch_target<'x, 'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    target: &'x Vec<Object<'x>>,
    input: OrgSource<'s>,
@ -78,7 +78,7 @@ pub fn rematch_target<'x, 'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn radio_target<'b, 'g, 'r, 's>(
+pub(crate) fn radio_target<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, RadioTarget<'s>> {
@ -118,7 +118,7 @@ fn radio_target_end<'b, 'g, 'r, 's>(
    alt((tag("<"), tag(">"), line_ending))(input)
 }

-pub trait RematchObject<'x> {
+pub(crate) trait RematchObject<'x> {
    fn rematch_object<'b, 'g, 'r, 's>(
        &'x self,
        context: RefContext<'b, 'g, 'r, 's>,
--- a/src/parser/regular_link.rs
+++ b/src/parser/regular_link.rs
@ -21,7 +21,7 @@ use crate::types::Object;
 use crate::types::RegularLink;

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn regular_link<'b, 'g, 'r, 's>(
+pub(crate) fn regular_link<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, RegularLink<'s>> {
@ -32,7 +32,7 @@ pub fn regular_link<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn regular_link_without_description<'b, 'g, 'r, 's>(
+fn regular_link_without_description<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, RegularLink<'s>> {
@ -51,7 +51,7 @@ pub fn regular_link_without_description<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn regular_link_with_description<'b, 'g, 'r, 's>(
+fn regular_link_with_description<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, RegularLink<'s>> {
@ -72,7 +72,7 @@ pub fn regular_link_with_description<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn pathreg<'b, 'g, 'r, 's>(
+fn pathreg<'b, 'g, 'r, 's>(
    _context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, OrgSource<'s>> {
@ -88,7 +88,7 @@ pub fn pathreg<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn description<'b, 'g, 'r, 's>(
+fn description<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Vec<Object<'s>>> {
--- a/src/parser/section.rs
+++ b/src/parser/section.rs
@ -25,7 +25,7 @@ use crate::types::Element;
 use crate::types::Section;

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn zeroth_section<'b, 'g, 'r, 's>(
+pub(crate) fn zeroth_section<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Section<'s>> {
@ -83,7 +83,7 @@ pub fn zeroth_section<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn section<'b, 'g, 'r, 's>(
+pub(crate) fn section<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    mut input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Section<'s>> {
--- a/src/parser/statistics_cookie.rs
+++ b/src/parser/statistics_cookie.rs
@ -13,7 +13,7 @@ use crate::error::Res;
 use crate::types::StatisticsCookie;

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn statistics_cookie<'b, 'g, 'r, 's>(
+pub(crate) fn statistics_cookie<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, StatisticsCookie<'s>> {
@ -24,7 +24,7 @@ pub fn statistics_cookie<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn percent_statistics_cookie<'b, 'g, 'r, 's>(
+fn percent_statistics_cookie<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, StatisticsCookie<'s>> {
@ -45,7 +45,7 @@ pub fn percent_statistics_cookie<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn fraction_statistics_cookie<'b, 'g, 'r, 's>(
+fn fraction_statistics_cookie<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, StatisticsCookie<'s>> {
--- a/src/parser/subscript_and_superscript.rs
+++ b/src/parser/subscript_and_superscript.rs
@ -33,7 +33,7 @@ use crate::types::Subscript;
 use crate::types::Superscript;

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn detect_subscript_or_superscript<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
+pub(crate) fn detect_subscript_or_superscript<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
    // This does not have to detect all valid subscript/superscript but all that it detects must be valid.
    let (remaining, _) = one_of("_^")(input)?;
    pre(input)?;
@ -46,7 +46,7 @@ pub fn detect_subscript_or_superscript<'s>(input: OrgSource<'s>) -> Res<OrgSourc
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn subscript<'b, 'g, 'r, 's>(
+pub(crate) fn subscript<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Subscript<'s>> {
@ -66,7 +66,7 @@ pub fn subscript<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn superscript<'b, 'g, 'r, 's>(
+pub(crate) fn superscript<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Superscript<'s>> {
--- a/src/parser/table.rs
+++ b/src/parser/table.rs
@ -33,7 +33,7 @@ use crate::types::TableRow;
 ///
 /// This is not the table.el style.
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn org_mode_table<'b, 'g, 'r, 's>(
+pub(crate) fn org_mode_table<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Table<'s>> {
@ -74,7 +74,7 @@ pub fn org_mode_table<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn detect_table<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
+pub(crate) fn detect_table<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
    tuple((start_of_line, space0, tag("|")))(input)?;
    Ok((input, ()))
 }
@ -89,7 +89,7 @@ fn table_end<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn org_mode_table_row<'b, 'g, 'r, 's>(
+fn org_mode_table_row<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, TableRow<'s>> {
@ -100,7 +100,7 @@ pub fn org_mode_table_row<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn org_mode_table_row_rule<'b, 'g, 'r, 's>(
+fn org_mode_table_row_rule<'b, 'g, 'r, 's>(
    _context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, TableRow<'s>> {
@ -117,7 +117,7 @@ pub fn org_mode_table_row_rule<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn org_mode_table_row_regular<'b, 'g, 'r, 's>(
+fn org_mode_table_row_regular<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, TableRow<'s>> {
@ -137,7 +137,7 @@ pub fn org_mode_table_row_regular<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn org_mode_table_cell<'b, 'g, 'r, 's>(
+fn org_mode_table_cell<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, TableCell<'s>> {
--- a/src/parser/target.rs
+++ b/src/parser/target.rs
@ -21,7 +21,7 @@ use crate::parser::util::get_consumed;
 use crate::types::Target;

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn target<'b, 'g, 'r, 's>(
+pub(crate) fn target<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Target<'s>> {
--- a/src/parser/text_markup.rs
+++ b/src/parser/text_markup.rs
@ -42,7 +42,7 @@ use crate::types::Underline;
 use crate::types::Verbatim;

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn text_markup<'b, 'g, 'r, 's>(
+pub(crate) fn text_markup<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Object<'s>> {
@ -60,7 +60,7 @@ pub fn text_markup<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn bold<'b, 'g, 'r, 's>(
+fn bold<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Bold<'s>> {
@ -77,7 +77,7 @@ pub fn bold<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn italic<'b, 'g, 'r, 's>(
+fn italic<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Italic<'s>> {
@ -94,7 +94,7 @@ pub fn italic<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn underline<'b, 'g, 'r, 's>(
+fn underline<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Underline<'s>> {
@ -111,7 +111,7 @@ pub fn underline<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn strike_through<'b, 'g, 'r, 's>(
+fn strike_through<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, StrikeThrough<'s>> {
@ -128,7 +128,7 @@ pub fn strike_through<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn verbatim<'b, 'g, 'r, 's>(
+fn verbatim<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Verbatim<'s>> {
@ -145,7 +145,7 @@ pub fn verbatim<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn code<'b, 'g, 'r, 's>(
+fn code<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Code<'s>> {
@ -288,7 +288,7 @@ fn _text_markup_string<'b, 'g, 'r, 's, 'c>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn pre<'b, 'g, 'r, 's>(
+fn pre<'b, 'g, 'r, 's>(
    _context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, ()> {
@ -307,7 +307,7 @@ pub fn pre<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn post<'b, 'g, 'r, 's>(
+fn post<'b, 'g, 'r, 's>(
    _context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, ()> {
--- a/src/parser/timestamp.rs
+++ b/src/parser/timestamp.rs
@ -23,7 +23,7 @@ use crate::parser::util::get_consumed;
 use crate::types::Timestamp;

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn timestamp<'b, 'g, 'r, 's>(
+pub(crate) fn timestamp<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Timestamp<'s>> {
--- a/src/parser/token.rs
+++ b/src/parser/token.rs
@ -11,7 +11,7 @@ use crate::types::Section;
 use crate::types::TableCell;
 use crate::types::TableRow;

-pub enum Token<'r, 's> {
+pub(crate) enum Token<'r, 's> {
    Document(&'r Document<'s>),
    Heading(&'r Heading<'s>),
    Section(&'r Section<'s>),
@ -24,7 +24,7 @@ pub enum Token<'r, 's> {
 }

 impl<'r, 's> Token<'r, 's> {
-    pub fn iter_tokens(&self) -> Box<dyn Iterator<Item = Token<'r, 's>> + '_> {
+    fn iter_tokens(&self) -> Box<dyn Iterator<Item = Token<'r, 's>> + '_> {
        match self {
            Token::Document(document) => Box::new(
                document
@ -109,12 +109,12 @@ impl<'r, 's> Token<'r, 's> {
    }
 }

-pub struct AllTokensIterator<'r, 's> {
+pub(crate) struct AllTokensIterator<'r, 's> {
    queued_tokens: VecDeque<Token<'r, 's>>,
 }

 impl<'r, 's> AllTokensIterator<'r, 's> {
-    pub fn new(tkn: Token<'r, 's>) -> Self {
+    pub(crate) fn new(tkn: Token<'r, 's>) -> Self {
        let mut queued_tokens = VecDeque::new();
        queued_tokens.push_back(tkn);
        AllTokensIterator { queued_tokens }
--- a/src/parser/util.rs
+++ b/src/parser/util.rs
@ -21,11 +21,11 @@ use crate::error::CustomError;
 use crate::error::MyError;
 use crate::error::Res;

-pub const WORD_CONSTITUENT_CHARACTERS: &str =
+pub(crate) const WORD_CONSTITUENT_CHARACTERS: &str =
    "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";

 /// Check if we are below a section of the given section type regardless of depth
-pub fn in_section<'b, 'g, 'r, 's, 'x>(
+pub(crate) fn in_section<'b, 'g, 'r, 's, 'x>(
    context: RefContext<'b, 'g, 'r, 's>,
    section_name: &'x str,
 ) -> bool {
@ -39,7 +39,7 @@ pub fn in_section<'b, 'g, 'r, 's, 'x>(
 }

 /// Checks if we are currently an immediate child of the given section type
-pub fn immediate_in_section<'b, 'g, 'r, 's, 'x>(
+pub(crate) fn immediate_in_section<'b, 'g, 'r, 's, 'x>(
    context: RefContext<'b, 'g, 'r, 's>,
    section_name: &'x str,
 ) -> bool {
@ -54,7 +54,7 @@ pub fn immediate_in_section<'b, 'g, 'r, 's, 'x>(
 }

 /// Check if we are below a section of the given section type regardless of depth
-pub fn in_object_section<'b, 'g, 'r, 's, 'x>(
+pub(crate) fn in_object_section<'b, 'g, 'r, 's, 'x>(
    context: RefContext<'b, 'g, 'r, 's>,
    section_name: &'x str,
 ) -> bool {
@ -68,7 +68,7 @@ pub fn in_object_section<'b, 'g, 'r, 's, 'x>(
 }

 /// Get a slice of the string that was consumed in a parser using the original input to the parser and the remaining input after the parser.
-pub fn get_consumed<'s>(input: OrgSource<'s>, remaining: OrgSource<'s>) -> OrgSource<'s> {
+pub(crate) fn get_consumed<'s>(input: OrgSource<'s>, remaining: OrgSource<'s>) -> OrgSource<'s> {
    input.get_until(remaining)
 }

@ -76,19 +76,19 @@ pub fn get_consumed<'s>(input: OrgSource<'s>, remaining: OrgSource<'s>) -> OrgSo
 ///
 /// It is up to the caller to ensure this is called at the start of a line.
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn blank_line(input: OrgSource<'_>) -> Res<OrgSource<'_>, OrgSource<'_>> {
+pub(crate) fn blank_line(input: OrgSource<'_>) -> Res<OrgSource<'_>, OrgSource<'_>> {
    not(eof)(input)?;
    recognize(tuple((space0, alt((line_ending, eof)))))(input)
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn element_trailing_whitespace<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>> {
+fn element_trailing_whitespace<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>> {
    start_of_line(input)?;
    alt((eof, recognize(many0(blank_line))))(input)
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn maybe_consume_object_trailing_whitespace_if_not_exiting<'b, 'g, 'r, 's>(
+pub(crate) fn maybe_consume_object_trailing_whitespace_if_not_exiting<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Option<OrgSource<'s>>> {
@ -104,7 +104,7 @@ pub fn maybe_consume_object_trailing_whitespace_if_not_exiting<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn maybe_consume_trailing_whitespace_if_not_exiting<'b, 'g, 'r, 's>(
+pub(crate) fn maybe_consume_trailing_whitespace_if_not_exiting<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Option<OrgSource<'s>>> {
@ -117,7 +117,7 @@ pub fn maybe_consume_trailing_whitespace_if_not_exiting<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn maybe_consume_trailing_whitespace<'b, 'g, 'r, 's>(
+pub(crate) fn maybe_consume_trailing_whitespace<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, Option<OrgSource<'s>>> {
@ -130,7 +130,7 @@ pub fn maybe_consume_trailing_whitespace<'b, 'g, 'r, 's>(

 /// Check that we are at the start of a line
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn start_of_line<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
+pub(crate) fn start_of_line<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
    if input.is_at_start_of_line() {
        Ok((input, ()))
    } else {
@ -140,7 +140,7 @@ pub fn start_of_line<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
    }
 }

-pub fn preceded_by_whitespace(
+pub(crate) fn preceded_by_whitespace(
    allow_start_of_file: bool,
 ) -> impl for<'s> Fn(OrgSource<'s>) -> Res<OrgSource<'s>, ()> {
    move |input| _preceded_by_whitespace(allow_start_of_file, input)
@ -168,13 +168,13 @@ fn _preceded_by_whitespace<'s>(
 ///
 /// This function only operates on spaces, tabs, carriage returns, and line feeds. It does not handle fancy unicode whitespace.
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn non_whitespace_character(input: OrgSource<'_>) -> Res<OrgSource<'_>, char> {
+pub(crate) fn non_whitespace_character(input: OrgSource<'_>) -> Res<OrgSource<'_>, char> {
    none_of(" \t\r\n")(input)
 }

 /// Check that we are at the start of a line
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn exit_matcher_parser<'b, 'g, 'r, 's>(
+pub(crate) fn exit_matcher_parser<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, OrgSource<'s>> {
@ -182,7 +182,7 @@ pub fn exit_matcher_parser<'b, 'g, 'r, 's>(
 }

 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn text_until_exit<'b, 'g, 'r, 's>(
+pub(crate) fn text_until_exit<'b, 'g, 'r, 's>(
    context: RefContext<'b, 'g, 'r, 's>,
    input: OrgSource<'s>,
 ) -> Res<OrgSource<'s>, OrgSource<'s>> {
@ -193,7 +193,7 @@ pub fn text_until_exit<'b, 'g, 'r, 's>(
 }

 #[allow(dead_code)]
-pub fn not_yet_implemented() -> Res<OrgSource<'static>, ()> {
+fn not_yet_implemented() -> Res<OrgSource<'static>, ()> {
    return Err(nom::Err::Error(CustomError::MyError(MyError(
        "Not implemented yet.".into(),
    ))));
@ -204,7 +204,7 @@ pub fn not_yet_implemented() -> Res<OrgSource<'static>, ()> {
 /// Text from the current point until the next line break or end of file
 ///
 /// Useful for debugging.
-pub fn text_until_eol<'r, 's>(
+fn text_until_eol<'r, 's>(
    input: OrgSource<'s>,
 ) -> Result<&'s str, nom::Err<CustomError<OrgSource<'s>>>> {
    let line = recognize(many_till(anychar, alt((line_ending, eof))))(input)
@ -212,7 +212,7 @@ pub fn text_until_eol<'r, 's>(
    Ok(line.trim())
 }

-pub fn include_input<'s, F, O>(
+pub(crate) fn include_input<'s, F, O>(
    mut inner: F,
 ) -> impl FnMut(OrgSource<'s>) -> Res<OrgSource<'s>, (OrgSource<'s>, O)>
 where
--- a/src/types/element.rs
+++ b/src/types/element.rs
@ -51,28 +51,28 @@ pub enum Element<'s> {
 impl<'s> Source<'s> for Element<'s> {
    fn get_source(&'s self) -> &'s str {
        match self {
-            Element::Paragraph(obj) => obj.source,
-            Element::PlainList(obj) => obj.source,
-            Element::GreaterBlock(obj) => obj.source,
-            Element::DynamicBlock(obj) => obj.source,
-            Element::FootnoteDefinition(obj) => obj.source,
-            Element::Comment(obj) => obj.source,
-            Element::Drawer(obj) => obj.source,
-            Element::PropertyDrawer(obj) => obj.source,
-            Element::Table(obj) => obj.source,
-            Element::VerseBlock(obj) => obj.source,
-            Element::CommentBlock(obj) => obj.source,
-            Element::ExampleBlock(obj) => obj.source,
-            Element::ExportBlock(obj) => obj.source,
-            Element::SrcBlock(obj) => obj.source,
-            Element::Clock(obj) => obj.source,
-            Element::DiarySexp(obj) => obj.source,
-            Element::Planning(obj) => obj.source,
-            Element::FixedWidthArea(obj) => obj.source,
-            Element::HorizontalRule(obj) => obj.source,
-            Element::Keyword(obj) => obj.source,
-            Element::BabelCall(obj) => obj.source,
-            Element::LatexEnvironment(obj) => obj.source,
+            Element::Paragraph(obj) => obj.get_source(),
+            Element::PlainList(obj) => obj.get_source(),
+            Element::GreaterBlock(obj) => obj.get_source(),
+            Element::DynamicBlock(obj) => obj.get_source(),
+            Element::FootnoteDefinition(obj) => obj.get_source(),
+            Element::Comment(obj) => obj.get_source(),
+            Element::Drawer(obj) => obj.get_source(),
+            Element::PropertyDrawer(obj) => obj.get_source(),
+            Element::Table(obj) => obj.get_source(),
+            Element::VerseBlock(obj) => obj.get_source(),
+            Element::CommentBlock(obj) => obj.get_source(),
+            Element::ExampleBlock(obj) => obj.get_source(),
+            Element::ExportBlock(obj) => obj.get_source(),
+            Element::SrcBlock(obj) => obj.get_source(),
+            Element::Clock(obj) => obj.get_source(),
+            Element::DiarySexp(obj) => obj.get_source(),
+            Element::Planning(obj) => obj.get_source(),
+            Element::FixedWidthArea(obj) => obj.get_source(),
+            Element::HorizontalRule(obj) => obj.get_source(),
+            Element::Keyword(obj) => obj.get_source(),
+            Element::BabelCall(obj) => obj.get_source(),
+            Element::LatexEnvironment(obj) => obj.get_source(),
        }
    }
 }
--- a/src/types/lesser_element.rs
+++ b/src/types/lesser_element.rs
@ -97,7 +97,7 @@ pub struct LatexEnvironment<'s> {
 }

 impl<'s> Paragraph<'s> {
-    pub fn of_text(input: &'s str) -> Self {
+    pub(crate) fn of_text(input: &'s str) -> Self {
        let mut objects = Vec::with_capacity(1);
        objects.push(Object::PlainText(PlainText { source: input }));
        Paragraph {
--- a/tests/test_template
+++ b/tests/test_template
@ -5,7 +5,7 @@ fn {name}() {{
    println!("{{}}", org_contents);
    let org_sexp = emacs_parse_anonymous_org_document(org_contents.as_str()).expect("Use emacs to parse org file.");
    println!("{{}}", org_sexp);
-    let (_remaining, parsed_sexp) = sexp_with_padding(org_sexp.as_str()).expect("Sexp Parse failure");
+    let (_remaining, parsed_sexp) = sexp(org_sexp.as_str()).expect("Sexp Parse failure");
    let rust_parsed = parse(org_contents.as_str()).expect("Org Parse failure");
    println!("{{:#?}}", rust_parsed);
    let diff_result =