Add children to heading.

src/context/angle_link.rs

@@ -12,10 +12,10 @@ use crate::intermediate::IAngleLink;
 pub(crate) struct RenderAngleLink {}
 
 impl RenderAngleLink {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         comment: &IAngleLink,
     ) -> Result<RenderAngleLink, CustomError> {
         Ok(RenderAngleLink {})

src/context/babel_call.rs

@@ -12,10 +12,10 @@ use crate::intermediate::IBabelCall;
 pub(crate) struct RenderBabelCall {}
 
 impl RenderBabelCall {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         original: &IBabelCall,
     ) -> Result<RenderBabelCall, CustomError> {
         Ok(RenderBabelCall {})

src/context/bold.rs

@@ -12,10 +12,10 @@ use crate::intermediate::IBold;
 pub(crate) struct RenderBold {}
 
 impl RenderBold {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         comment: &IBold,
     ) -> Result<RenderBold, CustomError> {
         Ok(RenderBold {})

src/context/center_block.rs

@@ -12,10 +12,10 @@ use crate::intermediate::ICenterBlock;
 pub(crate) struct RenderCenterBlock {}
 
 impl RenderCenterBlock {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         original: &ICenterBlock,
     ) -> Result<RenderCenterBlock, CustomError> {
         Ok(RenderCenterBlock {})

src/context/citation.rs

@@ -12,10 +12,10 @@ use crate::intermediate::ICitation;
 pub(crate) struct RenderCitation {}
 
 impl RenderCitation {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         comment: &ICitation,
     ) -> Result<RenderCitation, CustomError> {
         Ok(RenderCitation {})

src/context/citation_reference.rs

@@ -12,10 +12,10 @@ use crate::intermediate::ICitationReference;
 pub(crate) struct RenderCitationReference {}
 
 impl RenderCitationReference {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         comment: &ICitationReference,
     ) -> Result<RenderCitationReference, CustomError> {
         Ok(RenderCitationReference {})

src/context/clock.rs

@@ -12,10 +12,10 @@ use crate::intermediate::IClock;
 pub(crate) struct RenderClock {}
 
 impl RenderClock {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         original: &IClock,
     ) -> Result<RenderClock, CustomError> {
         Ok(RenderClock {})

src/context/code.rs

@@ -12,10 +12,10 @@ use crate::intermediate::ICode;
 pub(crate) struct RenderCode {}
 
 impl RenderCode {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         comment: &ICode,
     ) -> Result<RenderCode, CustomError> {
         Ok(RenderCode {})

src/context/comment.rs

@@ -12,10 +12,10 @@ use crate::intermediate::IComment;
 pub(crate) struct RenderComment {}
 
 impl RenderComment {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         comment: &IComment,
     ) -> Result<RenderComment, CustomError> {
         Ok(RenderComment {})

src/context/comment_block.rs

@@ -12,10 +12,10 @@ use crate::intermediate::ICommentBlock;
 pub(crate) struct RenderCommentBlock {}
 
 impl RenderCommentBlock {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         original: &ICommentBlock,
     ) -> Result<RenderCommentBlock, CustomError> {
         Ok(RenderCommentBlock {})

src/context/diary_sexp.rs

@@ -12,10 +12,10 @@ use crate::intermediate::IDiarySexp;
 pub(crate) struct RenderDiarySexp {}
 
 impl RenderDiarySexp {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         original: &IDiarySexp,
     ) -> Result<RenderDiarySexp, CustomError> {
         Ok(RenderDiarySexp {})

src/context/document_element.rs

@@ -1,5 +1,11 @@
+use std::path::Path;
+
 use serde::Serialize;
 
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IDocumentElement;
+
 use super::RenderHeading;
 use super::RenderSection;
 
@@ -9,3 +15,21 @@ pub(crate) enum RenderDocumentElement {
     Heading(RenderHeading),
     Section(RenderSection),
 }
+
+impl RenderDocumentElement {
+    pub(crate) fn new(
+        config: &Config,
+        output_directory: &Path,
+        output_file: &Path,
+        original: &IDocumentElement,
+    ) -> Result<RenderDocumentElement, CustomError> {
+        match original {
+            IDocumentElement::Heading(inner) => Ok(RenderDocumentElement::Heading(
+                RenderHeading::new(config, output_directory, output_file, inner)?,
+            )),
+            IDocumentElement::Section(inner) => Ok(RenderDocumentElement::Section(
+                RenderSection::new(config, output_directory, output_file, inner)?,
+            )),
+        }
+    }
+}

src/context/drawer.rs

@@ -12,10 +12,10 @@ use crate::intermediate::IDrawer;
 pub(crate) struct RenderDrawer {}
 
 impl RenderDrawer {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         original: &IDrawer,
     ) -> Result<RenderDrawer, CustomError> {
         Ok(RenderDrawer {})

src/context/dynamic_block.rs

@@ -12,10 +12,10 @@ use crate::intermediate::IDynamicBlock;
 pub(crate) struct RenderDynamicBlock {}
 
 impl RenderDynamicBlock {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         original: &IDynamicBlock,
     ) -> Result<RenderDynamicBlock, CustomError> {
         Ok(RenderDynamicBlock {})

src/context/element.rs

@@ -61,10 +61,10 @@ pub(crate) enum RenderElement {
 }
 
 impl RenderElement {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         element: &IElement,
     ) -> Result<RenderElement, CustomError> {
         match element {

src/context/entity.rs

@@ -12,10 +12,10 @@ use crate::intermediate::IEntity;
 pub(crate) struct RenderEntity {}
 
 impl RenderEntity {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         comment: &IEntity,
     ) -> Result<RenderEntity, CustomError> {
         Ok(RenderEntity {})

src/context/example_block.rs

@@ -12,10 +12,10 @@ use crate::intermediate::IExampleBlock;
 pub(crate) struct RenderExampleBlock {}
 
 impl RenderExampleBlock {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         original: &IExampleBlock,
     ) -> Result<RenderExampleBlock, CustomError> {
         Ok(RenderExampleBlock {})

src/context/export_block.rs

@@ -12,10 +12,10 @@ use crate::intermediate::IExportBlock;
 pub(crate) struct RenderExportBlock {}
 
 impl RenderExportBlock {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         original: &IExportBlock,
     ) -> Result<RenderExportBlock, CustomError> {
         Ok(RenderExportBlock {})

src/context/export_snippet.rs

@@ -12,10 +12,10 @@ use crate::intermediate::IExportSnippet;
 pub(crate) struct RenderExportSnippet {}
 
 impl RenderExportSnippet {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         comment: &IExportSnippet,
     ) -> Result<RenderExportSnippet, CustomError> {
         Ok(RenderExportSnippet {})

src/context/fixed_width_area.rs

@@ -12,10 +12,10 @@ use crate::intermediate::IFixedWidthArea;
 pub(crate) struct RenderFixedWidthArea {}
 
 impl RenderFixedWidthArea {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         original: &IFixedWidthArea,
     ) -> Result<RenderFixedWidthArea, CustomError> {
         Ok(RenderFixedWidthArea {})

src/context/footnote_definition.rs

@@ -12,10 +12,10 @@ use crate::intermediate::IFootnoteDefinition;
 pub(crate) struct RenderFootnoteDefinition {}
 
 impl RenderFootnoteDefinition {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         original: &IFootnoteDefinition,
     ) -> Result<RenderFootnoteDefinition, CustomError> {
         Ok(RenderFootnoteDefinition {})

src/context/footnote_reference.rs

@@ -12,10 +12,10 @@ use crate::intermediate::IFootnoteReference;
 pub(crate) struct RenderFootnoteReference {}
 
 impl RenderFootnoteReference {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         comment: &IFootnoteReference,
     ) -> Result<RenderFootnoteReference, CustomError> {
         Ok(RenderFootnoteReference {})

src/context/heading.rs

@@ -6,6 +6,7 @@ use crate::config::Config;
 use crate::error::CustomError;
 use crate::intermediate::IHeading;
 
+use super::RenderDocumentElement;
 use super::RenderObject;
 
 #[derive(Debug, Serialize)]
@@ -14,23 +15,46 @@ use super::RenderObject;
 pub(crate) struct RenderHeading {
     level: organic::types::HeadlineLevel,
     title: Vec<RenderObject>,
+    children: Vec<RenderDocumentElement>,
 }
 
 impl RenderHeading {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         heading: &IHeading,
     ) -> Result<RenderHeading, CustomError> {
-        let title = heading
-            .title
-            .iter()
-            .map(|obj| RenderObject::new(config, &output_directory, &output_file, obj))
-            .collect::<Result<Vec<_>, _>>()?;
+        let title = {
+            let mut ret = Vec::new();
+            for obj in heading.title.iter() {
+                ret.push(RenderObject::new(
+                    config,
+                    &output_directory,
+                    &output_file,
+                    obj,
+                )?);
+            }
+            ret
+        };
+
+        let children = {
+            let mut ret = Vec::new();
+            for obj in heading.children.iter() {
+                ret.push(RenderDocumentElement::new(
+                    config,
+                    &output_directory,
+                    &output_file,
+                    obj,
+                )?);
+            }
+            ret
+        };
+
         Ok(RenderHeading {
-            level: heading.level,
+            level: heading.level + 1, // Adding 1 because the page title is going to be h1.
             title,
+            children,
         })
     }
 }

src/context/horizontal_rule.rs

@@ -12,10 +12,10 @@ use crate::intermediate::IHorizontalRule;
 pub(crate) struct RenderHorizontalRule {}
 
 impl RenderHorizontalRule {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         original: &IHorizontalRule,
     ) -> Result<RenderHorizontalRule, CustomError> {
         Ok(RenderHorizontalRule {})

src/context/inline_babel_call.rs

@@ -12,10 +12,10 @@ use crate::intermediate::IInlineBabelCall;
 pub(crate) struct RenderInlineBabelCall {}
 
 impl RenderInlineBabelCall {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         comment: &IInlineBabelCall,
     ) -> Result<RenderInlineBabelCall, CustomError> {
         Ok(RenderInlineBabelCall {})

src/context/inline_source_block.rs

@@ -12,10 +12,10 @@ use crate::intermediate::IInlineSourceBlock;
 pub(crate) struct RenderInlineSourceBlock {}
 
 impl RenderInlineSourceBlock {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         comment: &IInlineSourceBlock,
     ) -> Result<RenderInlineSourceBlock, CustomError> {
         Ok(RenderInlineSourceBlock {})

src/context/italic.rs

@@ -12,10 +12,10 @@ use crate::intermediate::IItalic;
 pub(crate) struct RenderItalic {}
 
 impl RenderItalic {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         comment: &IItalic,
     ) -> Result<RenderItalic, CustomError> {
         Ok(RenderItalic {})

src/context/keyword.rs

@@ -12,10 +12,10 @@ use crate::intermediate::IKeyword;
 pub(crate) struct RenderKeyword {}
 
 impl RenderKeyword {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         keyword: &IKeyword,
     ) -> Result<RenderKeyword, CustomError> {
         Ok(RenderKeyword {})

src/context/latex_environment.rs

@@ -12,10 +12,10 @@ use crate::intermediate::ILatexEnvironment;
 pub(crate) struct RenderLatexEnvironment {}
 
 impl RenderLatexEnvironment {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         original: &ILatexEnvironment,
     ) -> Result<RenderLatexEnvironment, CustomError> {
         Ok(RenderLatexEnvironment {})

src/context/latex_fragment.rs

@@ -12,10 +12,10 @@ use crate::intermediate::ILatexFragment;
 pub(crate) struct RenderLatexFragment {}
 
 impl RenderLatexFragment {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         comment: &ILatexFragment,
     ) -> Result<RenderLatexFragment, CustomError> {
         Ok(RenderLatexFragment {})

src/context/line_break.rs

@@ -12,10 +12,10 @@ use crate::intermediate::ILineBreak;
 pub(crate) struct RenderLineBreak {}
 
 impl RenderLineBreak {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         comment: &ILineBreak,
     ) -> Result<RenderLineBreak, CustomError> {
         Ok(RenderLineBreak {})

src/context/object.rs

@@ -67,10 +67,10 @@ pub(crate) enum RenderObject {
 }
 
 impl RenderObject {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         object: &IObject,
     ) -> Result<RenderObject, CustomError> {
         match object {

src/context/org_macro.rs

@@ -12,10 +12,10 @@ use crate::intermediate::IOrgMacro;
 pub(crate) struct RenderOrgMacro {}
 
 impl RenderOrgMacro {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         comment: &IOrgMacro,
     ) -> Result<RenderOrgMacro, CustomError> {
         Ok(RenderOrgMacro {})

src/context/paragraph.rs

@@ -16,17 +16,25 @@ pub(crate) struct RenderParagraph {
 }
 
 impl RenderParagraph {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         paragraph: &IParagraph,
     ) -> Result<RenderParagraph, CustomError> {
-        let children = paragraph
-            .children
-            .iter()
-            .map(|obj| RenderObject::new(config, &output_directory, &output_file, obj))
-            .collect::<Result<Vec<_>, _>>()?;
+        let children = {
+            let mut ret = Vec::new();
+            for obj in paragraph.children.iter() {
+                ret.push(RenderObject::new(
+                    config,
+                    &output_directory,
+                    &output_file,
+                    obj,
+                )?);
+            }
+            ret
+        };
+
         Ok(RenderParagraph { children })
     }
 }

src/context/plain_link.rs

@@ -12,10 +12,10 @@ use crate::intermediate::IPlainLink;
 pub(crate) struct RenderPlainLink {}
 
 impl RenderPlainLink {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         comment: &IPlainLink,
     ) -> Result<RenderPlainLink, CustomError> {
         Ok(RenderPlainLink {})

src/context/plain_list.rs

@@ -12,10 +12,10 @@ use crate::intermediate::IPlainList;
 pub(crate) struct RenderPlainList {}
 
 impl RenderPlainList {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         original: &IPlainList,
     ) -> Result<RenderPlainList, CustomError> {
         Ok(RenderPlainList {})

src/context/plain_text.rs

@@ -12,10 +12,10 @@ use crate::intermediate::IPlainText;
 pub(crate) struct RenderPlainText {}
 
 impl RenderPlainText {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         heading: &IPlainText,
     ) -> Result<RenderPlainText, CustomError> {
         Ok(RenderPlainText {})

src/context/planning.rs

@@ -12,10 +12,10 @@ use crate::intermediate::IPlanning;
 pub(crate) struct RenderPlanning {}
 
 impl RenderPlanning {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         original: &IPlanning,
     ) -> Result<RenderPlanning, CustomError> {
         Ok(RenderPlanning {})

src/context/property_drawer.rs

@@ -12,10 +12,10 @@ use crate::intermediate::IPropertyDrawer;
 pub(crate) struct RenderPropertyDrawer {}
 
 impl RenderPropertyDrawer {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         original: &IPropertyDrawer,
     ) -> Result<RenderPropertyDrawer, CustomError> {
         Ok(RenderPropertyDrawer {})

src/context/quote_block.rs

@@ -12,10 +12,10 @@ use crate::intermediate::IQuoteBlock;
 pub(crate) struct RenderQuoteBlock {}
 
 impl RenderQuoteBlock {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         original: &IQuoteBlock,
     ) -> Result<RenderQuoteBlock, CustomError> {
         Ok(RenderQuoteBlock {})

src/context/radio_link.rs

@@ -12,10 +12,10 @@ use crate::intermediate::IRadioLink;
 pub(crate) struct RenderRadioLink {}
 
 impl RenderRadioLink {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         comment: &IRadioLink,
     ) -> Result<RenderRadioLink, CustomError> {
         Ok(RenderRadioLink {})

src/context/radio_target.rs

@@ -12,10 +12,10 @@ use crate::intermediate::IRadioTarget;
 pub(crate) struct RenderRadioTarget {}
 
 impl RenderRadioTarget {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         comment: &IRadioTarget,
     ) -> Result<RenderRadioTarget, CustomError> {
         Ok(RenderRadioTarget {})

src/context/regular_link.rs

@@ -12,10 +12,10 @@ use crate::intermediate::IRegularLink;
 pub(crate) struct RenderRegularLink {}
 
 impl RenderRegularLink {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         comment: &IRegularLink,
     ) -> Result<RenderRegularLink, CustomError> {
         Ok(RenderRegularLink {})

src/context/section.rs

@@ -16,17 +16,24 @@ pub(crate) struct RenderSection {
 }
 
 impl RenderSection {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         section: &ISection,
     ) -> Result<RenderSection, CustomError> {
-        let children = section
-            .children
-            .iter()
-            .map(|obj| RenderElement::new(config, &output_directory, &output_file, obj))
-            .collect::<Result<Vec<_>, _>>()?;
+        let children = {
+            let mut ret = Vec::new();
+            for obj in section.children.iter() {
+                ret.push(RenderElement::new(
+                    config,
+                    &output_directory,
+                    &output_file,
+                    obj,
+                )?);
+            }
+            ret
+        };
 
         Ok(RenderSection { children })
     }

src/context/special_block.rs

@@ -12,10 +12,10 @@ use crate::intermediate::ISpecialBlock;
 pub(crate) struct RenderSpecialBlock {}
 
 impl RenderSpecialBlock {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         original: &ISpecialBlock,
     ) -> Result<RenderSpecialBlock, CustomError> {
         Ok(RenderSpecialBlock {})

src/context/src_block.rs

@@ -12,10 +12,10 @@ use crate::intermediate::ISrcBlock;
 pub(crate) struct RenderSrcBlock {}
 
 impl RenderSrcBlock {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         original: &ISrcBlock,
     ) -> Result<RenderSrcBlock, CustomError> {
         Ok(RenderSrcBlock {})

src/context/statistics_cookie.rs

@@ -12,10 +12,10 @@ use crate::intermediate::IStatisticsCookie;
 pub(crate) struct RenderStatisticsCookie {}
 
 impl RenderStatisticsCookie {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         comment: &IStatisticsCookie,
     ) -> Result<RenderStatisticsCookie, CustomError> {
         Ok(RenderStatisticsCookie {})

src/context/strike_through.rs

@@ -12,10 +12,10 @@ use crate::intermediate::IStrikeThrough;
 pub(crate) struct RenderStrikeThrough {}
 
 impl RenderStrikeThrough {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         comment: &IStrikeThrough,
     ) -> Result<RenderStrikeThrough, CustomError> {
         Ok(RenderStrikeThrough {})

src/context/subscript.rs

@@ -12,10 +12,10 @@ use crate::intermediate::ISubscript;
 pub(crate) struct RenderSubscript {}
 
 impl RenderSubscript {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         comment: &ISubscript,
     ) -> Result<RenderSubscript, CustomError> {
         Ok(RenderSubscript {})

src/context/superscript.rs

@@ -12,10 +12,10 @@ use crate::intermediate::ISuperscript;
 pub(crate) struct RenderSuperscript {}
 
 impl RenderSuperscript {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         comment: &ISuperscript,
     ) -> Result<RenderSuperscript, CustomError> {
         Ok(RenderSuperscript {})

src/context/table.rs

@@ -12,10 +12,10 @@ use crate::intermediate::ITable;
 pub(crate) struct RenderTable {}
 
 impl RenderTable {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         original: &ITable,
     ) -> Result<RenderTable, CustomError> {
         Ok(RenderTable {})

src/context/target.rs

@@ -14,10 +14,10 @@ pub(crate) struct RenderTarget {
 }
 
 impl RenderTarget {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         target: &ITarget,
     ) -> Result<RenderTarget, CustomError> {
         Ok(RenderTarget {

src/context/timestamp.rs

@@ -12,10 +12,10 @@ use crate::intermediate::ITimestamp;
 pub(crate) struct RenderTimestamp {}
 
 impl RenderTimestamp {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         comment: &ITimestamp,
     ) -> Result<RenderTimestamp, CustomError> {
         Ok(RenderTimestamp {})

src/context/underline.rs

@@ -12,10 +12,10 @@ use crate::intermediate::IUnderline;
 pub(crate) struct RenderUnderline {}
 
 impl RenderUnderline {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         comment: &IUnderline,
     ) -> Result<RenderUnderline, CustomError> {
         Ok(RenderUnderline {})

src/context/verbatim.rs

@@ -12,10 +12,10 @@ use crate::intermediate::IVerbatim;
 pub(crate) struct RenderVerbatim {}
 
 impl RenderVerbatim {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         comment: &IVerbatim,
     ) -> Result<RenderVerbatim, CustomError> {
         Ok(RenderVerbatim {})

src/context/verse_block.rs

@@ -12,10 +12,10 @@ use crate::intermediate::IVerseBlock;
 pub(crate) struct RenderVerseBlock {}
 
 impl RenderVerseBlock {
-    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+    pub(crate) fn new(
         config: &Config,
-        output_directory: D,
-        output_file: F,
+        output_directory: &Path,
+        output_file: &Path,
         original: &IVerseBlock,
     ) -> Result<RenderVerseBlock, CustomError> {
         Ok(RenderVerseBlock {})

src/intermediate/convert.rs

@@ -6,13 +6,10 @@ use crate::config::Config;
 use crate::context::GlobalSettings;
 use crate::context::RenderBlogPostPage;
 use crate::context::RenderDocumentElement;
-use crate::context::RenderHeading;
-use crate::context::RenderSection;
 use crate::error::CustomError;
 
 use super::BlogPost;
 use super::BlogPostPage;
-use super::IDocumentElement;
 
 pub(crate) fn convert_blog_post_page_to_render_context<D: AsRef<Path>, F: AsRef<Path>>(
     config: &Config,
@@ -47,24 +44,12 @@ pub(crate) fn convert_blog_post_page_to_render_context<D: AsRef<Path>, F: AsRef<
         let mut children = Vec::new();
 
         for child in page.children.iter() {
-            match child {
-                IDocumentElement::Heading(heading) => {
-                    children.push(RenderDocumentElement::Heading(RenderHeading::new(
-                        config,
-                        output_directory,
-                        output_file,
-                        heading,
-                    )?));
-                }
-                IDocumentElement::Section(section) => {
-                    children.push(RenderDocumentElement::Section(RenderSection::new(
-                        config,
-                        output_directory,
-                        output_file,
-                        section,
-                    )?));
-                }
-            }
+            children.push(RenderDocumentElement::new(
+                config,
+                output_directory,
+                output_file,
+                child,
+            )?);
         }
 
         children

src/intermediate/document_element.rs

@@ -1,8 +1,31 @@
+use crate::error::CustomError;
+
+use super::registry::Registry;
 use super::IHeading;
 use super::ISection;
+use futures::future::{BoxFuture, FutureExt};
 
 #[derive(Debug)]
 pub(crate) enum IDocumentElement {
     Heading(IHeading),
     Section(ISection),
 }
+
+impl IDocumentElement {
+    pub(crate) fn new<'parse, 'b>(
+        registry: &'b mut Registry<'parse>,
+        original: &'b organic::types::DocumentElement<'parse>,
+    ) -> BoxFuture<'b, Result<IDocumentElement, CustomError>> {
+        async move {
+            match original {
+                organic::types::DocumentElement::Heading(inner) => Ok(IDocumentElement::Heading(
+                    IHeading::new(registry, inner).await?,
+                )),
+                organic::types::DocumentElement::Section(inner) => Ok(IDocumentElement::Section(
+                    ISection::new(registry, inner).await?,
+                )),
+            }
+        }
+        .boxed()
+    }
+}

src/intermediate/heading.rs

@@ -1,12 +1,14 @@
 use crate::error::CustomError;
 
 use super::registry::Registry;
+use super::IDocumentElement;
 use super::IObject;
 
 #[derive(Debug)]
 pub(crate) struct IHeading {
     pub(crate) level: organic::types::HeadlineLevel,
     pub(crate) title: Vec<IObject>,
+    pub(crate) children: Vec<IDocumentElement>,
 }
 
 impl IHeading {
@@ -21,9 +23,17 @@ impl IHeading {
             }
             ret
         };
+        let children = {
+            let mut ret = Vec::new();
+            for obj in heading.children.iter() {
+                ret.push(IDocumentElement::new(registry, obj).await?);
+            }
+            ret
+        };
         Ok(IHeading {
             title,
             level: heading.level,
+            children,
         })
     }
 }