Add children to heading.

Cargo.lock

@@ -71,6 +71,12 @@ version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "23b62fc65de8e4e7f52534fb52b0f3ed04746ae267519eef2a83941e8085068b"
 
+[[package]]
+name = "autocfg"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+
 [[package]]
 name = "backtrace"
 version = "0.3.69"
@@ -192,6 +198,95 @@ version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fed34cd105917e91daa4da6b3728c47b068749d6a62c59811f06ed2ac71d9da7"
 
+[[package]]
+name = "futures"
+version = "0.3.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da0290714b38af9b4a7b094b8a37086d1b4e61f2df9122c3cad2577669145335"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-io",
+ "futures-sink",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-channel"
+version = "0.3.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff4dd66668b557604244583e3e1e1eada8c5c2e96a6d0d6653ede395b78bbacb"
+dependencies = [
+ "futures-core",
+ "futures-sink",
+]
+
+[[package]]
+name = "futures-core"
+version = "0.3.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eb1d22c66e66d9d72e1758f0bd7d4fd0bee04cad842ee34587d68c07e45d088c"
+
+[[package]]
+name = "futures-executor"
+version = "0.3.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f4fb8693db0cf099eadcca0efe2a5a22e4550f98ed16aba6c48700da29597bc"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-io"
+version = "0.3.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8bf34a163b5c4c52d0478a4d757da8fb65cabef42ba90515efee0f6f9fa45aaa"
+
+[[package]]
+name = "futures-macro"
+version = "0.3.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53b153fd91e4b0147f4aced87be237c98248656bb01050b96bf3ee89220a8ddb"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "futures-sink"
+version = "0.3.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e36d3378ee38c2a36ad710c5d30c2911d752cb941c00c72dbabfb786a7970817"
+
+[[package]]
+name = "futures-task"
+version = "0.3.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "efd193069b0ddadc69c46389b740bbccdd97203899b48d09c5f7969591d6bae2"
+
+[[package]]
+name = "futures-util"
+version = "0.3.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a19526d624e703a3179b3d322efec918b6246ea0fa51d41124525f00f1cc8104"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-io",
+ "futures-macro",
+ "futures-sink",
+ "futures-task",
+ "memchr",
+ "pin-project-lite",
+ "pin-utils",
+ "slab",
+]
+
 [[package]]
 name = "gimli"
 version = "0.28.0"
@@ -347,6 +442,12 @@ version = "0.2.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8afb450f006bf6385ca15ef45d71d2288452bc3683ce2e2cacc0d18e4be60b58"
 
+[[package]]
+name = "pin-utils"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
+
 [[package]]
 name = "proc-macro2"
 version = "1.0.69"
@@ -432,6 +533,15 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "slab"
+version = "0.4.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67"
+dependencies = [
+ "autocfg",
+]
+
 [[package]]
 name = "static_assertions"
 version = "1.1.0"
@@ -641,6 +751,7 @@ version = "0.0.1"
 dependencies = [
  "clap",
  "duster",
+ "futures",
  "include_dir",
  "organic",
  "serde",

Cargo.toml

@@ -8,6 +8,7 @@ edition = "2021"
 [dependencies]
 clap = { version = "4.4.6", default-features = false, features = ["std", "color", "help", "derive"] }
 duster = { git = "https://code.fizz.buzz/talexander/duster.git", branch = "master" }
+futures = "0.3.29"
 include_dir = "0.7.3"
 # TODO: This is temporary to work on the latest organic code. Eventually switch back to using the published crate.
 organic = { path = "../organic" }

default_environment/templates/html/heading.dust

@@ -1 +1,11 @@
-heading
+{@lte key=.level value=4}
+  <h{.level}>{#.title}{>object/}{/.title}</h{.level}>
+{:else}
+  <ol>
+    <li>{#.title}{>object/}{/.title}</li>
+  </ol>
+{/lte}
+
+{#.children}
+  {>document_element/}
+{/.children}

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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        output_file: &Path,
         heading: &IHeading,
     ) -> Result<RenderHeading, CustomError> {
-        let title = heading
+        let title = {
-            .title
+            let mut ret = Vec::new();
-            .iter()
+            for obj in heading.title.iter() {
-            .map(|obj| RenderObject::new(config, &output_directory, &output_file, obj))
+                ret.push(RenderObject::new(
-            .collect::<Result<Vec<_>, _>>()?;
+                    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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        output_file: &Path,
         paragraph: &IParagraph,
     ) -> Result<RenderParagraph, CustomError> {
-        let children = paragraph
+        let children = {
-            .children
+            let mut ret = Vec::new();
-            .iter()
+            for obj in paragraph.children.iter() {
-            .map(|obj| RenderObject::new(config, &output_directory, &output_file, obj))
+                ret.push(RenderObject::new(
-            .collect::<Result<Vec<_>, _>>()?;
+                    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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        output_file: &Path,
         section: &ISection,
     ) -> Result<RenderSection, CustomError> {
-        let children = section
+        let children = {
-            .children
+            let mut ret = Vec::new();
-            .iter()
+            for obj in section.children.iter() {
-            .map(|obj| RenderElement::new(config, &output_directory, &output_file, obj))
+                ret.push(RenderElement::new(
-            .collect::<Result<Vec<_>, _>>()?;
+                    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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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_directory: &Path,
-        output_file: F,
+        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 {
+            children.push(RenderDocumentElement::new(
-                IDocumentElement::Heading(heading) => {
+                config,
-                    children.push(RenderDocumentElement::Heading(RenderHeading::new(
+                output_directory,
-                        config,
+                output_file,
-                        output_directory,
+                child,
-                        output_file,
+            )?);
-                        heading,
-                    )?));
-                }
-                IDocumentElement::Section(section) => {
-                    children.push(RenderDocumentElement::Section(RenderSection::new(
-                        config,
-                        output_directory,
-                        output_file,
-                        section,
-                    )?));
-                }
-            }
         }
 
         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,
         })
     }
 }