Add the skeletons for the objects.

src/context/angle_link.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IAngleLink;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "angle_link")]
+pub(crate) struct RenderAngleLink {}
+
+impl RenderAngleLink {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &IAngleLink,
+    ) -> Result<RenderAngleLink, CustomError> {
+        Ok(RenderAngleLink {})
+    }
+}

src/context/bold.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IBold;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "bold")]
+pub(crate) struct RenderBold {}
+
+impl RenderBold {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &IBold,
+    ) -> Result<RenderBold, CustomError> {
+        Ok(RenderBold {})
+    }
+}

src/context/citation.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::ICitation;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "citation")]
+pub(crate) struct RenderCitation {}
+
+impl RenderCitation {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &ICitation,
+    ) -> Result<RenderCitation, CustomError> {
+        Ok(RenderCitation {})
+    }
+}

src/context/citation_reference.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::ICitationReference;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "citation_reference")]
+pub(crate) struct RenderCitationReference {}
+
+impl RenderCitationReference {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &ICitationReference,
+    ) -> Result<RenderCitationReference, CustomError> {
+        Ok(RenderCitationReference {})
+    }
+}

src/context/code.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::ICode;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "code")]
+pub(crate) struct RenderCode {}
+
+impl RenderCode {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &ICode,
+    ) -> Result<RenderCode, CustomError> {
+        Ok(RenderCode {})
+    }
+}

src/context/entity.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IEntity;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "entity")]
+pub(crate) struct RenderEntity {}
+
+impl RenderEntity {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &IEntity,
+    ) -> Result<RenderEntity, CustomError> {
+        Ok(RenderEntity {})
+    }
+}

src/context/export_snippet.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IExportSnippet;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "export_snippet")]
+pub(crate) struct RenderExportSnippet {}
+
+impl RenderExportSnippet {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &IExportSnippet,
+    ) -> Result<RenderExportSnippet, CustomError> {
+        Ok(RenderExportSnippet {})
+    }
+}

src/context/footnote_reference.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IFootnoteReference;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "footnote_reference")]
+pub(crate) struct RenderFootnoteReference {}
+
+impl RenderFootnoteReference {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &IFootnoteReference,
+    ) -> Result<RenderFootnoteReference, CustomError> {
+        Ok(RenderFootnoteReference {})
+    }
+}

src/context/inline_babel_call.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IInlineBabelCall;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "inline_babel_call")]
+pub(crate) struct RenderInlineBabelCall {}
+
+impl RenderInlineBabelCall {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &IInlineBabelCall,
+    ) -> Result<RenderInlineBabelCall, CustomError> {
+        Ok(RenderInlineBabelCall {})
+    }
+}

src/context/inline_source_block.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IInlineSourceBlock;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "inline_source_block")]
+pub(crate) struct RenderInlineSourceBlock {}
+
+impl RenderInlineSourceBlock {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &IInlineSourceBlock,
+    ) -> Result<RenderInlineSourceBlock, CustomError> {
+        Ok(RenderInlineSourceBlock {})
+    }
+}

src/context/italic.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IItalic;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "italic")]
+pub(crate) struct RenderItalic {}
+
+impl RenderItalic {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &IItalic,
+    ) -> Result<RenderItalic, CustomError> {
+        Ok(RenderItalic {})
+    }
+}

src/context/latex_fragment.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::ILatexFragment;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "latex_fragment")]
+pub(crate) struct RenderLatexFragment {}
+
+impl RenderLatexFragment {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &ILatexFragment,
+    ) -> Result<RenderLatexFragment, CustomError> {
+        Ok(RenderLatexFragment {})
+    }
+}

src/context/line_break.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::ILineBreak;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "line_break")]
+pub(crate) struct RenderLineBreak {}
+
+impl RenderLineBreak {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &ILineBreak,
+    ) -> Result<RenderLineBreak, CustomError> {
+        Ok(RenderLineBreak {})
+    }
+}

src/context/mod.rs

@@ -1,7 +1,12 @@
+mod angle_link;
 mod babel_call;
 mod blog_post_page;
+mod bold;
 mod center_block;
+mod citation;
+mod citation_reference;
 mod clock;
+mod code;
 mod comment;
 mod comment_block;
 mod diary_sexp;
@@ -9,27 +14,47 @@ mod document_element;
 mod drawer;
 mod dynamic_block;
 mod element;
+mod entity;
 mod example_block;
 mod export_block;
+mod export_snippet;
 mod fixed_width_area;
 mod footnote_definition;
+mod footnote_reference;
 mod global_settings;
 mod heading;
 mod horizontal_rule;
+mod inline_babel_call;
+mod inline_source_block;
+mod italic;
 mod keyword;
 mod latex_environment;
+mod latex_fragment;
+mod line_break;
 mod object;
+mod org_macro;
 mod paragraph;
+mod plain_link;
 mod plain_list;
 mod plain_text;
 mod planning;
 mod property_drawer;
 mod quote_block;
+mod radio_link;
+mod radio_target;
+mod regular_link;
 mod section;
 mod special_block;
 mod src_block;
+mod statistics_cookie;
+mod strike_through;
+mod subscript;
+mod superscript;
 mod table;
 mod target;
+mod timestamp;
+mod underline;
+mod verbatim;
 mod verse_block;
 
 pub(crate) use blog_post_page::RenderBlogPostPage;

src/context/object.rs

@@ -6,14 +6,64 @@ use crate::config::Config;
 use crate::error::CustomError;
 use crate::intermediate::IObject;
 
+use super::angle_link::RenderAngleLink;
+use super::bold::RenderBold;
+use super::citation::RenderCitation;
+use super::citation_reference::RenderCitationReference;
+use super::code::RenderCode;
+use super::entity::RenderEntity;
+use super::export_snippet::RenderExportSnippet;
+use super::footnote_reference::RenderFootnoteReference;
+use super::inline_babel_call::RenderInlineBabelCall;
+use super::inline_source_block::RenderInlineSourceBlock;
+use super::italic::RenderItalic;
+use super::latex_fragment::RenderLatexFragment;
+use super::line_break::RenderLineBreak;
+use super::org_macro::RenderOrgMacro;
+use super::plain_link::RenderPlainLink;
 use super::plain_text::RenderPlainText;
+use super::radio_link::RenderRadioLink;
+use super::radio_target::RenderRadioTarget;
+use super::regular_link::RenderRegularLink;
+use super::statistics_cookie::RenderStatisticsCookie;
+use super::strike_through::RenderStrikeThrough;
+use super::subscript::RenderSubscript;
+use super::superscript::RenderSuperscript;
 use super::target::RenderTarget;
+use super::timestamp::RenderTimestamp;
+use super::underline::RenderUnderline;
+use super::verbatim::RenderVerbatim;
 
 #[derive(Debug, Serialize)]
 #[serde(untagged)]
 pub(crate) enum RenderObject {
+    Bold(RenderBold),
+    Italic(RenderItalic),
+    Underline(RenderUnderline),
+    StrikeThrough(RenderStrikeThrough),
+    Code(RenderCode),
+    Verbatim(RenderVerbatim),
     PlainText(RenderPlainText),
+    RegularLink(RenderRegularLink),
+    RadioLink(RenderRadioLink),
+    RadioTarget(RenderRadioTarget),
+    PlainLink(RenderPlainLink),
+    AngleLink(RenderAngleLink),
+    OrgMacro(RenderOrgMacro),
+    Entity(RenderEntity),
+    LatexFragment(RenderLatexFragment),
+    ExportSnippet(RenderExportSnippet),
+    FootnoteReference(RenderFootnoteReference),
+    Citation(RenderCitation),
+    CitationReference(RenderCitationReference),
+    InlineBabelCall(RenderInlineBabelCall),
+    InlineSourceBlock(RenderInlineSourceBlock),
+    LineBreak(RenderLineBreak),
     Target(RenderTarget),
+    StatisticsCookie(RenderStatisticsCookie),
+    Subscript(RenderSubscript),
+    Superscript(RenderSuperscript),
+    Timestamp(RenderTimestamp),
 }
 
 impl RenderObject {
@@ -24,18 +74,144 @@ impl RenderObject {
         object: &IObject,
     ) -> Result<RenderObject, CustomError> {
         match object {
+            IObject::Bold(inner) => Ok(RenderObject::Bold(RenderBold::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IObject::Italic(inner) => Ok(RenderObject::Italic(RenderItalic::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IObject::Underline(inner) => Ok(RenderObject::Underline(RenderUnderline::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IObject::StrikeThrough(inner) => Ok(RenderObject::StrikeThrough(
+                RenderStrikeThrough::new(config, output_directory, output_file, inner)?,
+            )),
+            IObject::Code(inner) => Ok(RenderObject::Code(RenderCode::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IObject::Verbatim(inner) => Ok(RenderObject::Verbatim(RenderVerbatim::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
             IObject::PlainText(inner) => Ok(RenderObject::PlainText(RenderPlainText::new(
                 config,
                 output_directory,
                 output_file,
                 inner,
             )?)),
+            IObject::RegularLink(inner) => Ok(RenderObject::RegularLink(RenderRegularLink::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IObject::RadioLink(inner) => Ok(RenderObject::RadioLink(RenderRadioLink::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IObject::RadioTarget(inner) => Ok(RenderObject::RadioTarget(RenderRadioTarget::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IObject::PlainLink(inner) => Ok(RenderObject::PlainLink(RenderPlainLink::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IObject::AngleLink(inner) => Ok(RenderObject::AngleLink(RenderAngleLink::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IObject::OrgMacro(inner) => Ok(RenderObject::OrgMacro(RenderOrgMacro::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IObject::Entity(inner) => Ok(RenderObject::Entity(RenderEntity::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IObject::LatexFragment(inner) => Ok(RenderObject::LatexFragment(
+                RenderLatexFragment::new(config, output_directory, output_file, inner)?,
+            )),
+            IObject::ExportSnippet(inner) => Ok(RenderObject::ExportSnippet(
+                RenderExportSnippet::new(config, output_directory, output_file, inner)?,
+            )),
+            IObject::FootnoteReference(inner) => Ok(RenderObject::FootnoteReference(
+                RenderFootnoteReference::new(config, output_directory, output_file, inner)?,
+            )),
+            IObject::Citation(inner) => Ok(RenderObject::Citation(RenderCitation::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IObject::CitationReference(inner) => Ok(RenderObject::CitationReference(
+                RenderCitationReference::new(config, output_directory, output_file, inner)?,
+            )),
+            IObject::InlineBabelCall(inner) => Ok(RenderObject::InlineBabelCall(
+                RenderInlineBabelCall::new(config, output_directory, output_file, inner)?,
+            )),
+            IObject::InlineSourceBlock(inner) => Ok(RenderObject::InlineSourceBlock(
+                RenderInlineSourceBlock::new(config, output_directory, output_file, inner)?,
+            )),
+            IObject::LineBreak(inner) => Ok(RenderObject::LineBreak(RenderLineBreak::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
             IObject::Target(inner) => Ok(RenderObject::Target(RenderTarget::new(
                 config,
                 output_directory,
                 output_file,
                 inner,
             )?)),
+            IObject::StatisticsCookie(inner) => Ok(RenderObject::StatisticsCookie(
+                RenderStatisticsCookie::new(config, output_directory, output_file, inner)?,
+            )),
+            IObject::Subscript(inner) => Ok(RenderObject::Subscript(RenderSubscript::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IObject::Superscript(inner) => Ok(RenderObject::Superscript(RenderSuperscript::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
+            IObject::Timestamp(inner) => Ok(RenderObject::Timestamp(RenderTimestamp::new(
+                config,
+                output_directory,
+                output_file,
+                inner,
+            )?)),
         }
     }
 }

src/context/org_macro.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IOrgMacro;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "org_macro")]
+pub(crate) struct RenderOrgMacro {}
+
+impl RenderOrgMacro {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &IOrgMacro,
+    ) -> Result<RenderOrgMacro, CustomError> {
+        Ok(RenderOrgMacro {})
+    }
+}

src/context/plain_link.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IPlainLink;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "plain_link")]
+pub(crate) struct RenderPlainLink {}
+
+impl RenderPlainLink {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &IPlainLink,
+    ) -> Result<RenderPlainLink, CustomError> {
+        Ok(RenderPlainLink {})
+    }
+}

src/context/radio_link.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IRadioLink;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "radio_link")]
+pub(crate) struct RenderRadioLink {}
+
+impl RenderRadioLink {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &IRadioLink,
+    ) -> Result<RenderRadioLink, CustomError> {
+        Ok(RenderRadioLink {})
+    }
+}

src/context/radio_target.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IRadioTarget;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "radio_target")]
+pub(crate) struct RenderRadioTarget {}
+
+impl RenderRadioTarget {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &IRadioTarget,
+    ) -> Result<RenderRadioTarget, CustomError> {
+        Ok(RenderRadioTarget {})
+    }
+}

src/context/regular_link.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IRegularLink;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "regular_link")]
+pub(crate) struct RenderRegularLink {}
+
+impl RenderRegularLink {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &IRegularLink,
+    ) -> Result<RenderRegularLink, CustomError> {
+        Ok(RenderRegularLink {})
+    }
+}

src/context/statistics_cookie.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IStatisticsCookie;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "statistics_cookie")]
+pub(crate) struct RenderStatisticsCookie {}
+
+impl RenderStatisticsCookie {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &IStatisticsCookie,
+    ) -> Result<RenderStatisticsCookie, CustomError> {
+        Ok(RenderStatisticsCookie {})
+    }
+}

src/context/strike_through.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IStrikeThrough;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "strike_through")]
+pub(crate) struct RenderStrikeThrough {}
+
+impl RenderStrikeThrough {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &IStrikeThrough,
+    ) -> Result<RenderStrikeThrough, CustomError> {
+        Ok(RenderStrikeThrough {})
+    }
+}

src/context/subscript.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::ISubscript;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "subscript")]
+pub(crate) struct RenderSubscript {}
+
+impl RenderSubscript {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &ISubscript,
+    ) -> Result<RenderSubscript, CustomError> {
+        Ok(RenderSubscript {})
+    }
+}

src/context/superscript.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::ISuperscript;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "superscript")]
+pub(crate) struct RenderSuperscript {}
+
+impl RenderSuperscript {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &ISuperscript,
+    ) -> Result<RenderSuperscript, CustomError> {
+        Ok(RenderSuperscript {})
+    }
+}

src/context/timestamp.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::ITimestamp;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "timestamp")]
+pub(crate) struct RenderTimestamp {}
+
+impl RenderTimestamp {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &ITimestamp,
+    ) -> Result<RenderTimestamp, CustomError> {
+        Ok(RenderTimestamp {})
+    }
+}

src/context/underline.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IUnderline;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "underline")]
+pub(crate) struct RenderUnderline {}
+
+impl RenderUnderline {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &IUnderline,
+    ) -> Result<RenderUnderline, CustomError> {
+        Ok(RenderUnderline {})
+    }
+}

src/context/verbatim.rs

@@ -0,0 +1,23 @@
+use std::path::Path;
+
+use serde::Serialize;
+
+use crate::config::Config;
+use crate::error::CustomError;
+use crate::intermediate::IVerbatim;
+
+#[derive(Debug, Serialize)]
+#[serde(tag = "type")]
+#[serde(rename = "verbatim")]
+pub(crate) struct RenderVerbatim {}
+
+impl RenderVerbatim {
+    pub(crate) fn new<D: AsRef<Path>, F: AsRef<Path>>(
+        config: &Config,
+        output_directory: D,
+        output_file: F,
+        comment: &IVerbatim,
+    ) -> Result<RenderVerbatim, CustomError> {
+        Ok(RenderVerbatim {})
+    }
+}