Only include sexp module if compare feature is enabled.

src/compare/diff.rs

@@ -86,7 +86,7 @@ pub struct DiffResult<'s> {
 }
 
 #[derive(Debug, PartialEq)]
-pub enum DiffStatus {
+enum DiffStatus {
     Good,
     Bad,
 }

src/compare/util.rs

@@ -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>> {

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(crate) exit_matcher: &'r DynContextMatcher<'r>,
-    pub class: ExitClass,
+    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,

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,

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 {

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>,
 }
 

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(crate) type RefContext<'b, 'g, 'r, 's> = &'b Context<'g, 'r, 's>;
-pub trait ContextMatcher = for<'b, 'g, 'r, 's> Fn(
+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;
+type DynContextMatcher<'c> = dyn ContextMatcher + 'c;
-pub trait Matcher = for<'s> Fn(OrgSource<'s>) -> Res<OrgSource<'s>, OrgSource<'s>>;
+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(crate) use context::Context;
-pub use context::ContextElement;
+pub(crate) use context::ContextElement;
-pub use context::ExitMatcherNode;
+pub(crate) use context::ExitMatcherNode;
-pub use exiting::ExitClass;
+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;

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 {

src/error/mod.rs

@@ -1,4 +1,4 @@
 mod error;
-pub use error::CustomError;
+pub(crate) use error::CustomError;
-pub use error::MyError;
+pub(crate) use error::MyError;
-pub use error::Res;
+pub(crate) use error::Res;

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(())
 }

src/lib.rs

@@ -1,6 +1,7 @@
 #![feature(round_char_boundary)]
 #![feature(exit_status_error)]
 #![feature(trait_alias)]
+// TODO: #![warn(missing_docs)]
 
 #[cfg(feature = "compare")]
 mod compare;
@@ -20,5 +21,6 @@ mod error;
 pub mod parser;
 pub mod types;
 
+pub use context::FileAccessInterface;
 pub use context::GlobalSettings;
 pub use context::LocalFileAccessInterface;

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>> {

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>> {

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

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>> {

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,

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, ()))
 }

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))
     }
 }

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>> {

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>> {

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>, ()>
 {

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>> {

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>> {

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,

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, ()))
 }

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>> {

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>> {

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, ()))
 }

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>> {

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> {

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>> {

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>> {

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>> {

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)),

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>> {

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>, ()> {

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>> {

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>> {

src/parser/mod.rs

@@ -37,6 +37,7 @@ mod property_drawer;
 mod radio_link;
 mod regular_link;
 mod section;
+#[cfg(feature = "compare")]
 pub mod sexp;
 mod statistics_cookie;
 mod subscript_and_superscript;
@@ -46,7 +47,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;

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>, ()> {

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>> {

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 {

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>> {

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>> {

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>> {

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>,

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>> {

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>> {

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>,

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>>> {

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>> {

src/parser/sexp.rs

@@ -31,8 +31,8 @@ pub enum Token<'s> {
 
 #[derive(Debug)]
 pub struct TextWithProperties<'s> {
-    pub text: &'s str,
+    pub(crate) text: &'s str,
-    pub properties: Vec<Token<'s>>,
+    pub(crate) properties: Vec<Token<'s>>,
 }
 
 enum ParseState {
@@ -41,35 +41,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 +99,7 @@ impl<'s> Token<'s> {
     }
 }
 
-pub fn unquote(text: &str) -> Result<String, Box<dyn std::error::Error>> {
+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());
@@ -143,7 +147,7 @@ pub fn sexp_with_padding<'s>(input: &'s str) -> Res<&'s str, Token<'s>> {
 }
 
 #[cfg_attr(feature = "tracing", tracing::instrument(ret, level = "debug"))]
-pub fn sexp<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, Token<'s>> {
+fn sexp<'s>(input: OrgSource<'s>) -> Res<OrgSource<'s>, Token<'s>> {
     let (remaining, tkn) = token(input)?;
     Ok((remaining, tkn))
 }

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>> {

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>> {

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>> {

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>> {

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>, ()> {

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>> {

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 }

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

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::Paragraph(obj) => obj.get_source(),
-            Element::PlainList(obj) => obj.source,
+            Element::PlainList(obj) => obj.get_source(),
-            Element::GreaterBlock(obj) => obj.source,
+            Element::GreaterBlock(obj) => obj.get_source(),
-            Element::DynamicBlock(obj) => obj.source,
+            Element::DynamicBlock(obj) => obj.get_source(),
-            Element::FootnoteDefinition(obj) => obj.source,
+            Element::FootnoteDefinition(obj) => obj.get_source(),
-            Element::Comment(obj) => obj.source,
+            Element::Comment(obj) => obj.get_source(),
-            Element::Drawer(obj) => obj.source,
+            Element::Drawer(obj) => obj.get_source(),
-            Element::PropertyDrawer(obj) => obj.source,
+            Element::PropertyDrawer(obj) => obj.get_source(),
-            Element::Table(obj) => obj.source,
+            Element::Table(obj) => obj.get_source(),
-            Element::VerseBlock(obj) => obj.source,
+            Element::VerseBlock(obj) => obj.get_source(),
-            Element::CommentBlock(obj) => obj.source,
+            Element::CommentBlock(obj) => obj.get_source(),
-            Element::ExampleBlock(obj) => obj.source,
+            Element::ExampleBlock(obj) => obj.get_source(),
-            Element::ExportBlock(obj) => obj.source,
+            Element::ExportBlock(obj) => obj.get_source(),
-            Element::SrcBlock(obj) => obj.source,
+            Element::SrcBlock(obj) => obj.get_source(),
-            Element::Clock(obj) => obj.source,
+            Element::Clock(obj) => obj.get_source(),
-            Element::DiarySexp(obj) => obj.source,
+            Element::DiarySexp(obj) => obj.get_source(),
-            Element::Planning(obj) => obj.source,
+            Element::Planning(obj) => obj.get_source(),
-            Element::FixedWidthArea(obj) => obj.source,
+            Element::FixedWidthArea(obj) => obj.get_source(),
-            Element::HorizontalRule(obj) => obj.source,
+            Element::HorizontalRule(obj) => obj.get_source(),
-            Element::Keyword(obj) => obj.source,
+            Element::Keyword(obj) => obj.get_source(),
-            Element::BabelCall(obj) => obj.source,
+            Element::BabelCall(obj) => obj.get_source(),
-            Element::LatexEnvironment(obj) => obj.source,
+            Element::LatexEnvironment(obj) => obj.get_source(),
         }
     }
 }

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 {