From df29763019ff865949deb9989e79714dc0a7fd67 Mon Sep 17 00:00:00 2001
From: Manuel Amstutz <manuel.amstutz@orphis.ch>
Date: Mon, 10 Jun 2024 08:11:48 +0200
Subject: [PATCH 1/4] Allow & and | in conditions!!

---
 DocxTemplater.Test/PatternMatcherTest.cs | 1 +
 DocxTemplater/PatterMatcher.cs           | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/DocxTemplater.Test/PatternMatcherTest.cs b/DocxTemplater.Test/PatternMatcherTest.cs
index 94286c2..4c702ab 100644
--- a/DocxTemplater.Test/PatternMatcherTest.cs
+++ b/DocxTemplater.Test/PatternMatcherTest.cs
@@ -40,6 +40,7 @@ static IEnumerable TestPatternMatch_Cases()
             yield return new TestCaseData("{?{!MyBool}}").Returns(new[] { PatternType.Condition });
             yield return new TestCaseData("{ ? { MyBool}}").Returns(new[] { PatternType.Condition });
             yield return new TestCaseData("{?{  a / 20 >= 12 }}").Returns(new[] { PatternType.Condition });
+            yield return new TestCaseData("{?{  a / 20 >= 12 && a.b == true || !b.c }}").Returns(new[] { PatternType.Condition });
             yield return new TestCaseData("{{var}:F(d)}").Returns(new[] { PatternType.Variable });
             yield return new TestCaseData("{{ds.foo.var}:f('HH : mm : s')}").Returns(new[] { PatternType.Variable }).SetName("Format with date pattern");
             yield return new TestCaseData("{{ds.foo.var}:f(HH:mm)}").Returns(new[] { PatternType.Variable }).SetName("Format with date pattern");
diff --git a/DocxTemplater/PatterMatcher.cs b/DocxTemplater/PatterMatcher.cs
index 1485d1c..ba38c21 100644
--- a/DocxTemplater/PatterMatcher.cs
+++ b/DocxTemplater/PatterMatcher.cs
@@ -25,7 +25,7 @@ internal static class PatternMatcher
                                                                     (?<separator>:\s*s\s*:) |
                                                                     (?<else>(?:else)|:) |
                                                                     (?(condMarker) # if condition marker is set, we expect a condition
-                                                                        (?<condition>[a-zA-Z0-9+\-*\/><=\s\.\!]+)? #condition name (without brackets)
+                                                                        (?<condition>[a-zA-Z0-9+\-*\/><=\s\.\!&\|]+)? #condition name (without brackets)
                                                                         |
                                                                         (?:
                                                                             (?<prefix>[\/\#])?(?<varname>[a-zA-Z0-9\._]+)? #variable name

From 159d6d485ced20a8cd82d5fbf5c61be727356ef6 Mon Sep 17 00:00:00 2001
From: Manuel Amstutz <manuel.amstutz@orphis.ch>
Date: Tue, 11 Jun 2024 13:34:48 +0200
Subject: [PATCH 2/4] Markdown Formatter

---
 .../DocxTemplater.Markdown.csproj             |  15 +
 .../MarkDownFormatterConfiguration.cs         |  66 ++
 DocxTemplater.Markdown/MarkdownFormatter.cs   |  52 +
 .../MarkdownToOpenXmlRenderer.cs              | 183 ++++
 .../Renderer/HeadingRenderer.cs               |  21 +
 .../Inlines/EmphasisInlineRenderer.cs         |  26 +
 .../Renderer/Inlines/LineBreakLineRenderer.cs |  16 +
 .../Renderer/Inlines/LiteralInlineRenderer.cs |  12 +
 .../Renderer/ListRenderer.cs                  | 200 ++++
 .../Renderer/OpenXmlObjectRenderer.cs         |   9 +
 .../Renderer/ParagraphRenderer.cs             |  18 +
 .../Renderer/TableRenderer.cs                 |  85 ++
 .../Renderer/ThematicBreakRenderer.cs         |  33 +
 DocxTemplater.Test/DocxTemplater.Test.csproj  | 140 +--
 DocxTemplater.Test/MarkdownRendererTest.cs    | 300 ++++++
 .../Resources/MarkdownTestTemplate.docx       | Bin 0 -> 15412 bytes
 DocxTemplater.Test/Resources/TestMarkDown.md  |  65 ++
 DocxTemplater.sln                             | 112 +-
 DocxTemplater/OpenXmlHelper.cs                | 958 +++++++++---------
 19 files changed, 1736 insertions(+), 575 deletions(-)
 create mode 100644 DocxTemplater.Markdown/DocxTemplater.Markdown.csproj
 create mode 100644 DocxTemplater.Markdown/MarkDownFormatterConfiguration.cs
 create mode 100644 DocxTemplater.Markdown/MarkdownFormatter.cs
 create mode 100644 DocxTemplater.Markdown/MarkdownToOpenXmlRenderer.cs
 create mode 100644 DocxTemplater.Markdown/Renderer/HeadingRenderer.cs
 create mode 100644 DocxTemplater.Markdown/Renderer/Inlines/EmphasisInlineRenderer.cs
 create mode 100644 DocxTemplater.Markdown/Renderer/Inlines/LineBreakLineRenderer.cs
 create mode 100644 DocxTemplater.Markdown/Renderer/Inlines/LiteralInlineRenderer.cs
 create mode 100644 DocxTemplater.Markdown/Renderer/ListRenderer.cs
 create mode 100644 DocxTemplater.Markdown/Renderer/OpenXmlObjectRenderer.cs
 create mode 100644 DocxTemplater.Markdown/Renderer/ParagraphRenderer.cs
 create mode 100644 DocxTemplater.Markdown/Renderer/TableRenderer.cs
 create mode 100644 DocxTemplater.Markdown/Renderer/ThematicBreakRenderer.cs
 create mode 100644 DocxTemplater.Test/MarkdownRendererTest.cs
 create mode 100644 DocxTemplater.Test/Resources/MarkdownTestTemplate.docx
 create mode 100644 DocxTemplater.Test/Resources/TestMarkDown.md

diff --git a/DocxTemplater.Markdown/DocxTemplater.Markdown.csproj b/DocxTemplater.Markdown/DocxTemplater.Markdown.csproj
new file mode 100644
index 0000000..4f8a152
--- /dev/null
+++ b/DocxTemplater.Markdown/DocxTemplater.Markdown.csproj
@@ -0,0 +1,15 @@
+<Project Sdk="Microsoft.NET.Sdk">
+	<PropertyGroup>
+		<GeneratePackageOnBuild>True</GeneratePackageOnBuild>
+	</PropertyGroup>
+	<ItemGroup>
+		<PackageReference Include="GitVersion.MsBuild" Version="5.12.0">
+			<PrivateAssets>all</PrivateAssets>
+			<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+		</PackageReference>
+		<PackageReference Include="Markdig" Version="0.37.0" />
+	</ItemGroup>
+	<ItemGroup>
+		<ProjectReference Include="..\DocxTemplater\DocxTemplater.csproj" />
+	</ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/DocxTemplater.Markdown/MarkDownFormatterConfiguration.cs b/DocxTemplater.Markdown/MarkDownFormatterConfiguration.cs
new file mode 100644
index 0000000..2d43a4b
--- /dev/null
+++ b/DocxTemplater.Markdown/MarkDownFormatterConfiguration.cs
@@ -0,0 +1,66 @@
+using DocumentFormat.OpenXml.Wordprocessing;
+using System.Collections.Generic;
+
+namespace DocxTemplater.Markdown
+{
+    public record ListLevelConfiguration(
+        string LevelText,
+        string FontOverride,
+        NumberFormatValues NumberingFormat,
+        int IndentPerLevel);
+
+    public class MarkDownFormatterConfiguration
+    {
+        public static readonly MarkDownFormatterConfiguration Default;
+
+        static MarkDownFormatterConfiguration()
+        {
+            Default = new MarkDownFormatterConfiguration();
+        }
+
+        public MarkDownFormatterConfiguration()
+        {
+            OrderedListLevelConfiguration = new List<ListLevelConfiguration>();
+            UnorderedListLevelConfiguration = new List<ListLevelConfiguration>();
+
+            OrderedListLevelConfiguration.Add(new ListLevelConfiguration("%1.", null, NumberFormatValues.Decimal, 720));
+            OrderedListLevelConfiguration.Add(new ListLevelConfiguration("%2.", null, NumberFormatValues.LowerLetter, 720));
+            OrderedListLevelConfiguration.Add(new ListLevelConfiguration("%3.", null, NumberFormatValues.LowerRoman, 720));
+
+            OrderedListLevelConfiguration.Add(new ListLevelConfiguration("%4.", null, NumberFormatValues.Decimal, 720));
+            OrderedListLevelConfiguration.Add(new ListLevelConfiguration("%5.", null, NumberFormatValues.LowerLetter, 720));
+            OrderedListLevelConfiguration.Add(new ListLevelConfiguration("%6.", null, NumberFormatValues.LowerRoman, 720));
+
+            OrderedListLevelConfiguration.Add(new ListLevelConfiguration("%7.", null, NumberFormatValues.Decimal, 720));
+            OrderedListLevelConfiguration.Add(new ListLevelConfiguration("%8.", null, NumberFormatValues.LowerLetter, 720));
+            OrderedListLevelConfiguration.Add(new ListLevelConfiguration("%9.", null, NumberFormatValues.LowerRoman, 720));
+
+            UnorderedListLevelConfiguration.Add(new ListLevelConfiguration("\uf0b7", "Symbol", NumberFormatValues.Bullet, 720));
+            UnorderedListLevelConfiguration.Add(new ListLevelConfiguration("o", "Courier New", NumberFormatValues.Bullet, 720));
+            UnorderedListLevelConfiguration.Add(new ListLevelConfiguration("\uf0a7", "Wingdings", NumberFormatValues.Bullet, 720));
+
+            UnorderedListLevelConfiguration.Add(new ListLevelConfiguration("\uf0b7", "Symbol", NumberFormatValues.Bullet, 720));
+            UnorderedListLevelConfiguration.Add(new ListLevelConfiguration("o", "Courier New", NumberFormatValues.Bullet, 720));
+            UnorderedListLevelConfiguration.Add(new ListLevelConfiguration("\uf0a7", "Wingdings", NumberFormatValues.Bullet, 720));
+
+            UnorderedListLevelConfiguration.Add(new ListLevelConfiguration("\uf0b7", "Symbol", NumberFormatValues.Bullet, 720));
+            UnorderedListLevelConfiguration.Add(new ListLevelConfiguration("o", "Courier New", NumberFormatValues.Bullet, 720));
+            UnorderedListLevelConfiguration.Add(new ListLevelConfiguration("\uf0a7", "Wingdings", NumberFormatValues.Bullet, 720));
+        }
+
+        public List<ListLevelConfiguration> OrderedListLevelConfiguration
+        {
+            get;
+        }
+
+        public List<ListLevelConfiguration> UnorderedListLevelConfiguration
+        {
+            get;
+        }
+
+        /// <summary>
+        /// Name of a table style in the template document applied to tables.
+        /// </summary>
+        public string TableStyle { get; set; }
+    }
+}
diff --git a/DocxTemplater.Markdown/MarkdownFormatter.cs b/DocxTemplater.Markdown/MarkdownFormatter.cs
new file mode 100644
index 0000000..82dacf2
--- /dev/null
+++ b/DocxTemplater.Markdown/MarkdownFormatter.cs
@@ -0,0 +1,52 @@
+using DocumentFormat.OpenXml;
+using DocumentFormat.OpenXml.Wordprocessing;
+using DocxTemplater.Formatter;
+using Markdig.Parsers;
+using System;
+using DocumentFormat.OpenXml.Packaging;
+using Markdig;
+
+namespace DocxTemplater.Markdown
+{
+    public class MarkdownFormatter : IFormatter
+    {
+        private readonly MarkDownFormatterConfiguration m_configuration;
+
+        public MarkdownFormatter(MarkDownFormatterConfiguration configuration = null)
+        {
+            m_configuration = configuration ?? MarkDownFormatterConfiguration.Default;
+        }
+
+        public bool CanHandle(Type type, string prefix)
+        {
+            string prefixUpper = prefix.ToUpper();
+            return prefixUpper is "MD" && type == typeof(string);
+        }
+
+        public void ApplyFormat(FormatterContext context, Text target)
+        {
+            if (context.Value is not string mdText)
+            {
+                return;
+            }
+
+            var root = target.GetRoot();
+            if (root is OpenXmlPartRootElement openXmlPartRootElement && openXmlPartRootElement.OpenXmlPart != null)
+            {
+
+                if (openXmlPartRootElement.OpenXmlPart is MainDocumentPart mainDocumentPart)
+                {
+                    var pipeline = new MarkdownPipelineBuilder().UsePipeTables().Build();
+                    var markdownDocument = MarkdownParser.Parse(mdText, pipeline);
+                    var renderer = new MarkdownToOpenXmlRenderer(target, mainDocumentPart, m_configuration);
+                    renderer.Render(markdownDocument);
+                }
+                else
+                {
+                    throw new InvalidOperationException("Markdown currently only supported in MainDocument");
+                }
+            }
+            target.RemoveWithEmptyParent();
+        }
+    }
+}
diff --git a/DocxTemplater.Markdown/MarkdownToOpenXmlRenderer.cs b/DocxTemplater.Markdown/MarkdownToOpenXmlRenderer.cs
new file mode 100644
index 0000000..846de3a
--- /dev/null
+++ b/DocxTemplater.Markdown/MarkdownToOpenXmlRenderer.cs
@@ -0,0 +1,183 @@
+
+using DocumentFormat.OpenXml;
+using DocumentFormat.OpenXml.Packaging;
+using DocumentFormat.OpenXml.Wordprocessing;
+using DocxTemplater.Markdown.Renderer;
+using DocxTemplater.Markdown.Renderer.Inlines;
+using Markdig.Helpers;
+using Markdig.Renderers;
+using Markdig.Syntax;
+using Markdig.Syntax.Inlines;
+using System;
+using System.Collections.Generic;
+
+namespace DocxTemplater.Markdown
+{
+    internal sealed class MarkdownToOpenXmlRenderer : RendererBase
+    {
+        private sealed record Format(bool Bold, bool Italic, string Style);
+
+        private readonly Stack<Format> m_formatStack = new();
+        private OpenXmlCompositeElement m_parentElement;
+        private bool m_lastElemntWasNewLine;
+
+        public MarkdownToOpenXmlRenderer(
+            Text previousOpenXmlNode,
+            MainDocumentPart mainDocumentPart,
+            MarkDownFormatterConfiguration configuration)
+        {
+            m_lastElemntWasNewLine = true;
+            m_formatStack.Push(new Format(false, false, null));
+            m_parentElement = previousOpenXmlNode.GetFirstAncestor<Paragraph>();
+            ObjectRenderers.Add(new LiteralInlineRenderer());
+            ObjectRenderers.Add(new ParagraphRenderer());
+            ObjectRenderers.Add(new LineBreakLineRenderer());
+            ObjectRenderers.Add(new EmphasisInlineRenderer());
+            ObjectRenderers.Add(new TableRenderer(configuration, mainDocumentPart));
+            ObjectRenderers.Add(new ListRenderer(mainDocumentPart, configuration));
+            ObjectRenderers.Add(new HeadingRenderer());
+            ObjectRenderers.Add(new ThematicBreakRenderer());
+        }
+
+        public bool ExplicitParagraph { get; set; }
+
+        public Paragraph CurrentParagraph => m_parentElement as Paragraph;
+        
+        public MarkdownToOpenXmlRenderer Write(ref StringSlice slice)
+        {
+            Write(slice.AsSpan());
+            return this;
+        }
+
+        public void Write(ReadOnlySpan<char> content)
+        {
+            if (!content.IsEmpty)
+            {
+                var newRun = new Run(new Text(content.ToString()){ Space = SpaceProcessingModeValues.Preserve });
+                var format = m_formatStack.Peek();
+                if (format.Bold || format.Italic || format.Style != null)
+                {
+                    RunProperties run1Properties = new();
+                    if (format.Bold)
+                    {
+                        run1Properties.Append(new Bold());
+                    }
+                    if (format.Italic)
+                    {
+                        run1Properties.Append(new Italic());
+                    }
+                    newRun.RunProperties = run1Properties;
+
+                    //add style
+                    if (format.Style != null)
+                    {
+                        var runStyle = new RunStyle { Val = format.Style };
+                        newRun.RunProperties.Append(runStyle);
+                    }
+                }
+                m_parentElement.Append(newRun);
+                m_lastElemntWasNewLine = false;
+            }
+        }
+
+        public override object Render(MarkdownObject markdownObject)
+        {
+            Write(markdownObject);
+            return null;
+        }
+
+        public void WriteLeafInline(LeafBlock leafBlock)
+        {
+            Inline inline = leafBlock.Inline;
+            while (inline != null)
+            {
+                Write(inline);
+                inline = inline.NextSibling;
+            }
+        }
+
+        public IDisposable PushFormat(bool? bold, bool? italic)
+        {
+            var currentStyle = m_formatStack.Peek();
+            bold ??= currentStyle.Bold;
+            italic ??= currentStyle.Italic;
+            return new FormatScope(m_formatStack, bold.Value, italic.Value, currentStyle.Style);
+        }
+
+        public IDisposable PushStyle(string style)
+        {
+            return new FormatScope(m_formatStack, m_formatStack.Peek().Bold, m_formatStack.Peek().Italic, style);
+        }
+
+        public void NewLine()
+        {
+            m_parentElement.Append(new Run(new Break()));
+            m_lastElemntWasNewLine = true;
+        }
+
+        public void EnsureNewLine()
+        {
+            if (!m_lastElemntWasNewLine)
+            {
+                NewLine();
+            }
+        }
+
+        public void ReplaceIfCurrentParagraphIsEmpty(Paragraph newParagraph)
+        {
+            var lastParagraph = CurrentParagraph;
+            AddParagraph(newParagraph);
+            if (lastParagraph != null && lastParagraph.ChildElements.Count == 0)
+            {
+                lastParagraph.Remove();
+            }
+        }
+
+        public void AddParagraph(OpenXmlCompositeElement paragraph = null)
+        {
+            paragraph ??= new Paragraph();
+            m_parentElement = m_parentElement.InsertAfterSelf(paragraph);
+            m_lastElemntWasNewLine = false;
+        }
+
+        public IDisposable PushParagraph(Paragraph paragraph)
+        {
+            m_lastElemntWasNewLine = true;
+            return new ParagraphScope(this, paragraph);
+        }
+
+        private sealed class ParagraphScope : IDisposable
+        {
+            private readonly MarkdownToOpenXmlRenderer m_renderer;
+            private readonly OpenXmlCompositeElement m_previousParagraph;
+
+            public ParagraphScope(MarkdownToOpenXmlRenderer renderer, Paragraph element)
+            {
+                m_renderer = renderer;
+                m_previousParagraph = m_renderer.m_parentElement;
+                m_renderer.m_parentElement = element;
+            }
+
+            public void Dispose()
+            {
+                m_renderer.m_parentElement = m_previousParagraph;
+            }
+        }
+
+        private sealed class FormatScope : IDisposable
+        {
+            private readonly Stack<Format> m_formatStack;
+            public FormatScope(Stack<Format> formatStack, bool bold, bool italic, string style)
+            {
+                m_formatStack = formatStack;
+                m_formatStack.Push(new Format(bold, italic, style));
+            }
+
+            public void Dispose()
+            {
+                m_formatStack.Pop();
+            }
+        }
+    }
+
+}
diff --git a/DocxTemplater.Markdown/Renderer/HeadingRenderer.cs b/DocxTemplater.Markdown/Renderer/HeadingRenderer.cs
new file mode 100644
index 0000000..480f143
--- /dev/null
+++ b/DocxTemplater.Markdown/Renderer/HeadingRenderer.cs
@@ -0,0 +1,21 @@
+using DocumentFormat.OpenXml.Wordprocessing;
+using Markdig.Syntax;
+
+namespace DocxTemplater.Markdown.Renderer
+{
+    internal sealed class HeadingRenderer : OpenXmlObjectRenderer<HeadingBlock>
+    {
+        protected override void Write(MarkdownToOpenXmlRenderer renderer, HeadingBlock heading)
+        {
+            var headingParagraph = new Paragraph();
+            // add heading style
+            var headingStyle = new ParagraphStyleId() { Val = $"Heading{heading.Level}" };
+            var paragraphProps = new ParagraphProperties();
+            paragraphProps.Append(headingStyle);
+            headingParagraph.ParagraphProperties = paragraphProps;
+            renderer.AddParagraph(headingParagraph);
+            renderer.WriteLeafInline(heading);
+            renderer.AddParagraph();
+        }
+    }
+}
diff --git a/DocxTemplater.Markdown/Renderer/Inlines/EmphasisInlineRenderer.cs b/DocxTemplater.Markdown/Renderer/Inlines/EmphasisInlineRenderer.cs
new file mode 100644
index 0000000..529058c
--- /dev/null
+++ b/DocxTemplater.Markdown/Renderer/Inlines/EmphasisInlineRenderer.cs
@@ -0,0 +1,26 @@
+using Markdig.Syntax.Inlines;
+
+namespace DocxTemplater.Markdown.Renderer.Inlines
+{
+    internal sealed class EmphasisInlineRenderer : OpenXmlObjectRenderer<EmphasisInline>
+    {
+        protected override void Write(MarkdownToOpenXmlRenderer renderer, EmphasisInline obj)
+        {
+            bool? italic = null;
+            bool? bold = null;
+            if (obj.DelimiterChar is '_' or '*')
+            {
+                if (obj.DelimiterCount == 1)
+                {
+                    italic = true;
+                }
+                else if (obj.DelimiterCount == 2)
+                {
+                    bold = true;
+                }
+            }
+            using var format = renderer.PushFormat(bold, italic);
+            renderer.WriteChildren(obj);
+        }
+    }
+}
\ No newline at end of file
diff --git a/DocxTemplater.Markdown/Renderer/Inlines/LineBreakLineRenderer.cs b/DocxTemplater.Markdown/Renderer/Inlines/LineBreakLineRenderer.cs
new file mode 100644
index 0000000..7d19232
--- /dev/null
+++ b/DocxTemplater.Markdown/Renderer/Inlines/LineBreakLineRenderer.cs
@@ -0,0 +1,16 @@
+using Markdig.Syntax.Inlines;
+
+namespace DocxTemplater.Markdown.Renderer.Inlines
+{
+    internal sealed class LineBreakLineRenderer : OpenXmlObjectRenderer<LineBreakInline>
+    {
+        protected override void Write(MarkdownToOpenXmlRenderer renderer, LineBreakInline obj)
+        {
+            if (renderer.IsLastInContainer)
+            {
+                return;
+            }
+            renderer.NewLine();
+        }
+    }
+}
diff --git a/DocxTemplater.Markdown/Renderer/Inlines/LiteralInlineRenderer.cs b/DocxTemplater.Markdown/Renderer/Inlines/LiteralInlineRenderer.cs
new file mode 100644
index 0000000..8f5d626
--- /dev/null
+++ b/DocxTemplater.Markdown/Renderer/Inlines/LiteralInlineRenderer.cs
@@ -0,0 +1,12 @@
+using Markdig.Syntax.Inlines;
+
+namespace DocxTemplater.Markdown.Renderer.Inlines
+{
+    internal sealed class LiteralInlineRenderer : OpenXmlObjectRenderer<LiteralInline>
+    {
+        protected override void Write(MarkdownToOpenXmlRenderer renderer, LiteralInline obj)
+        {
+            renderer.Write(ref obj.Content);
+        }
+    }
+}
\ No newline at end of file
diff --git a/DocxTemplater.Markdown/Renderer/ListRenderer.cs b/DocxTemplater.Markdown/Renderer/ListRenderer.cs
new file mode 100644
index 0000000..d8c5772
--- /dev/null
+++ b/DocxTemplater.Markdown/Renderer/ListRenderer.cs
@@ -0,0 +1,200 @@
+using DocumentFormat.OpenXml.Packaging;
+using DocumentFormat.OpenXml.Wordprocessing;
+using Markdig.Syntax;
+using System.Linq;
+
+namespace DocxTemplater.Markdown.Renderer
+{
+    internal sealed class ListRenderer : OpenXmlObjectRenderer<ListBlock>
+    {
+        private int m_level = -1;
+        private int m_levelWithSameOrdering = -1;
+        private bool? m_lastLevelOrdered;
+
+        private readonly MainDocumentPart m_mainDocumentPart;
+        private readonly MarkDownFormatterConfiguration m_configuration;
+        private AbstractNum m_currentAbstractNumNotOrdered;
+        private AbstractNum m_currentAbstractNumOrdered;
+        private NumberingInstance m_currentNumberingInstanceOrdered;
+        private NumberingInstance m_currentNumberingInstanceNotOrdered;
+        private NumberingDefinitionsPart m_numberingDefinitionsPart;
+        private string m_listParagraphStyle;
+
+        public ListRenderer(MainDocumentPart mainDocumentPart, MarkDownFormatterConfiguration configuration)
+        {
+            m_mainDocumentPart = mainDocumentPart;
+            m_configuration = configuration;
+        }
+
+        protected override void Write(MarkdownToOpenXmlRenderer renderer, ListBlock listBlock)
+        {
+
+            StartListLevel(listBlock.IsOrdered);
+            try
+            {
+                var numberingInstance = listBlock.IsOrdered ? m_currentNumberingInstanceOrdered : m_currentNumberingInstanceNotOrdered;
+
+                foreach (var item in listBlock)
+                {
+                    var numberingProps =
+                    new NumberingProperties(
+                        new NumberingLevelReference() { Val = m_levelWithSameOrdering },
+                        new NumberingId() { Val = numberingInstance.NumberID }
+                    );
+                    var listItem = (ListItemBlock)item;
+                    var listParagraph = new Paragraph();
+                    var paragraphProperties = new ParagraphProperties(numberingProps)
+                    {
+                        ParagraphStyleId = new ParagraphStyleId() { Val = m_listParagraphStyle }
+                    };
+                    listParagraph.ParagraphProperties = paragraphProperties;
+                    renderer.ReplaceIfCurrentParagraphIsEmpty(listParagraph);
+                    renderer.ExplicitParagraph = true;
+                    renderer.WriteChildren(listItem);
+                }
+            }
+            finally
+            {
+                EndListLevel();
+            }
+
+            if (m_level == -1)
+            {
+                renderer.AddParagraph();
+            }
+        }
+
+        private void CrateListParagraphStyleIfNotExistent()
+        {
+            if (m_listParagraphStyle == null)
+            {
+                var part = m_mainDocumentPart.StyleDefinitionsPart;
+                if (part == null)
+                {
+                    part = m_mainDocumentPart.AddNewPart<StyleDefinitionsPart>();
+                    part.Styles = new Styles();
+                }
+
+                var style = part.Styles?.Elements<Style>().FirstOrDefault(x => x.StyleId == "ListParagraph");
+                if (style == null)
+                {
+                    style = new Style()
+                    {
+                        Type = StyleValues.Paragraph,
+                        StyleId = "ListParagraph",
+                        CustomStyle = true,
+                        StyleName = new StyleName() { Val = "List Paragraph" },
+                        UIPriority = new UIPriority() { Val = 34 },
+                        PrimaryStyle = new PrimaryStyle(),
+                        Rsid = new Rsid() { Val = "004004FF" }
+                    };
+                    var styleParagraphProperties = new StyleParagraphProperties();
+                    styleParagraphProperties.Append(new ContextualSpacing());
+                    style.Append(styleParagraphProperties);
+                    part.Styles?.Append(style);
+                    part.Styles?.Save();
+                }
+                m_listParagraphStyle = "ListParagraph";
+            }
+        }
+
+        private void StartListLevel(bool ordered)
+        {
+            m_level++;
+            if (m_level == 0)
+            {
+                CrateListParagraphStyleIfNotExistent();
+                CrateNumberingInstance(ordered);
+            }
+
+            if (m_lastLevelOrdered != ordered)
+            {
+                m_levelWithSameOrdering = -1;
+            }
+            m_levelWithSameOrdering++;
+            m_lastLevelOrdered = ordered;
+
+            // try to find level
+            var abstractNumberDefinition = GetAbstractNumberingDefinition(ordered);
+            var level = abstractNumberDefinition.ChildElements.OfType<Level>().FirstOrDefault(x => x.LevelIndex == m_level);
+            if (level == null)
+            {
+                var levelConfig = ordered ? m_configuration.OrderedListLevelConfiguration : m_configuration.UnorderedListLevelConfiguration;
+                var config = levelConfig[m_levelWithSameOrdering % levelConfig.Count];
+                level = new Level()
+                {
+                    LevelIndex = m_level,
+                    NumberingFormat = new NumberingFormat()
+                    {
+                        Val = config.NumberingFormat
+                    },
+                    LevelText = new LevelText() { Val = config.LevelText },
+                    StartNumberingValue = new StartNumberingValue() { Val = 1 },
+                };
+                var paraProps = new PreviousParagraphProperties(new Indentation()
+                {
+                    Left = (config.IndentPerLevel * (m_level + 1)).ToString(),
+                    Hanging = m_level % 2 == 0 ? "360" : "180"
+                });
+                level.Append(paraProps);
+                if (!string.IsNullOrEmpty(config.FontOverride))
+                {
+                    level.Append(new NumberingSymbolRunProperties(new RunFonts() { Ascii = config.FontOverride, HighAnsi = config.FontOverride }));
+
+                }
+                abstractNumberDefinition.Append(level);
+                m_numberingDefinitionsPart.Numbering.Save();
+            }
+        }
+
+        private void EndListLevel()
+        {
+            m_level--;
+            m_levelWithSameOrdering--;
+        }
+
+        /// <summary>
+        /// Crates a AbstractNum format for multiple levels of lists
+        /// </summary>
+        /// <returns></returns>
+        private void CrateNumberingInstance(bool ordered)
+        {
+            // Ensure the main document part has a NumberingDefinitionsPart
+            if (m_mainDocumentPart.NumberingDefinitionsPart == null)
+            {
+                m_numberingDefinitionsPart = m_mainDocumentPart.AddNewPart<NumberingDefinitionsPart>();
+                m_numberingDefinitionsPart.Numbering = new Numbering();
+            }
+            else
+            {
+                m_numberingDefinitionsPart = m_mainDocumentPart.NumberingDefinitionsPart;
+            }
+
+            var abstractNum = GetAbstractNumberingDefinition(ordered);
+
+            if (abstractNum == null)
+            {
+                abstractNum = m_numberingDefinitionsPart.Numbering.CreateNewAbstractNumbering();
+                var numberIngInstance = m_numberingDefinitionsPart.Numbering.CreateNewNumberingInstance(abstractNum.AbstractNumberId);
+                if (!ordered)
+                {
+                    m_currentAbstractNumNotOrdered = abstractNum;
+                    m_currentNumberingInstanceNotOrdered = numberIngInstance;
+                }
+                else
+                {
+                    m_currentAbstractNumOrdered = abstractNum;
+                    m_currentNumberingInstanceOrdered = numberIngInstance;
+                }
+                m_numberingDefinitionsPart.Numbering.Save();
+            }
+
+        }
+
+        private AbstractNum GetAbstractNumberingDefinition(bool ordered)
+        {
+            var abstractNum = ordered ? m_currentAbstractNumOrdered : m_currentAbstractNumNotOrdered;
+            return abstractNum;
+        }
+    }
+}
diff --git a/DocxTemplater.Markdown/Renderer/OpenXmlObjectRenderer.cs b/DocxTemplater.Markdown/Renderer/OpenXmlObjectRenderer.cs
new file mode 100644
index 0000000..b57af1b
--- /dev/null
+++ b/DocxTemplater.Markdown/Renderer/OpenXmlObjectRenderer.cs
@@ -0,0 +1,9 @@
+using Markdig.Renderers;
+using Markdig.Syntax;
+
+namespace DocxTemplater.Markdown.Renderer
+{
+    internal abstract class OpenXmlObjectRenderer<TObject> : MarkdownObjectRenderer<MarkdownToOpenXmlRenderer, TObject> where TObject : MarkdownObject
+    {
+    }
+}
\ No newline at end of file
diff --git a/DocxTemplater.Markdown/Renderer/ParagraphRenderer.cs b/DocxTemplater.Markdown/Renderer/ParagraphRenderer.cs
new file mode 100644
index 0000000..bb9e2be
--- /dev/null
+++ b/DocxTemplater.Markdown/Renderer/ParagraphRenderer.cs
@@ -0,0 +1,18 @@
+using Markdig.Syntax;
+
+namespace DocxTemplater.Markdown.Renderer
+{
+    internal sealed class ParagraphRenderer : OpenXmlObjectRenderer<ParagraphBlock>
+    {
+        protected override void Write(MarkdownToOpenXmlRenderer renderer, ParagraphBlock obj)
+        {
+            renderer.WriteLeafInline(obj);
+            if (renderer.ExplicitParagraph)
+            {
+                renderer.ExplicitParagraph = false;
+                return;
+            }
+            renderer.AddParagraph();
+        }
+    }
+}
\ No newline at end of file
diff --git a/DocxTemplater.Markdown/Renderer/TableRenderer.cs b/DocxTemplater.Markdown/Renderer/TableRenderer.cs
new file mode 100644
index 0000000..e856358
--- /dev/null
+++ b/DocxTemplater.Markdown/Renderer/TableRenderer.cs
@@ -0,0 +1,85 @@
+using DocumentFormat.OpenXml.Packaging;
+using Markdig.Extensions.Tables;
+using Table = Markdig.Extensions.Tables.Table;
+using WP = DocumentFormat.OpenXml.Wordprocessing;
+
+namespace DocxTemplater.Markdown.Renderer
+{
+    internal sealed class TableRenderer : OpenXmlObjectRenderer<Table>
+    {
+        private readonly MarkDownFormatterConfiguration m_markDownFormatterConfiguration;
+        private readonly MainDocumentPart m_mainDocument;
+        private WP.Style m_tableStyle;
+
+        public TableRenderer(MarkDownFormatterConfiguration markDownFormatterConfiguration, MainDocumentPart mainDocument)
+        {
+            m_markDownFormatterConfiguration = markDownFormatterConfiguration;
+            m_mainDocument = mainDocument;
+        }
+
+        private static string PercentToFiftiethsOfAPercent(double percent)
+        {
+            // 5000 fiftieths-of-a-percent = 100% - strange openxml units
+            return ((int)(percent * 50)).ToString();
+        }
+
+        protected override void Write(MarkdownToOpenXmlRenderer renderer, Table mkTable)
+        {
+            var table = new WP.Table();
+            var tableProperties = new WP.TableProperties
+            {
+                TableWidth = new WP.TableWidth
+                {
+                    Type = WP.TableWidthUnitValues.Pct,
+                    Width = PercentToFiftiethsOfAPercent(100)
+                }
+            };
+
+            if (m_markDownFormatterConfiguration.TableStyle != null)
+            {
+                if (m_tableStyle == null)
+                {
+                    m_tableStyle ??= m_mainDocument.FindTableStyleByName(m_markDownFormatterConfiguration.TableStyle);
+                    tableProperties.TableStyle = new WP.TableStyle { Val = m_markDownFormatterConfiguration.TableStyle };
+                }
+            }
+
+            var tableGrid = new WP.TableGrid();
+            foreach (var _ in mkTable.ColumnDefinitions)
+            {
+                /* TODO:
+                // Add full support for alignment as defined in specs of Pipe table
+                // https://github.com/xoofx/markdig/blob/master/src/Markdig.Tests/Specs/PipeTableSpecs.md
+                */
+                tableGrid.Append(new WP.GridColumn());
+            }
+
+            table.AppendChild(tableProperties);
+            table.Append(tableGrid);
+
+            foreach (TableRow row in mkTable)
+            {
+                var tableRow = new WP.TableRow();
+                table.AppendChild(tableRow);
+                for (int i = 0; i < row.Count; i++)
+                {
+                    var cell = (TableCell)row[i];
+                    var cellProperties = new WP.TableCellProperties();
+                    var cellWidth = new WP.TableCellWidth { Type = WP.TableWidthUnitValues.Auto };
+                    cellProperties.Append(cellWidth);
+                    var cellElement = new WP.TableCell(cellProperties);
+                    tableRow.AppendChild(cellElement);
+
+                    // cell paragraph
+                    var cellParagraph = new WP.Paragraph();
+                    cellElement.Append(cellParagraph);
+                    using var paragraphScope = renderer.PushParagraph(cellParagraph);
+                    renderer.WriteChildren(cell);
+                }
+            }
+            renderer.AddParagraph(table);
+            renderer.ExplicitParagraph = true;
+            renderer.AddParagraph();
+        }
+    }
+}
diff --git a/DocxTemplater.Markdown/Renderer/ThematicBreakRenderer.cs b/DocxTemplater.Markdown/Renderer/ThematicBreakRenderer.cs
new file mode 100644
index 0000000..5a5ebf0
--- /dev/null
+++ b/DocxTemplater.Markdown/Renderer/ThematicBreakRenderer.cs
@@ -0,0 +1,33 @@
+using DocumentFormat.OpenXml;
+using DocumentFormat.OpenXml.Wordprocessing;
+using Markdig.Syntax;
+
+namespace DocxTemplater.Markdown.Renderer
+{
+    internal sealed class ThematicBreakRenderer : OpenXmlObjectRenderer<ThematicBreakBlock>
+    {
+        protected override void Write(MarkdownToOpenXmlRenderer renderer, ThematicBreakBlock obj)
+        {
+            renderer.AddParagraph(CreateParagraphWithBorder());
+            renderer.AddParagraph();
+        }
+
+        private static Paragraph CreateParagraphWithBorder()
+        {
+            var paragraph = new Paragraph();
+            var paragraphProperties = new ParagraphProperties();
+            var borders = CreateBorders();
+            paragraphProperties.Append(borders);
+            paragraph.Append(paragraphProperties);
+            return paragraph;
+        }
+
+        private static ParagraphBorders CreateBorders()
+        {
+            var borders = new ParagraphBorders();
+            var bottomBorder = new BottomBorder { Val = new EnumValue<BorderValues>(BorderValues.Single), Color = "auto", Size = 6 };
+            borders.Append(bottomBorder);
+            return borders;
+        }
+    }
+}
diff --git a/DocxTemplater.Test/DocxTemplater.Test.csproj b/DocxTemplater.Test/DocxTemplater.Test.csproj
index 59c0818..935968f 100644
--- a/DocxTemplater.Test/DocxTemplater.Test.csproj
+++ b/DocxTemplater.Test/DocxTemplater.Test.csproj
@@ -1,67 +1,75 @@
-<Project Sdk="Microsoft.NET.Sdk">
-  <PropertyGroup>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <Nullable>disable</Nullable>
-    <IsPackable>false</IsPackable>
-    <IsTestProject>true</IsTestProject>
-  </PropertyGroup>
-  <PropertyGroup>
-    <AnalysisLevelPerformance>None</AnalysisLevelPerformance>
-  </PropertyGroup>
-  <ItemGroup>
-    <PackageReference Include="AutoBogus" Version="2.13.1" />
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.10.0" />
-    <PackageReference Include="NUnit" Version="4.1.0" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
-    <PackageReference Include="NUnit.Analyzers" Version="4.2.0">
-      <PrivateAssets>all</PrivateAssets>
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-    </PackageReference>
-    <PackageReference Include="coverlet.collector" Version="6.0.2">
-      <PrivateAssets>all</PrivateAssets>
-      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-    </PackageReference>
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\DocxTemplater.Images\DocxTemplater.Images.csproj" />
-    <ProjectReference Include="..\DocxTemplater\DocxTemplater.csproj" />
-  </ItemGroup>
-  <ItemGroup>
-    <None Update="Resources\BillTemplate.docx">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-    <None Update="Resources\BillTemplate2.docx">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-    <None Update="Resources\ComplexTemplate.docx">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-    <None Update="Resources\ConditionalTableRows.docx">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-    <None Update="Resources\DynamicTable.docx">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-    <None Update="Resources\DynamicTableWithComplexObjectsAsHeaderAndValues.docx">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-    <None Update="Resources\ImageFormatterTest.docx">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-    <None Update="Resources\MultipleRowsBoundToCollection.docx">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-    <None Update="Resources\MultipleTableRowsBoundToCollection.docx">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-    <None Update="Resources\NestedCollectionsInTable.docx">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-    <None Update="Resources\RowTemplate.docx">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-    <None Update="Resources\testImage.jpg">
-      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
-    </None>
-  </ItemGroup>
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>disable</Nullable>
+    <IsPackable>false</IsPackable>
+    <IsTestProject>true</IsTestProject>
+  </PropertyGroup>
+  <PropertyGroup>
+    <AnalysisLevelPerformance>None</AnalysisLevelPerformance>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="AutoBogus" Version="2.13.1" />
+    <PackageReference Include="JetBrains.DotMemoryUnit" Version="3.2.20220510" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.10.0" />
+    <PackageReference Include="NUnit" Version="4.1.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.5.0" />
+    <PackageReference Include="NUnit.Analyzers" Version="4.2.0">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="coverlet.collector" Version="6.0.2">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\DocxTemplater.Images\DocxTemplater.Images.csproj" />
+    <ProjectReference Include="..\DocxTemplater.Markdown\DocxTemplater.Markdown.csproj" />
+    <ProjectReference Include="..\DocxTemplater\DocxTemplater.csproj" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Update="Resources\BillTemplate.docx">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+    <None Update="Resources\BillTemplate2.docx">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+    <None Update="Resources\ComplexTemplate.docx">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+    <None Update="Resources\ConditionalTableRows.docx">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+    <None Update="Resources\DynamicTable.docx">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+    <None Update="Resources\DynamicTableWithComplexObjectsAsHeaderAndValues.docx">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+    <None Update="Resources\ImageFormatterTest.docx">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+    <None Update="Resources\MarkdownTestTemplate.docx">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+    <None Update="Resources\MultipleRowsBoundToCollection.docx">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+    <None Update="Resources\MultipleTableRowsBoundToCollection.docx">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+    <None Update="Resources\NestedCollectionsInTable.docx">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+    <None Update="Resources\RowTemplate.docx">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+    <None Update="Resources\testImage.jpg">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+    <None Update="Resources\TestMarkDown.md">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/DocxTemplater.Test/MarkdownRendererTest.cs b/DocxTemplater.Test/MarkdownRendererTest.cs
new file mode 100644
index 0000000..ff4ca34
--- /dev/null
+++ b/DocxTemplater.Test/MarkdownRendererTest.cs
@@ -0,0 +1,300 @@
+using System.Text;
+using DocumentFormat.OpenXml;
+using DocumentFormat.OpenXml.Packaging;
+using DocumentFormat.OpenXml.Wordprocessing;
+using DocxTemplater.Markdown;
+
+namespace DocxTemplater.Test
+{
+    internal class MarkdownRendererTest
+    {
+        [Test]
+        public void PlainText()
+        {
+            var markdown = "Hello\r\nSecond Line\r\n\r\nSecond Paragraph First Line";
+            var body = CreateTemplateWithMarkdownAndReturnBody(markdown);
+            // check text from first and second paragraph
+            var firstParagraphFirstLine = body.Descendants<Text>().First();
+            Assert.That(firstParagraphFirstLine.Text, Is.EqualTo("Hello"));
+            var firstParagraphSecondLine = body.Descendants<Text>().ElementAt(1);
+            Assert.That(firstParagraphSecondLine.Text, Is.EqualTo("Second Line"));
+            var secondParagraph = body.Descendants<Text>().Last();
+            Assert.That(secondParagraph.Text, Is.EqualTo("Second Paragraph First Line"));
+        }
+
+
+        [Test]
+        public void MarkdownWithPlaceholder()
+        {
+            var markdown = "_Hello_  **{{ds:Name}}**";
+            using var memStream = new MemoryStream();
+            using var wpDocument = WordprocessingDocument.Create(memStream, WordprocessingDocumentType.Document);
+            MainDocumentPart mainPart = wpDocument.AddMainDocumentPart();
+            mainPart.Document =
+                new Document(new Body(new Paragraph(new Run(new Text("{{ds.markdown}:md}")))));
+            wpDocument.Save();
+            memStream.Position = 0;
+
+            var docTemplate = new DocxTemplate(memStream);
+            docTemplate.RegisterFormatter(new DocxTemplater.Markdown.MarkdownFormatter());
+            docTemplate.BindModel("ds", new
+            {
+                Name = "John",
+                markdown
+            });
+
+            var result = docTemplate.Process();
+            docTemplate.Validate();
+            Assert.That(result, Is.Not.Null);
+            result.SaveAsFileAndOpenInWord();
+            result.Position = 0;
+            var document = WordprocessingDocument.Open(result, false);
+            var body = document.MainDocumentPart.Document.Body;
+
+            // {{ds.markdown}:md} --> "_Hello_ **{{ds:Name}}**" --> "Hello John"
+            Assert.That(body.InnerText, Is.EqualTo("Hello John"));
+        }
+
+        [TestCase("**Hello**")]
+        [TestCase("__Hello__")]
+        public void BoldText(string markdown)
+        {
+            var body = CreateTemplateWithMarkdownAndReturnBody(markdown);
+            var runWithHello = (Run)body.Descendants<Text>().Single(x => x.Text == "Hello").Parent;
+            Assert.That(runWithHello.RunProperties.Bold, Is.Not.Null);
+            Assert.That(runWithHello.RunProperties.Italic, Is.Null);
+        }
+
+        [TestCase("*Hello*")]
+        [TestCase("_Hello_")]
+        public void ItalicText(string markdown)
+        {
+            var body = CreateTemplateWithMarkdownAndReturnBody(markdown);
+            var runWithHello = (Run)body.Descendants<Text>().Single(x => x.Text == "Hello").Parent;
+            Assert.That(runWithHello.RunProperties.Bold, Is.Null);
+            Assert.That(runWithHello.RunProperties.Italic, Is.Not.Null);
+        }
+
+        [Test]
+        public void MixedText()
+        {
+            var body = CreateTemplateWithMarkdownAndReturnBody("_Hello_ **There**");
+            var runWithHello = (Run)body.Descendants<Text>().Single(x => x.Text == "Hello").Parent;
+            var runWithThere = (Run)body.Descendants<Text>().Single(x => x.Text == "There").Parent;
+            Assert.That(runWithHello.RunProperties.Bold, Is.Null);
+            Assert.That(runWithHello.RunProperties.Italic, Is.Not.Null);
+            Assert.That(runWithThere.RunProperties.Bold, Is.Not.Null);
+            Assert.That(runWithThere.RunProperties.Italic, Is.Null);
+            Assert.That(body.InnerText, Is.EqualTo("Hello There"));
+        }
+
+
+        [TestCase("***Hello***")]
+        [TestCase("___Hello___")]
+        [TestCase("**_Hello_**")]
+        [TestCase("__*Hello*__")]
+        public void BoldAndItalic(string markdown)
+        {
+            var body = CreateTemplateWithMarkdownAndReturnBody(markdown);
+            var runWithHello = (Run)body.Descendants<Text>().Single(x => x.Text == "Hello").Parent;
+            Assert.That(runWithHello.RunProperties.Bold, Is.Not.Null);
+            Assert.That(runWithHello.RunProperties.Italic, Is.Not.Null);
+        }
+
+        [TestCase("> Dorothy followed her through many of the beautiful rooms in her castle.\r\n>\r\n>> The Witch bade her clean the pots and kettles and sweep the floor and keep the fire fed with wood.")]
+        public void BlockQuote_JustIgnored(string markdown)
+        {
+            var body = CreateTemplateWithMarkdownAndReturnBody(markdown);
+            Assert.That(body.InnerXml, Is.EqualTo("<w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:r><w:t>Dorothy" +
+                                                  " followed her through many of the beautiful rooms in her castle.</w:t></w:r></w:p><w:p xmlns:w=" +
+                                                  "\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:r><w:t>The Witch bade her clean" +
+                                                  " the pots and kettles and sweep the floor and keep the fire fed with wood.</w:t></w:r></w:p><w:p x" +
+                                                  "mlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" />"));
+        }
+
+        [Test]
+        public void MultipleLines()
+        {
+            var sb = new StringBuilder();
+            sb.AppendLine("__This is bold__");
+            sb.AppendLine("This is not");
+            sb.AppendLine("**This is bold**");
+            sb.AppendLine("This is not");
+            sb.AppendLine("_This is italic_");
+            sb.AppendLine("This is not");
+            sb.AppendLine("*This is italic*");
+            sb.AppendLine("This is not");
+            var body = CreateTemplateWithMarkdownAndReturnBody(sb.ToString());
+            var lineCount = body.Descendants<Run>().Count(x => x.ChildElements.Any(x => x is Break));
+            Assert.That(lineCount, Is.EqualTo(7));
+        }
+
+
+        [Test]
+        public void OrderedList()
+        {
+            var markdown = "1. First\n2. Second\n3. Third\n 4. Fourth\n 5. Fifth";
+            var body = CreateTemplateWithMarkdownAndReturnBody(markdown);
+            Assert.That(body.InnerXml, Is.EqualTo("<w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:pPr><w:pStyle w:val=\"ListParagraph\" /><w:numPr><w:ilvl w:val=\"0\" /><w:numId w:val=\"1\" /></w:numPr></w:pPr><w:r><w:t>First</w:t></w:r></w:p><w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:pPr><w:pStyle w:val=\"ListParagraph\" /><w:numPr><w:ilvl w:val=\"0\" /><w:numId w:val=\"1\" /></w:numPr></w:pPr><w:r><w:t>Second</w:t></w:r></w:p><w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:pPr><w:pStyle w:val=\"ListParagraph\" /><w:numPr><w:ilvl w:val=\"0\" /><w:numId w:val=\"1\" /></w:numPr></w:pPr><w:r><w:t>Third</w:t></w:r></w:p><w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:pPr><w:pStyle w:val=\"ListParagraph\" /><w:numPr><w:ilvl w:val=\"0\" /><w:numId w:val=\"1\" /></w:numPr></w:pPr><w:r><w:t>Fourth</w:t></w:r></w:p><w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:pPr><w:pStyle w:val=\"ListParagraph\" /><w:numPr><w:ilvl w:val=\"0\" /><w:numId w:val=\"1\" /></w:numPr></w:pPr><w:r><w:t>Fifth</w:t></w:r></w:p><w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" />"));
+        }
+
+        [Test]
+        public void UnorderedList()
+        {
+            var markdown = "* First\n* Second\n* Third";
+            var body = CreateTemplateWithMarkdownAndReturnBody(markdown);
+            Assert.That(body.InnerXml, Is.EqualTo("<w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:pPr><w:pStyle w:val=\"ListParagraph\" /><w:numPr><w:ilvl w:val=\"0\" /><w:numId w:val=\"1\" /></w:numPr></w:pPr><w:r><w:t>First</w:t></w:r></w:p><w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:pPr><w:pStyle w:val=\"ListParagraph\" /><w:numPr><w:ilvl w:val=\"0\" /><w:numId w:val=\"1\" /></w:numPr></w:pPr><w:r><w:t>Second</w:t></w:r></w:p><w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:pPr><w:pStyle w:val=\"ListParagraph\" /><w:numPr><w:ilvl w:val=\"0\" /><w:numId w:val=\"1\" /></w:numPr></w:pPr><w:r><w:t>Third</w:t></w:r></w:p><w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" />"));
+        }
+
+        [Test]
+        public void NestedUnorderedList()
+        {
+            var sb = new StringBuilder();
+            sb.AppendLine("* First");
+            sb.AppendLine("* Second");
+            sb.AppendLine("  * First First");
+            sb.AppendLine("  * First Second");
+            sb.AppendLine("    * First Second First");
+            sb.AppendLine("    * First Second Second");
+            sb.AppendLine("  * First Third");
+            sb.AppendLine("* Third");
+
+            var body = CreateTemplateWithMarkdownAndReturnBody(sb.ToString());
+            Assert.That(body.InnerXml, Is.EqualTo("<w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:pPr><w:pStyle w:val=\"ListParagraph\" /><w:numPr><w:ilvl w:val=\"0\" /><w:numId w:val=\"1\" /></w:numPr></w:pPr><w:r><w:t>First</w:t></w:r></w:p><w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:pPr><w:pStyle w:val=\"ListParagraph\" /><w:numPr><w:ilvl w:val=\"0\" /><w:numId w:val=\"1\" /></w:numPr></w:pPr><w:r><w:t>Second</w:t></w:r></w:p><w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:pPr><w:pStyle w:val=\"ListParagraph\" /><w:numPr><w:ilvl w:val=\"1\" /><w:numId w:val=\"1\" /></w:numPr></w:pPr><w:r><w:t>First First</w:t></w:r></w:p><w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:pPr><w:pStyle w:val=\"ListParagraph\" /><w:numPr><w:ilvl w:val=\"1\" /><w:numId w:val=\"1\" /></w:numPr></w:pPr><w:r><w:t>First Second</w:t></w:r></w:p><w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:pPr><w:pStyle w:val=\"ListParagraph\" /><w:numPr><w:ilvl w:val=\"2\" /><w:numId w:val=\"1\" /></w:numPr></w:pPr><w:r><w:t>First Second First</w:t></w:r></w:p><w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:pPr><w:pStyle w:val=\"ListParagraph\" /><w:numPr><w:ilvl w:val=\"2\" /><w:numId w:val=\"1\" /></w:numPr></w:pPr><w:r><w:t>First Second Second</w:t></w:r></w:p><w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:pPr><w:pStyle w:val=\"ListParagraph\" /><w:numPr><w:ilvl w:val=\"1\" /><w:numId w:val=\"1\" /></w:numPr></w:pPr><w:r><w:t>First Third</w:t></w:r></w:p><w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:pPr><w:pStyle w:val=\"ListParagraph\" /><w:numPr><w:ilvl w:val=\"0\" /><w:numId w:val=\"1\" /></w:numPr></w:pPr><w:r><w:t>Third</w:t></w:r></w:p><w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" />"));
+        }
+
+        [Test]
+        public void NestedOrderedList()
+        {
+            var sb = new StringBuilder();
+            sb.AppendLine("1. First");
+            sb.AppendLine("2. Second");
+            sb.AppendLine("   1. First First");
+            sb.AppendLine("   2. First Second");
+            sb.AppendLine("      1. First Second First");
+            sb.AppendLine("      2. First Second Second");
+            sb.AppendLine("   3. First Third");
+            sb.AppendLine("3. Third");
+            var body = CreateTemplateWithMarkdownAndReturnBody(sb.ToString());
+            Assert.That(body.InnerXml, Is.EqualTo("<w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:pPr><w:pStyle w:val=\"ListParagraph\" " +
+                                                  "/><w:numPr><w:ilvl w:val=\"0\" /><w:numId w:val=\"1\" /></w:numPr></w:pPr><w:r><w:t>First</w:t></w:r></w:p>" +
+                                                  "<w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:pPr><w:pStyle w:val=\"ListParagraph\" />" +
+                                                  "<w:numPr><w:ilvl w:val=\"0\" /><w:numId w:val=\"1\" /></w:numPr></w:pPr><w:r><w:t>Second</w:t></w:r></w:p>" +
+                                                  "<w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:pPr><w:pStyle w:val=\"ListParagraph\" /><w:numPr><w:ilvl w:val=\"1\" />" +
+                                                  "<w:numId w:val=\"1\" /></w:numPr></w:pPr><w:r><w:t>First First</w:t></w:r></w:p><w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\">" +
+                                                  "<w:pPr><w:pStyle w:val=\"ListParagraph\" /><w:numPr><w:ilvl w:val=\"1\" /><w:numId w:val=\"1\" /></w:numPr></w:pPr><w:r><w:t>First Second</w:t></w:r></w:p>" +
+                                                  "<w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:pPr><w:pStyle w:val=\"ListParagraph\" /><w:numPr><w:ilvl w:val=\"2\" /><w:numId w:val=\"1\" />" +
+                                                  "</w:numPr></w:pPr><w:r><w:t>First Second First</w:t></w:r></w:p><w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:pPr><w:pStyle w:val=\"ListParagraph\" /><" +
+                                                  "w:numPr><w:ilvl w:val=\"2\" /><w:numId w:val=\"1\" /></w:numPr></w:pPr><w:r><w:t>First Second Second</w:t></w:r>" +
+                                                  "</w:p><w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:pPr><w:pStyle w:val=\"ListParagraph\" />" +
+                                                  "<w:numPr><w:ilvl w:val=\"1\" /><w:numId w:val=\"1\" /></w:numPr></w:pPr><w:r><w:t>First Third</w:t></w:r>" +
+                                                  "</w:p><w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\">" +
+                                                  "<w:pPr><w:pStyle w:val=\"ListParagraph\" /><w:numPr><w:ilvl w:val=\"0\" /><w:numId w:val=\"1\" /" +
+                                                  "></w:numPr></w:pPr><w:r><w:t>Third</w:t></w:r></w:p><w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" />"));
+        }
+
+        [Test]
+        public void Table()
+        {
+            var sb = new StringBuilder();
+            sb.AppendLine("| Header 1 | Header 2 |");
+            sb.AppendLine("|----------|----------|");
+            sb.AppendLine("| Row 1 Col 1 | Row 1 Col 2 |");
+            sb.AppendLine("| Row 2 Col 1 | Row 2 Col 2 |");
+            var body = CreateTemplateWithMarkdownAndReturnBody(sb.ToString());
+            Assert.That(body.InnerXml, Is.EqualTo("<w:tbl xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:tblPr><w:tblW w:w=\"5000\" w:type=\"pct\" /></w:tblPr><w:tblGrid><w:gridCol /><w:gridCol /><w:gridCol /></w:tblGrid><w:tr><w:tc><w:tcPr><w:tcW w:type=\"auto\" /></w:tcPr><w:p><w:r><w:t>Header 1</w:t></w:r></w:p><w:p /></w:tc><w:tc><w:tcPr><w:tcW w:type=\"auto\" /></w:tcPr><w:p><w:r><w:t>Header 2</w:t></w:r></w:p><w:p /></w:tc></w:tr><w:tr><w:tc><w:tcPr><w:tcW w:type=\"auto\" /></w:tcPr><w:p><w:r><w:t>Row 1 Col 1</w:t></w:r></w:p><w:p /></w:tc><w:tc><w:tcPr><w:tcW w:type=\"auto\" /></w:tcPr><w:p><w:r><w:t>Row 1 Col 2</w:t></w:r></w:p><w:p /></w:tc></w:tr><w:tr><w:tc><w:tcPr><w:tcW w:type=\"auto\" /></w:tcPr><w:p><w:r><w:t>Row 2 Col 1</w:t></w:r></w:p><w:p /></w:tc><w:tc><w:tcPr><w:tcW w:type=\"auto\" /></w:tcPr><w:p><w:r><w:t>Row 2 Col 2</w:t></w:r></w:p><w:p /></w:tc></w:tr></w:tbl><w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" />"));
+        }
+
+        [Test]
+        public void Headings()
+        {
+
+            var sb = new StringBuilder();
+            sb.AppendLine("# Heading 1");
+            sb.AppendLine("Some text after heading");
+            sb.AppendLine("Next Line After heading");
+            sb.AppendLine("## Heading 2");
+            sb.AppendLine("Some text after heading");
+            sb.AppendLine("Next Line After heading");
+            sb.AppendLine("### Heading 3");
+            sb.AppendLine("Some text after heading");
+            sb.AppendLine("Next Line After heading");
+            sb.AppendLine("#### Heading 4");
+            sb.AppendLine("Some text after heading");
+            sb.AppendLine("Next Line After heading");
+            sb.AppendLine("##### Heading 5");
+            sb.AppendLine("Some text after heading");
+            sb.AppendLine("Next Line After heading");
+            sb.AppendLine("###### Heading 6");
+            var body = CreateTemplateWithMarkdownAndReturnBody(sb.ToString());
+            Assert.That(body.InnerXml, Is.EqualTo("<w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:pPr><w:pStyle w:val=\"Heading1\" /></w:pPr><w:r><w:t>Heading 1</w:t></w:r></w:p><w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:r><w:t>Some text after heading</w:t></w:r><w:r><w:br /></w:r><w:r><w:t>Next Line After heading</w:t></w:r></w:p><w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" /><w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:pPr><w:pStyle w:val=\"Heading2\" /></w:pPr><w:r><w:t>Heading 2</w:t></w:r></w:p><w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:r><w:t>Some text after heading</w:t></w:r><w:r><w:br /></w:r><w:r><w:t>Next Line After heading</w:t></w:r></w:p><w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" /><w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:pPr><w:pStyle w:val=\"Heading3\" /></w:pPr><w:r><w:t>Heading 3</w:t></w:r></w:p><w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:r><w:t>Some text after heading</w:t></w:r><w:r><w:br /></w:r><w:r><w:t>Next Line After heading</w:t></w:r></w:p><w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" /><w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:pPr><w:pStyle w:val=\"Heading4\" /></w:pPr><w:r><w:t>Heading 4</w:t></w:r></w:p><w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:r><w:t>Some text after heading</w:t></w:r><w:r><w:br /></w:r><w:r><w:t>Next Line After heading</w:t></w:r></w:p><w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" /><w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:pPr><w:pStyle w:val=\"Heading5\" /></w:pPr><w:r><w:t>Heading 5</w:t></w:r></w:p><w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:r><w:t>Some text after heading</w:t></w:r><w:r><w:br /></w:r><w:r><w:t>Next Line After heading</w:t></w:r></w:p><w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" /><w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\"><w:pPr><w:pStyle w:val=\"Heading6\" /></w:pPr><w:r><w:t>Heading 6</w:t></w:r></w:p><w:p xmlns:w=\"http://schemas.openxmlformats.org/wordprocessingml/2006/main\" />"));
+        }
+
+        [Test]
+        public void TestMarkDownInTemplateWithEmbeddedStyles()
+        {
+            using var fileStream = File.OpenRead("Resources/MarkdownTestTemplate.docx");
+            var docTemplate = new DocxTemplate(fileStream);
+
+            var sb = new StringBuilder();
+            sb.AppendLine("# This is a Table in a Table");
+            sb.AppendLine("Created from markdown");
+            sb.AppendLine();
+            sb.AppendLine("| Header 1 | Header 2 |");
+            sb.AppendLine("|----------|----------|");
+            sb.AppendLine("| Row 1 Col 1 | Row 1 Col 2 |");
+            sb.AppendLine("| Row 2 Col 1 | _Row 2_ **Col 2** |");
+
+            var sb2 = new StringBuilder();
+            sb2.AppendLine("# This is a List in a Table");
+            sb2.AppendLine("Created from markdown");
+            sb2.AppendLine("1. First");
+            sb2.AppendLine("2. Second");
+            sb2.AppendLine("   1. First First");
+            sb2.AppendLine("   2. First Second");
+            sb2.AppendLine("      1. First Second First");
+            sb2.AppendLine("      2. First Second Second");
+            sb2.AppendLine("   3. First Third");
+            sb2.AppendLine("3. Third");
+
+            var model = new
+            {
+                markdown = File.ReadAllText("Resources/TestMarkDown.md"),
+                markdownInTable = sb.ToString(),
+                markdownInTableList = sb2.ToString()
+            };
+            docTemplate.RegisterFormatter(new DocxTemplater.Markdown.MarkdownFormatter(new MarkDownFormatterConfiguration()
+            {
+                TableStyle = "MarkDownTestTableStyle"
+            }));
+            docTemplate.BindModel("ds", model);
+            var result = docTemplate.Process();
+            docTemplate.Validate();
+            Assert.That(result, Is.Not.Null);
+            result.SaveAsFileAndOpenInWord();
+        }
+
+        private Body CreateTemplateWithMarkdownAndReturnBody(string markdown)
+        {
+            using var memStream = new MemoryStream();
+            using var wpDocument = WordprocessingDocument.Create(memStream, WordprocessingDocumentType.Document);
+            MainDocumentPart mainPart = wpDocument.AddMainDocumentPart();
+            mainPart.Document =
+                new Document(new Body(new Paragraph(new Run(new Text("{{ds}:md}")))));
+            wpDocument.Save();
+            memStream.Position = 0;
+
+            var docTemplate = new DocxTemplate(memStream);
+            docTemplate.RegisterFormatter(new DocxTemplater.Markdown.MarkdownFormatter());
+            docTemplate.BindModel("ds", markdown);
+
+            var result = docTemplate.Process();
+            docTemplate.Validate();
+            Assert.That(result, Is.Not.Null);
+            result.SaveAsFileAndOpenInWord();
+            result.Position = 0;
+            var document = WordprocessingDocument.Open(result, false);
+            return document.MainDocumentPart.Document.Body;
+        }
+    }
+}
diff --git a/DocxTemplater.Test/Resources/MarkdownTestTemplate.docx b/DocxTemplater.Test/Resources/MarkdownTestTemplate.docx
new file mode 100644
index 0000000000000000000000000000000000000000..70dec21b266b5514dda004c46737de70d7e0cdf2
GIT binary patch
literal 15412
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
N^nFgSI-Gy}`#%S_>Fodj

literal 0
HcmV?d00001

diff --git a/DocxTemplater.Test/Resources/TestMarkDown.md b/DocxTemplater.Test/Resources/TestMarkDown.md
new file mode 100644
index 0000000..4886857
--- /dev/null
+++ b/DocxTemplater.Test/Resources/TestMarkDown.md
@@ -0,0 +1,65 @@
+## Headings
+
+---
+
+# h1 Heading
+## h2 Heading
+### h3 Heading
+#### h4 Heading
+##### h5 Heading
+###### h6 Heading
+
+
+## Horizontal Rules
+
+___
+
+---
+
+***
+
+## Emphasis
+
+**This is bold text**
+
+__This is bold text__
+
+*This is italic text*
+
+_This is italic text_
+
+~~Strikethrough~~  // Not yet supported
+
+## Lists
+
++ Create a list by starting a line with `+`, `-`, or `*`
++ Sub-lists are made by indenting 2 spaces:
+  - Marker character change forces new list start:
+    * Ac tristique libero volutpat at
+    + Facilisis in pretium nisl aliquet
+    - Nulla volutpat aliquam velit
++ Very easy!
+
+Ordered
+
+1. Lorem ipsum dolor sit amet
+2. Consectetur adipiscing elit
+3. Integer molestie lorem at massa
+
+
+1. You can use sequential numbers...
+1. ...or keep all the numbers as `1.`
+
+Start numbering with offset:
+
+57. foo
+1. bar
+
+## Tables
+
+| Syntax      | Description | Test Text     |
+| :---        |    :----:   |          ---: |
+| Header      | Title       | Here's this   |
+| Paragraph   | Text        | And more      |
+
+!!! Alignement is not yet supported
\ No newline at end of file
diff --git a/DocxTemplater.sln b/DocxTemplater.sln
index 3c6a17c..5cfaeca 100644
--- a/DocxTemplater.sln
+++ b/DocxTemplater.sln
@@ -1,53 +1,59 @@
-
-Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 17
-VisualStudioVersion = 17.8.34316.72
-MinimumVisualStudioVersion = 10.0.40219.1
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{0CD7C229-E003-4372-BCB5-8C6C83096A37}"
-	ProjectSection(SolutionItems) = preProject
-		.editorconfig = .editorconfig
-		Directory.Build.props = Directory.Build.props
-		GitVersion.yml = GitVersion.yml
-	EndProjectSection
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DocxTemplater", "DocxTemplater\DocxTemplater.csproj", "{3903B788-BBF1-49CB-8E0F-67A25B25815B}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DocxTemplater.Images", "DocxTemplater.Images\DocxTemplater.Images.csproj", "{315FB1E7-A136-4380-AF01-45B4929DE1C8}"
-EndProject
-Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DocxTemplater.Test", "DocxTemplater.Test\DocxTemplater.Test.csproj", "{C1F7FAB0-0807-4208-9BD8-E7E5BF6B5986}"
-EndProject
-Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "workflows", "workflows", "{63F28020-AE87-4C41-9020-A4236A324EEC}"
-	ProjectSection(SolutionItems) = preProject
-		.github\workflows\ci.yml = .github\workflows\ci.yml
-		.github\workflows\release.yml = .github\workflows\release.yml
-	EndProjectSection
-EndProject
-Global
-	GlobalSection(SolutionConfigurationPlatforms) = preSolution
-		Debug|Any CPU = Debug|Any CPU
-		Release|Any CPU = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(ProjectConfigurationPlatforms) = postSolution
-		{3903B788-BBF1-49CB-8E0F-67A25B25815B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{3903B788-BBF1-49CB-8E0F-67A25B25815B}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{3903B788-BBF1-49CB-8E0F-67A25B25815B}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{3903B788-BBF1-49CB-8E0F-67A25B25815B}.Release|Any CPU.Build.0 = Release|Any CPU
-		{315FB1E7-A136-4380-AF01-45B4929DE1C8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{315FB1E7-A136-4380-AF01-45B4929DE1C8}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{315FB1E7-A136-4380-AF01-45B4929DE1C8}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{315FB1E7-A136-4380-AF01-45B4929DE1C8}.Release|Any CPU.Build.0 = Release|Any CPU
-		{C1F7FAB0-0807-4208-9BD8-E7E5BF6B5986}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{C1F7FAB0-0807-4208-9BD8-E7E5BF6B5986}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{C1F7FAB0-0807-4208-9BD8-E7E5BF6B5986}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{C1F7FAB0-0807-4208-9BD8-E7E5BF6B5986}.Release|Any CPU.Build.0 = Release|Any CPU
-	EndGlobalSection
-	GlobalSection(SolutionProperties) = preSolution
-		HideSolutionNode = FALSE
-	EndGlobalSection
-	GlobalSection(NestedProjects) = preSolution
-		{63F28020-AE87-4C41-9020-A4236A324EEC} = {0CD7C229-E003-4372-BCB5-8C6C83096A37}
-	EndGlobalSection
-	GlobalSection(ExtensibilityGlobals) = postSolution
-		SolutionGuid = {87BDC60D-731C-4676-AEBA-FECF871AE24A}
-	EndGlobalSection
-EndGlobal
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.8.34316.72
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{0CD7C229-E003-4372-BCB5-8C6C83096A37}"
+	ProjectSection(SolutionItems) = preProject
+		.editorconfig = .editorconfig
+		Directory.Build.props = Directory.Build.props
+		GitVersion.yml = GitVersion.yml
+	EndProjectSection
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DocxTemplater", "DocxTemplater\DocxTemplater.csproj", "{3903B788-BBF1-49CB-8E0F-67A25B25815B}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DocxTemplater.Images", "DocxTemplater.Images\DocxTemplater.Images.csproj", "{315FB1E7-A136-4380-AF01-45B4929DE1C8}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "DocxTemplater.Test", "DocxTemplater.Test\DocxTemplater.Test.csproj", "{C1F7FAB0-0807-4208-9BD8-E7E5BF6B5986}"
+EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "workflows", "workflows", "{63F28020-AE87-4C41-9020-A4236A324EEC}"
+	ProjectSection(SolutionItems) = preProject
+		.github\workflows\ci.yml = .github\workflows\ci.yml
+		.github\workflows\release.yml = .github\workflows\release.yml
+	EndProjectSection
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DocxTemplater.Markdown", "DocxTemplater.Markdown\DocxTemplater.Markdown.csproj", "{D4CFD3BD-84B8-400C-A088-26FC15ADE80D}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{3903B788-BBF1-49CB-8E0F-67A25B25815B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{3903B788-BBF1-49CB-8E0F-67A25B25815B}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{3903B788-BBF1-49CB-8E0F-67A25B25815B}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{3903B788-BBF1-49CB-8E0F-67A25B25815B}.Release|Any CPU.Build.0 = Release|Any CPU
+		{315FB1E7-A136-4380-AF01-45B4929DE1C8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{315FB1E7-A136-4380-AF01-45B4929DE1C8}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{315FB1E7-A136-4380-AF01-45B4929DE1C8}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{315FB1E7-A136-4380-AF01-45B4929DE1C8}.Release|Any CPU.Build.0 = Release|Any CPU
+		{C1F7FAB0-0807-4208-9BD8-E7E5BF6B5986}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{C1F7FAB0-0807-4208-9BD8-E7E5BF6B5986}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{C1F7FAB0-0807-4208-9BD8-E7E5BF6B5986}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{C1F7FAB0-0807-4208-9BD8-E7E5BF6B5986}.Release|Any CPU.Build.0 = Release|Any CPU
+		{D4CFD3BD-84B8-400C-A088-26FC15ADE80D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{D4CFD3BD-84B8-400C-A088-26FC15ADE80D}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{D4CFD3BD-84B8-400C-A088-26FC15ADE80D}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{D4CFD3BD-84B8-400C-A088-26FC15ADE80D}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(NestedProjects) = preSolution
+		{63F28020-AE87-4C41-9020-A4236A324EEC} = {0CD7C229-E003-4372-BCB5-8C6C83096A37}
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {87BDC60D-731C-4676-AEBA-FECF871AE24A}
+	EndGlobalSection
+EndGlobal
diff --git a/DocxTemplater/OpenXmlHelper.cs b/DocxTemplater/OpenXmlHelper.cs
index ec07cc6..1883775 100644
--- a/DocxTemplater/OpenXmlHelper.cs
+++ b/DocxTemplater/OpenXmlHelper.cs
@@ -1,456 +1,502 @@
-using DocumentFormat.OpenXml;
-using DocumentFormat.OpenXml.Drawing.Wordprocessing;
-using DocumentFormat.OpenXml.Packaging;
-using DocumentFormat.OpenXml.Wordprocessing;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Xml;
-using System.Xml.Linq;
-using Run = DocumentFormat.OpenXml.Wordprocessing.Run;
-using RunProperties = DocumentFormat.OpenXml.Wordprocessing.RunProperties;
-using Table = DocumentFormat.OpenXml.Wordprocessing.Table;
-using Text = DocumentFormat.OpenXml.Wordprocessing.Text;
-
-namespace DocxTemplater
-{
-    public static class OpenXmlHelper
-    {
-        public static bool IsChildOf(this OpenXmlElement element, OpenXmlElement parent)
-        {
-            ArgumentNullException.ThrowIfNull(element, nameof(element));
-            ArgumentNullException.ThrowIfNull(element);
-            ArgumentNullException.ThrowIfNull(parent);
-            var current = element.Parent;
-            while (current != null)
-            {
-                if (current == parent)
-                {
-                    return true;
-                }
-
-                current = current.Parent;
-            }
-            return false;
-        }
-
-
-        /// <summary>
-        /// Traverses the tree upwards and returns the first element of the given type.
-        /// </summary>
-        /// <typeparam name="TElement"></typeparam>
-        /// <param name="element"></param>
-        /// <returns></returns>
-        public static OpenXmlElement ElementBeforeInDocument<TElement>(this OpenXmlElement element)
-            where TElement : OpenXmlElement
-        {
-            var parent = element.Parent;
-            while (parent != null)
-            {
-                var result = (parent?.Descendants<TElement>()).LastOrDefault(x => x.IsBefore(element));
-                if (result != null)
-                {
-                    return result;
-                }
-                parent = parent.PreviousSibling() ?? parent.Parent;
-            }
-            return null;
-        }
-
-        public static OpenXmlElement ElementAfterInDocument<TElement>(this OpenXmlElement element)
-            where TElement : OpenXmlElement
-        {
-            var parent = element.Parent;
-            while (parent != null)
-            {
-                var result = parent?.Descendants<TElement>().FirstOrDefault(x => x.IsAfter(element));
-                if (result != null)
-                {
-                    return result;
-                }
-                parent = parent.NextSibling() ?? parent.Parent;
-            }
-            return null;
-        }
-
-        public static OpenXmlElement FindCommonParent(this OpenXmlElement element, OpenXmlElement otherElement)
-        {
-            ArgumentNullException.ThrowIfNull(element);
-            ArgumentNullException.ThrowIfNull(otherElement);
-            var current = element.Parent;
-            while (current != null)
-            {
-                if (otherElement.IsChildOf(current))
-                {
-                    return current;
-                }
-                current = current.Parent;
-            }
-            return null;
-        }
-
-        /// <summary>
-        /// Splits the element after the given descendant element.
-        /// And returns the two parts of the split element.
-        /// </summary>
-        public static IReadOnlyCollection<OpenXmlElement> SplitAfterElement(this OpenXmlElement elementToSplit, OpenXmlElement element)
-        {
-            return elementToSplit.SplitAtElement(element, false);
-        }
-
-        public static IReadOnlyCollection<OpenXmlElement> SplitBeforeElement(this OpenXmlElement elementToSplit, OpenXmlElement element)
-        {
-            return elementToSplit.SplitAtElement(element, true);
-        }
-
-        private static IReadOnlyCollection<OpenXmlElement> SplitAtElement(this OpenXmlElement elementToSplit, OpenXmlElement element, bool beforeElement)
-        {
-            if (elementToSplit == element)
-            {
-                return new List<OpenXmlElement>() { elementToSplit };
-            }
-            var result = new List<OpenXmlElement>() { elementToSplit };
-            var parent = element.Parent ?? throw new ArgumentException("cannot split a root node without parent");
-            var childs = beforeElement ? parent.ChildsBefore(element).ToList() : parent.ChildsAfter(element).ToList();
-            if (childs.Count > 0)
-            {
-                var clonedParent = (OpenXmlElement)parent.CloneNode(false);
-                if (parent.Parent != null)
-                {
-                    if (beforeElement)
-                    {
-                        parent.InsertBeforeSelf(clonedParent);
-                    }
-                    else
-                    {
-                        parent.InsertAfterSelf(clonedParent);
-                    }
-                }
-                foreach (var child in childs)
-                {
-                    child.Remove();
-                    clonedParent.AppendChild(child);
-                }
-
-                if (beforeElement)
-                {
-                    result.Insert(0, clonedParent);
-                }
-                else
-                {
-                    result.Add(clonedParent);
-                }
-            }
-            if (elementToSplit == parent)
-            {
-                return result;
-            }
-            return elementToSplit.SplitAtElement(parent, beforeElement);
-        }
-
-        public static IEnumerable<OpenXmlElement> ChildsBefore(this OpenXmlElement parent, OpenXmlElement child)
-        {
-            foreach (var c in parent.ChildElements)
-            {
-                if (c == child)
-                {
-                    yield break;
-                }
-                yield return c;
-            }
-        }
-
-        public static IEnumerable<OpenXmlElement> ChildsAfter(this OpenXmlElement parent, OpenXmlElement child)
-        {
-            bool found = false;
-            foreach (var c in parent.ChildElements)
-            {
-                if (found)
-                {
-                    yield return c;
-                }
-                else if (c == child)
-                {
-                    found = true;
-                }
-            }
-        }
-        public static IEnumerable<OpenXmlElement> ChildsBetween(this OpenXmlElement parent, OpenXmlElement startChild, OpenXmlElement endChild)
-        {
-            bool found = false;
-            foreach (var c in parent.ChildElements)
-            {
-                if (found)
-                {
-                    if (c == endChild)
-                    {
-                        yield break;
-                    }
-                    yield return c;
-                }
-                else if (c == startChild)
-                {
-                    found = true;
-                }
-            }
-        }
-
-        public static OpenXmlElement InsertAfterSelf(this OpenXmlElement element, IEnumerable<OpenXmlElement> elements)
-        {
-            foreach (var e in elements)
-            {
-                element.InsertAfterSelf(e);
-                element = e;
-            }
-            return element;
-        }
-
-        public static OpenXmlElement InsertBeforeSelf(this OpenXmlElement element, IEnumerable<OpenXmlElement> elements)
-        {
-            foreach (var e in elements.Reverse())
-            {
-                element.InsertBeforeSelf(e);
-            }
-            return element;
-        }
-
-        public static Text MergeText(this Text first, int startIndex, Text last, int length)
-        {
-            var commonParent = first.FindCommonParent(last) ?? throw new ArgumentException("Text elements must have a common parent");
-            if (startIndex < 0 || startIndex >= first.Text.Length)
-            {
-                throw new ArgumentOutOfRangeException(nameof(startIndex));
-            }
-            var matchInSameElement = first == last;
-            var firstTextLength = first.Text.Length;
-            if (startIndex != 0) // leading text is not part of the match
-            {
-                first = first.SplitAtIndex(startIndex);
-            }
-            if (startIndex + length < firstTextLength) // trailing text part of the match in the first element
-            {
-                first.SplitAtIndex(length);
-            }
-
-            if (matchInSameElement)
-            {
-                return first;
-            }
-
-            List<OpenXmlElement> toRemove = new();
-            bool found = false;
-            foreach (var current in commonParent.Descendants<Text>())
-            {
-                if (current == first)
-                {
-                    found = true;
-                    continue;
-                }
-                if (!found)
-                {
-                    continue;
-                }
-
-                // trailing text is not part of the match int the last element
-                if (first.Text.Length + current.Text.Length > length)
-                {
-                    var firstPart = current.Text[..(length - first.Text.Length)];
-                    var secondPart = current.Text[(length - first.Text.Length)..];
-                    first.Text += firstPart;
-                    current.Text = secondPart;
-                    break;
-                }
-                first.Text += current.Text;
-                toRemove.Add(current);
-                if (current == last)
-                {
-                    break;
-                }
-            }
-            foreach (var text in toRemove)
-            {
-                text.RemoveWithEmptyParent();
-            }
-            return first;
-        }
-
-        public static Text SplitAtIndex(this Text element, int startIndexSecondPart)
-        {
-            if (startIndexSecondPart < 0 || startIndexSecondPart >= element.Text.Length)
-            {
-                throw new ArgumentOutOfRangeException(nameof(startIndexSecondPart));
-            }
-            var firstPart = element.Text[..startIndexSecondPart];
-            var secondPart = element.Text[startIndexSecondPart..];
-            element.Text = firstPart;
-            var newElement = element.InsertAfterSelf(new Text(secondPart));
-            element.Space = SpaceProcessingModeValues.Preserve;
-            newElement.Space = SpaceProcessingModeValues.Preserve;
-            return newElement;
-        }
-
-        public static string ToPrettyPrintXml(this IEnumerable<OpenXmlElement> elements)
-        {
-            var sb = new StringBuilder();
-            sb.AppendLine("<root>");
-            foreach (var element in elements)
-            {
-                sb.AppendLine(element.InnerXml);
-            }
-            sb.AppendLine("</root>");
-            var xmldoc = XDocument.Parse(sb.ToString());
-            // remove all xmlns attributes
-            foreach (var e in xmldoc.Descendants())
-            {
-                e.Attributes().Where(a => a.IsNamespaceDeclaration).Remove();
-            }
-
-            foreach (var elem in xmldoc.Descendants())
-            {
-                elem.Name = elem.Name.LocalName;
-            }
-            return xmldoc.ToString();
-        }
-
-        public static string ToPrettyPrintXml(this OpenXmlElement element)
-        {
-            var xmldoc = XDocument.Parse(element.OuterXml);
-            return xmldoc.ToString();
-        }
-
-        public static string PrintTree(this OpenXmlElement element, StringBuilder sb = null, int indent = 0)
-        {
-            sb ??= new StringBuilder();
-            sb.AppendLine($"{new string(' ', indent)}parent ({element.Parent?.GetType()?.Name}){element.GetType().Name}({element.GetType().Namespace})");
-            var attributes = element.GetAttributes();
-            if (attributes.Any())
-            {
-                sb.AppendLine($"{new string(' ', indent + 2)}Attributes:");
-                foreach (var attribute in attributes)
-                {
-                    sb.AppendLine($"{new string(' ', indent + 4)}{attribute.LocalName} = {attribute.Value}");
-                }
-            }
-            foreach (var child in element.ChildElements)
-            {
-                child.PrintTree(sb, indent + 2);
-            }
-            return sb.ToString();
-        }
-
-
-        public static OpenXmlElement GetRoot(this OpenXmlElement element)
-        {
-            var current = element;
-            while (current.Parent != null)
-            {
-                current = current.Parent;
-            }
-            return current;
-        }
-
-        public static T GetFirstAncestor<T>(this OpenXmlElement element)
-        where T : OpenXmlElement
-        {
-            var current = element.Parent;
-            while (current != null)
-            {
-                if (current is T t)
-                {
-                    return t;
-                }
-                current = current.Parent;
-            }
-            return null;
-        }
-
-
-        public static void RemoveWithEmptyParent(this OpenXmlElement element)
-        {
-            var parent = element.Parent;
-            bool removeParent = true;
-            if (parent != null)
-            {
-                if (element is TableCell)
-                {
-                    removeParent = parent.ChildElements.OfType<TableCell>().Count() == 1;
-                }
-                else if (element is TableRow row)
-                {
-                    var rowProperties = row.ChildElements.OfType<TableRowProperties>().FirstOrDefault();
-                    if (rowProperties != null)
-                    {
-                        var nextSibling = row.NextSibling<TableRow>();
-                        if (nextSibling != null)
-                        {
-                            var nextRowProperties = nextSibling.ChildElements.OfType<TableRowProperties>().FirstOrDefault();
-                            if (nextRowProperties == null)
-                            {
-                                rowProperties.Remove();
-                                nextSibling.AddChild(rowProperties);
-                            }
-                        }
-                    }
-                }
-                else
-                {
-                    removeParent = !element.ChildElements.Any(x => x is not Languages and not RunProperties and not ParagraphProperties);
-                }
-
-                if (removeParent)
-                {
-                    element.Remove();
-                    RemoveWithEmptyParent(parent);
-                }
-            }
-        }
-
-        public static uint GetMaxDocPropertyId(this OpenXmlPart doc)
-        {
-            if (doc.RootElement == null)
-            {
-                return 0;
-            }
-            return doc
-                .RootElement
-                .Descendants<DocProperties>()
-                .Max(x => (uint?)x.Id) ?? 0;
-        }
-
-        public static OpenXmlElement ParseOpenXmlString(string openXmlString)
-        {
-            XmlDocument xmlDoc = new();
-            xmlDoc.LoadXml(openXmlString);
-            var localName = xmlDoc.DocumentElement.LocalName;
-            OpenXmlElement element = null;
-            switch (localName)
-            {
-                case "p":
-                    element = new Paragraph(openXmlString);
-                    break;
-                case "r":
-                    element = new Run(openXmlString);
-                    break;
-                case "t":
-                    element = new Text(openXmlString);
-                    break;
-                case "tbl":
-                    element = new Table(openXmlString);
-                    break;
-                case "tr":
-                    element = new TableRow(openXmlString);
-                    break;
-                case "tc":
-                    element = new TableCell(openXmlString);
-                    break;
-            }
-            if (element == null)
-            {
-                throw new InvalidOperationException("Unsupported OpenXml element: " + localName);
-            }
-            return element;
-        }
-
-    }
-}
+using DocumentFormat.OpenXml;
+using DocumentFormat.OpenXml.Packaging;
+using DocumentFormat.OpenXml.Wordprocessing;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Xml;
+using System.Xml.Linq;
+using DocumentFormat.OpenXml.Drawing.Wordprocessing;
+
+
+namespace DocxTemplater
+{
+    public static class OpenXmlHelper
+    {
+        public static bool IsChildOf(this OpenXmlElement element, OpenXmlElement parent)
+        {
+            ArgumentNullException.ThrowIfNull(element, nameof(element));
+            ArgumentNullException.ThrowIfNull(element);
+            ArgumentNullException.ThrowIfNull(parent);
+            var current = element.Parent;
+            while (current != null)
+            {
+                if (current == parent)
+                {
+                    return true;
+                }
+
+                current = current.Parent;
+            }
+            return false;
+        }
+
+        public static Style FindTableStyleByName(this MainDocumentPart mainDocumentPart, string name)
+        {
+            var part = mainDocumentPart.StyleDefinitionsPart;
+            if (part == null)
+            {
+                return null;
+            }
+            return part.Styles?.Elements<Style>().FirstOrDefault(x => x.StyleId == name);
+        }
+
+
+        /// <summary>
+        /// Traverses the tree upwards and returns the first element of the given type.
+        /// </summary>
+        /// <typeparam name="TElement"></typeparam>
+        /// <param name="element"></param>
+        /// <returns></returns>
+        public static OpenXmlElement ElementBeforeInDocument<TElement>(this OpenXmlElement element)
+            where TElement : OpenXmlElement
+        {
+            var parent = element.Parent;
+            while (parent != null)
+            {
+                var result = (parent?.Descendants<TElement>()).LastOrDefault(x => x.IsBefore(element));
+                if (result != null)
+                {
+                    return result;
+                }
+                parent = parent.PreviousSibling() ?? parent.Parent;
+            }
+            return null;
+        }
+
+        public static OpenXmlElement ElementAfterInDocument<TElement>(this OpenXmlElement element)
+            where TElement : OpenXmlElement
+        {
+            var parent = element.Parent;
+            while (parent != null)
+            {
+                var result = parent?.Descendants<TElement>().FirstOrDefault(x => x.IsAfter(element));
+                if (result != null)
+                {
+                    return result;
+                }
+                parent = parent.NextSibling() ?? parent.Parent;
+            }
+            return null;
+        }
+
+        public static AbstractNum CreateNewAbstractNumbering(this Numbering numbering)
+        {
+            var abstractNum = new AbstractNum()
+            {
+                MultiLevelType = new MultiLevelType() { Val = MultiLevelValues.HybridMultilevel }
+            };
+            int bulletAbstractNumId = numbering.Elements<AbstractNum>()
+                .Where(x => x.AbstractNumberId != null)
+                .Select(x => x.AbstractNumberId.Value).DefaultIfEmpty(0).Max() + 1;
+            abstractNum.AbstractNumberId = bulletAbstractNumId;
+
+            return numbering.InsertAfterLastChildOfSameType(abstractNum);
+        }
+
+        public static NumberingInstance CreateNewNumberingInstance(this Numbering numbering, int abstractNumberingId)
+        {
+            var numberIngInstance = new NumberingInstance(new AbstractNumId() { Val = abstractNumberingId })
+            {
+                NumberID = numbering.Elements<NumberingInstance>().Count() + 1
+            };
+            return numbering.InsertAfterLastChildOfSameType(numberIngInstance);
+        }
+
+        public static T InsertAfterLastChildOfSameType<T>(this OpenXmlCompositeElement parent, T newChild)
+            where T : OpenXmlElement
+        {
+            var lastChild = parent.ChildElements.LastOrDefault(x => x.GetType() == newChild.GetType());
+            if (lastChild != null)
+            {
+                parent.InsertAfter(newChild, lastChild);
+            }
+            else
+            {
+                parent.AppendChild(newChild);
+            }
+            return newChild;
+        }
+
+
+        public static OpenXmlElement FindCommonParent(this OpenXmlElement element, OpenXmlElement otherElement)
+        {
+            ArgumentNullException.ThrowIfNull(element);
+            ArgumentNullException.ThrowIfNull(otherElement);
+            var current = element.Parent;
+            while (current != null)
+            {
+                if (otherElement.IsChildOf(current))
+                {
+                    return current;
+                }
+                current = current.Parent;
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// Splits the element after the given descendant element.
+        /// And returns the two parts of the split element.
+        /// </summary>
+        public static IReadOnlyCollection<OpenXmlElement> SplitAfterElement(this OpenXmlElement elementToSplit, OpenXmlElement element)
+        {
+            return elementToSplit.SplitAtElement(element, false);
+        }
+
+        public static IReadOnlyCollection<OpenXmlElement> SplitBeforeElement(this OpenXmlElement elementToSplit, OpenXmlElement element)
+        {
+            return elementToSplit.SplitAtElement(element, true);
+        }
+
+        private static IReadOnlyCollection<OpenXmlElement> SplitAtElement(this OpenXmlElement elementToSplit, OpenXmlElement element, bool beforeElement)
+        {
+            if (elementToSplit == element)
+            {
+                return new List<OpenXmlElement>() { elementToSplit };
+            }
+            var result = new List<OpenXmlElement>() { elementToSplit };
+            var parent = element.Parent ?? throw new ArgumentException("cannot split a root node without parent");
+            var childs = beforeElement ? parent.ChildsBefore(element).ToList() : parent.ChildsAfter(element).ToList();
+            if (childs.Count > 0)
+            {
+                var clonedParent = (OpenXmlElement)parent.CloneNode(false);
+                if (parent.Parent != null)
+                {
+                    if (beforeElement)
+                    {
+                        parent.InsertBeforeSelf(clonedParent);
+                    }
+                    else
+                    {
+                        parent.InsertAfterSelf(clonedParent);
+                    }
+                }
+                foreach (var child in childs)
+                {
+                    child.Remove();
+                    clonedParent.AppendChild(child);
+                }
+
+                if (beforeElement)
+                {
+                    result.Insert(0, clonedParent);
+                }
+                else
+                {
+                    result.Add(clonedParent);
+                }
+            }
+            if (elementToSplit == parent)
+            {
+                return result;
+            }
+            return elementToSplit.SplitAtElement(parent, beforeElement);
+        }
+
+        public static IEnumerable<OpenXmlElement> ChildsBefore(this OpenXmlElement parent, OpenXmlElement child)
+        {
+            foreach (var c in parent.ChildElements)
+            {
+                if (c == child)
+                {
+                    yield break;
+                }
+                yield return c;
+            }
+        }
+
+        public static IEnumerable<OpenXmlElement> ChildsAfter(this OpenXmlElement parent, OpenXmlElement child)
+        {
+            bool found = false;
+            foreach (var c in parent.ChildElements)
+            {
+                if (found)
+                {
+                    yield return c;
+                }
+                else if (c == child)
+                {
+                    found = true;
+                }
+            }
+        }
+        public static IEnumerable<OpenXmlElement> ChildsBetween(this OpenXmlElement parent, OpenXmlElement startChild, OpenXmlElement endChild)
+        {
+            bool found = false;
+            foreach (var c in parent.ChildElements)
+            {
+                if (found)
+                {
+                    if (c == endChild)
+                    {
+                        yield break;
+                    }
+                    yield return c;
+                }
+                else if (c == startChild)
+                {
+                    found = true;
+                }
+            }
+        }
+
+        public static OpenXmlElement InsertAfterSelf(this OpenXmlElement element, IEnumerable<OpenXmlElement> elements)
+        {
+            foreach (var e in elements)
+            {
+                element.InsertAfterSelf(e);
+                element = e;
+            }
+            return element;
+        }
+
+        public static OpenXmlElement InsertBeforeSelf(this OpenXmlElement element, IEnumerable<OpenXmlElement> elements)
+        {
+            foreach (var e in elements.Reverse())
+            {
+                element.InsertBeforeSelf(e);
+            }
+            return element;
+        }
+
+        public static Text MergeText(this Text first, int startIndex, Text last, int length)
+        {
+            var commonParent = first.FindCommonParent(last) ?? throw new ArgumentException("Text elements must have a common parent");
+            if (startIndex < 0 || startIndex >= first.Text.Length)
+            {
+                throw new ArgumentOutOfRangeException(nameof(startIndex));
+            }
+            var matchInSameElement = first == last;
+            var firstTextLength = first.Text.Length;
+            if (startIndex != 0) // leading text is not part of the match
+            {
+                first = first.SplitAtIndex(startIndex);
+            }
+            if (startIndex + length < firstTextLength) // trailing text part of the match in the first element
+            {
+                first.SplitAtIndex(length);
+            }
+
+            if (matchInSameElement)
+            {
+                return first;
+            }
+
+            List<OpenXmlElement> toRemove = new();
+            bool found = false;
+            foreach (var current in commonParent.Descendants<Text>())
+            {
+                if (current == first)
+                {
+                    found = true;
+                    continue;
+                }
+                if (!found)
+                {
+                    continue;
+                }
+
+                // trailing text is not part of the match int the last element
+                if (first.Text.Length + current.Text.Length > length)
+                {
+                    var firstPart = current.Text[..(length - first.Text.Length)];
+                    var secondPart = current.Text[(length - first.Text.Length)..];
+                    first.Text += firstPart;
+                    current.Text = secondPart;
+                    break;
+                }
+                first.Text += current.Text;
+                toRemove.Add(current);
+                if (current == last)
+                {
+                    break;
+                }
+            }
+            foreach (var text in toRemove)
+            {
+                text.RemoveWithEmptyParent();
+            }
+            return first;
+        }
+
+        public static Text SplitAtIndex(this Text element, int startIndexSecondPart)
+        {
+            if (startIndexSecondPart < 0 || startIndexSecondPart >= element.Text.Length)
+            {
+                throw new ArgumentOutOfRangeException(nameof(startIndexSecondPart));
+            }
+            var firstPart = element.Text[..startIndexSecondPart];
+            var secondPart = element.Text[startIndexSecondPart..];
+            element.Text = firstPart;
+            var newElement = element.InsertAfterSelf(new Text(secondPart));
+            element.Space = SpaceProcessingModeValues.Preserve;
+            newElement.Space = SpaceProcessingModeValues.Preserve;
+            return newElement;
+        }
+
+        public static string ToPrettyPrintXml(this IEnumerable<OpenXmlElement> elements)
+        {
+            var sb = new StringBuilder();
+            sb.AppendLine("<root>");
+            foreach (var element in elements)
+            {
+                sb.AppendLine(element.InnerXml);
+            }
+            sb.AppendLine("</root>");
+            var xmldoc = XDocument.Parse(sb.ToString());
+            // remove all xmlns attributes
+            foreach (var e in xmldoc.Descendants())
+            {
+                e.Attributes().Where(a => a.IsNamespaceDeclaration).Remove();
+            }
+
+            foreach (var elem in xmldoc.Descendants())
+            {
+                elem.Name = elem.Name.LocalName;
+            }
+            return xmldoc.ToString();
+        }
+
+        public static string ToPrettyPrintXml(this OpenXmlElement element)
+        {
+            var xmldoc = XDocument.Parse(element.OuterXml);
+            return xmldoc.ToString();
+        }
+
+        public static string PrintTree(this OpenXmlElement element, StringBuilder sb = null, int indent = 0)
+        {
+            sb ??= new StringBuilder();
+            sb.AppendLine($"{new string(' ', indent)}parent ({element.Parent?.GetType()?.Name}){element.GetType().Name}({element.GetType().Namespace})");
+            var attributes = element.GetAttributes();
+            if (attributes.Any())
+            {
+                sb.AppendLine($"{new string(' ', indent + 2)}Attributes:");
+                foreach (var attribute in attributes)
+                {
+                    sb.AppendLine($"{new string(' ', indent + 4)}{attribute.LocalName} = {attribute.Value}");
+                }
+            }
+            foreach (var child in element.ChildElements)
+            {
+                child.PrintTree(sb, indent + 2);
+            }
+            return sb.ToString();
+        }
+
+
+        public static OpenXmlElement GetRoot(this OpenXmlElement element)
+        {
+            var current = element;
+            while (current.Parent != null)
+            {
+                current = current.Parent;
+            }
+            return current;
+        }
+
+        public static T GetFirstAncestor<T>(this OpenXmlElement element)
+        where T : OpenXmlElement
+        {
+            var current = element.Parent;
+            while (current != null)
+            {
+                if (current is T t)
+                {
+                    return t;
+                }
+                current = current.Parent;
+            }
+            return null;
+        }
+
+
+        public static void RemoveWithEmptyParent(this OpenXmlElement element)
+        {
+            var parent = element.Parent;
+            bool removeParent = true;
+            if (parent != null)
+            {
+                if (element is TableCell)
+                {
+                    removeParent = parent.ChildElements.OfType<TableCell>().Count() == 1;
+                }
+                else if (element is TableRow row)
+                {
+                    var rowProperties = row.ChildElements.OfType<TableRowProperties>().FirstOrDefault();
+                    if (rowProperties != null)
+                    {
+                        var nextSibling = row.NextSibling<TableRow>();
+                        if (nextSibling != null)
+                        {
+                            var nextRowProperties = nextSibling.ChildElements.OfType<TableRowProperties>().FirstOrDefault();
+                            if (nextRowProperties == null)
+                            {
+                                rowProperties.Remove();
+                                nextSibling.AddChild(rowProperties);
+                            }
+                        }
+                    }
+                }
+                else
+                {
+                    removeParent = !element.ChildElements.Any(x => x is not Languages and not RunProperties and not ParagraphProperties);
+                }
+
+                if (removeParent)
+                {
+                    element.Remove();
+                    RemoveWithEmptyParent(parent);
+                }
+            }
+        }
+
+        public static uint GetMaxDocPropertyId(this OpenXmlPart doc)
+        {
+            if (doc.RootElement == null)
+            {
+                return 0;
+            }
+            return doc
+                .RootElement
+                .Descendants<DocProperties>()
+                .Max(x => (uint?)x.Id) ?? 0;
+        }
+
+        public static OpenXmlElement ParseOpenXmlString(string openXmlString)
+        {
+            XmlDocument xmlDoc = new();
+            xmlDoc.LoadXml(openXmlString);
+            var localName = xmlDoc.DocumentElement.LocalName;
+            OpenXmlElement element = null;
+            switch (localName)
+            {
+                case "p":
+                    element = new Paragraph(openXmlString);
+                    break;
+                case "r":
+                    element = new Run(openXmlString);
+                    break;
+                case "t":
+                    element = new Text(openXmlString);
+                    break;
+                case "tbl":
+                    element = new Table(openXmlString);
+                    break;
+                case "tr":
+                    element = new TableRow(openXmlString);
+                    break;
+                case "tc":
+                    element = new TableCell(openXmlString);
+                    break;
+            }
+            if (element == null)
+            {
+                throw new InvalidOperationException("Unsupported OpenXml element: " + localName);
+            }
+            return element;
+        }
+
+    }
+}

From b750bea1fa1181aef94e04cf698d03b459d25ca6 Mon Sep 17 00:00:00 2001
From: Manuel Amstutz <manuel.amstutz@orphis.ch>
Date: Wed, 12 Jun 2024 08:35:47 +0200
Subject: [PATCH 3/4] Add interfaces for ScriptCompiler and ModelLookup to
 encapsulate internal types

---
 .../Blocks/CollectionSeparatorBlock.cs        |  68 +--
 DocxTemplater/Blocks/ConditionalBlock.cs      | 110 ++--
 DocxTemplater/Blocks/ContentBlock.cs          | 508 ++++++++--------
 DocxTemplater/Blocks/DynamicTableBlock.cs     | 238 ++++----
 DocxTemplater/Blocks/LoopBlock.cs             |  94 +--
 DocxTemplater/DocxTemplate.cs                 | 231 +++----
 DocxTemplater/Formatter/IFormatter.cs         |  24 +-
 .../Formatter/IFormatterInitialization.cs     |  11 +
 DocxTemplater/Formatter/IVariableReplacer.cs  |  13 +
 DocxTemplater/Formatter/VariableReplacer.cs   | 240 ++++----
 DocxTemplater/IModelLookup.cs                 |  13 +
 DocxTemplater/IScriptCompiler.cs              |  10 +
 DocxTemplater/InternalsVisibleTo.cs           |   3 +
 DocxTemplater/ModelLookup.cs                  | 334 +++++------
 DocxTemplater/PatternType.cs                  |  30 +-
 DocxTemplater/ScriptCompiler.cs               | 184 +++---
 DocxTemplater/TemplateProcessor.cs            | 563 +++++++++---------
 DocxTemplater/VariableScope.cs                |  18 +-
 DocxTemplater/XmlNodeTemplate.cs              |  42 +-
 19 files changed, 1394 insertions(+), 1340 deletions(-)
 create mode 100644 DocxTemplater/Formatter/IFormatterInitialization.cs
 create mode 100644 DocxTemplater/Formatter/IVariableReplacer.cs
 create mode 100644 DocxTemplater/IModelLookup.cs
 create mode 100644 DocxTemplater/IScriptCompiler.cs
 create mode 100644 DocxTemplater/InternalsVisibleTo.cs

diff --git a/DocxTemplater/Blocks/CollectionSeparatorBlock.cs b/DocxTemplater/Blocks/CollectionSeparatorBlock.cs
index 13cf5ec..f0635cd 100644
--- a/DocxTemplater/Blocks/CollectionSeparatorBlock.cs
+++ b/DocxTemplater/Blocks/CollectionSeparatorBlock.cs
@@ -1,34 +1,34 @@
-using DocumentFormat.OpenXml;
-using DocumentFormat.OpenXml.Wordprocessing;
-using DocxTemplater.Formatter;
-using System.Collections.Generic;
-
-namespace DocxTemplater.Blocks
-{
-    internal class CollectionSeparatorBlock : ContentBlock
-    {
-        public CollectionSeparatorBlock(VariableReplacer variableReplacer, PatternType patternType, Text startTextNode,
-            PatternMatch startMatch)
-            : base(variableReplacer, patternType, startTextNode, startMatch)
-        {
-        }
-
-        public override void Expand(ModelLookup models, OpenXmlElement parentNode)
-        {
-            int count = (int)models.GetValue($"{ParentBlock.StartMatch.Variable}._Idx");
-            int length = (int)models.GetValue($"{ParentBlock.StartMatch.Variable}._Length");
-            // last element is rendered first - get length and count ot to not render the last separator
-            if (length - count == 0)
-            {
-                return;
-            }
-            base.Expand(models, parentNode);
-        }
-
-        protected override void InsertContent(OpenXmlElement parentNode, IEnumerable<OpenXmlElement> paragraphs)
-        {
-            var element = m_insertionPoint.GetElement(parentNode) ?? throw new OpenXmlTemplateException($"Insertion point {m_insertionPoint.Id} not found");
-            element.InsertBeforeSelf(paragraphs);
-        }
-    }
-}
+using DocumentFormat.OpenXml;
+using DocumentFormat.OpenXml.Wordprocessing;
+using DocxTemplater.Formatter;
+using System.Collections.Generic;
+
+namespace DocxTemplater.Blocks
+{
+    internal class CollectionSeparatorBlock : ContentBlock
+    {
+        public CollectionSeparatorBlock(IVariableReplacer variableReplacer, PatternType patternType, Text startTextNode,
+            PatternMatch startMatch)
+            : base(variableReplacer, patternType, startTextNode, startMatch)
+        {
+        }
+
+        public override void Expand(IModelLookup models, OpenXmlElement parentNode)
+        {
+            int count = (int)models.GetValue($"{ParentBlock.StartMatch.Variable}._Idx");
+            int length = (int)models.GetValue($"{ParentBlock.StartMatch.Variable}._Length");
+            // last element is rendered first - get length and count ot to not render the last separator
+            if (length - count == 0)
+            {
+                return;
+            }
+            base.Expand(models, parentNode);
+        }
+
+        protected override void InsertContent(OpenXmlElement parentNode, IEnumerable<OpenXmlElement> paragraphs)
+        {
+            var element = m_insertionPoint.GetElement(parentNode) ?? throw new OpenXmlTemplateException($"Insertion point {m_insertionPoint.Id} not found");
+            element.InsertBeforeSelf(paragraphs);
+        }
+    }
+}
diff --git a/DocxTemplater/Blocks/ConditionalBlock.cs b/DocxTemplater/Blocks/ConditionalBlock.cs
index 2c2640d..6ea8c9d 100644
--- a/DocxTemplater/Blocks/ConditionalBlock.cs
+++ b/DocxTemplater/Blocks/ConditionalBlock.cs
@@ -1,56 +1,56 @@
-using System.Diagnostics;
-using System.Linq;
-using DocumentFormat.OpenXml;
-using DocumentFormat.OpenXml.Wordprocessing;
-using DocxTemplater.Formatter;
-
-namespace DocxTemplater.Blocks
-{
-    internal class ConditionalBlock : ContentBlock
-    {
-        private readonly string m_condition;
-        private readonly ScriptCompiler m_scriptCompiler;
-
-
-        public ConditionalBlock(VariableReplacer variableReplacer, ScriptCompiler scriptCompiler, PatternType patternType, Text startTextNode, PatternMatch startMatch)
-            : base(variableReplacer, patternType, startTextNode, startMatch)
-        {
-            m_condition = startMatch.Condition;
-            m_scriptCompiler = scriptCompiler;
-        }
-
-        public override void Expand(ModelLookup models, OpenXmlElement parentNode)
-        {
-            bool conditionResult = false;
-            try
-            {
-                conditionResult = m_scriptCompiler.CompileScript(m_condition)();
-            }
-            catch (OpenXmlTemplateException) when (m_scriptCompiler.ProcessSettings.BindingErrorHandling != BindingErrorHandling.ThrowException)
-            {
-            }
-            var cloned = m_content.Select(x => x.CloneNode(true)).ToList();
-            InsertContent(parentNode, cloned);
-            m_variableReplacer.ReplaceVariables(cloned);
-            Debug.Assert(m_childBlocks.Count is 1 or 2);
-
-            var elseBlock = m_childBlocks.Count > 1 ? m_childBlocks[1] : null;
-            var conditionBlock = m_childBlocks[0];
-            if (conditionResult)
-            {
-                conditionBlock.Expand(models, parentNode);
-            }
-            else if (m_childBlocks.Count > 1)
-            {
-                elseBlock?.Expand(models, parentNode);
-            }
-            conditionBlock.RemoveAnchor(parentNode);
-            elseBlock?.RemoveAnchor(parentNode);
-        }
-
-        public override string ToString()
-        {
-            return $"ConditionalBlock: {m_condition}";
-        }
-    }
+using System.Diagnostics;
+using System.Linq;
+using DocumentFormat.OpenXml;
+using DocumentFormat.OpenXml.Wordprocessing;
+using DocxTemplater.Formatter;
+
+namespace DocxTemplater.Blocks
+{
+    internal class ConditionalBlock : ContentBlock
+    {
+        private readonly string m_condition;
+        private readonly IScriptCompiler m_scriptCompiler;
+
+
+        public ConditionalBlock(IVariableReplacer variableReplacer, IScriptCompiler scriptCompiler, PatternType patternType, Text startTextNode, PatternMatch startMatch)
+            : base(variableReplacer, patternType, startTextNode, startMatch)
+        {
+            m_condition = startMatch.Condition;
+            m_scriptCompiler = scriptCompiler;
+        }
+
+        public override void Expand(IModelLookup models, OpenXmlElement parentNode)
+        {
+            bool conditionResult = false;
+            try
+            {
+                conditionResult = m_scriptCompiler.CompileScript(m_condition)();
+            }
+            catch (OpenXmlTemplateException) when (m_scriptCompiler.ProcessSettings.BindingErrorHandling != BindingErrorHandling.ThrowException)
+            {
+            }
+            var cloned = m_content.Select(x => x.CloneNode(true)).ToList();
+            InsertContent(parentNode, cloned);
+            m_variableReplacer.ReplaceVariables(cloned);
+            Debug.Assert(m_childBlocks.Count is 1 or 2);
+
+            var elseBlock = m_childBlocks.Count > 1 ? m_childBlocks[1] : null;
+            var conditionBlock = m_childBlocks[0];
+            if (conditionResult)
+            {
+                conditionBlock.Expand(models, parentNode);
+            }
+            else if (m_childBlocks.Count > 1)
+            {
+                elseBlock?.Expand(models, parentNode);
+            }
+            conditionBlock.RemoveAnchor(parentNode);
+            elseBlock?.RemoveAnchor(parentNode);
+        }
+
+        public override string ToString()
+        {
+            return $"ConditionalBlock: {m_condition}";
+        }
+    }
 }
\ No newline at end of file
diff --git a/DocxTemplater/Blocks/ContentBlock.cs b/DocxTemplater/Blocks/ContentBlock.cs
index 3199bf1..68c010c 100644
--- a/DocxTemplater/Blocks/ContentBlock.cs
+++ b/DocxTemplater/Blocks/ContentBlock.cs
@@ -1,255 +1,255 @@
-using DocumentFormat.OpenXml;
-using DocumentFormat.OpenXml.Wordprocessing;
-using DocxTemplater.Formatter;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace DocxTemplater.Blocks
-{
-    internal class ContentBlock
-    {
-        protected InsertionPoint m_insertionPoint;
-        protected IReadOnlyCollection<OpenXmlElement> m_content;
-        protected readonly List<ContentBlock> m_childBlocks;
-        protected readonly VariableReplacer m_variableReplacer;
-#pragma warning disable IDE0052
-        private InsertionPoint m_lastElementMarker;
-#pragma warning restore IDE0052
-
-        public ContentBlock()
-        {
-            PatternType = PatternType.None;
-            m_content = new List<OpenXmlElement>();
-            m_childBlocks = new List<ContentBlock>();
-        }
-
-        public ContentBlock(VariableReplacer variableReplacer, PatternType patternType, Text startTextNode, PatternMatch startMatch)
-        {
-            m_content = new List<OpenXmlElement>();
-            m_childBlocks = new List<ContentBlock>();
-            m_variableReplacer = variableReplacer;
-            PatternType = patternType;
-            StartTextNode = startTextNode ?? throw new ArgumentNullException(nameof(startTextNode));
-            StartMatch = startMatch ?? throw new ArgumentNullException(nameof(startMatch));
-        }
-
-        public static ContentBlock Crate(
-            VariableReplacer variableReplacer,
-            ScriptCompiler scriptCompiler,
-            PatternType patternType,
-            Text startTextNode,
-            PatternMatch matchedStartNode)
-        {
-            return patternType switch
-            {
-                PatternType.CollectionStart when matchedStartNode.Formatter.Equals("dyntable", StringComparison.InvariantCultureIgnoreCase) => new DynamicTableBlock(variableReplacer, patternType, startTextNode, matchedStartNode),
-                PatternType.CollectionStart => new LoopBlock(variableReplacer, patternType, startTextNode, matchedStartNode),
-                PatternType.CollectionSeparator => new CollectionSeparatorBlock(variableReplacer, patternType, startTextNode, matchedStartNode),
-                PatternType.Condition => new ConditionalBlock(variableReplacer, scriptCompiler, patternType, startTextNode, matchedStartNode),
-                _ => new ContentBlock(variableReplacer, patternType, startTextNode, matchedStartNode)
-            };
-        }
-
-        public PatternType PatternType
-        {
-            get;
-        }
-
-        public Text StartTextNode
-        {
-            get;
-        }
-
-        public Text EndTextNode
-        {
-            get;
-            private set;
-        }
-
-        public PatternMatch StartMatch
-        {
-            get;
-        }
-
-        public PatternMatch EndMatch
-        {
-            get;
-            private set;
-        }
-
-        public IReadOnlyCollection<OpenXmlElement> Content => m_content;
-
-        public ContentBlock ParentBlock { get; private set; }
-
-        public OpenXmlElement ParentNode { get; set; }
-
-        public OpenXmlElement LastElement { get; set; }
-
-        public OpenXmlElement FirstElement { get; set; }
-
-
-        public IReadOnlyCollection<ContentBlock> ChildBlocks => m_childBlocks;
-
-        public virtual void Expand(ModelLookup models, OpenXmlElement parentNode)
-        {
-            InsertContentAndReplaceVariables(models, parentNode);
-            ExpandChildBlocks(models, parentNode);
-            RemoveChildBlockInsertionPoints(parentNode);
-        }
-
-        protected virtual void InsertContentAndReplaceVariables(ModelLookup models, OpenXmlElement parentNode)
-        {
-            var cloned = m_content.Select(x => x.CloneNode(true)).ToList();
-            InsertContent(parentNode, cloned);
-            m_variableReplacer.ReplaceVariables(cloned);
-        }
-
-        public virtual void ExpandChildBlocks(ModelLookup models, OpenXmlElement parentNode)
-        {
-            foreach (var child in m_childBlocks)
-            {
-                child.Expand(models, parentNode);
-            }
-        }
-
-        protected virtual void RemoveChildBlockInsertionPoints(OpenXmlElement parentNode)
-        {
-            foreach (var child in m_childBlocks)
-            {
-                child.RemoveAnchor(parentNode);
-            }
-        }
-
-        protected virtual void InsertContent(OpenXmlElement parentNode, IEnumerable<OpenXmlElement> paragraphs)
-        {
-            var element = m_insertionPoint.GetElement(parentNode) ?? throw new OpenXmlTemplateException($"Insertion point {m_insertionPoint.Id} not found");
-            element.InsertAfterSelf(paragraphs);
-        }
-
-        public void RemoveAnchor(OpenXmlElement parentNode)
-        {
-            var element = m_insertionPoint.GetElement(parentNode) ?? throw new OpenXmlTemplateException($"Insertion point {m_insertionPoint.Id} not found");
-            element.Remove();
-        }
-
-        public override string ToString()
-        {
-            return $"{StartTextNode.Text}_{m_insertionPoint}";
-        }
-
-
-        public virtual void AddChildBlock(ContentBlock block)
-        {
-            block.ParentBlock = this;
-            m_childBlocks.Add(block);
-        }
-
-        public void Print(int i)
-        {
-            Console.WriteLine(new string('-', i + 1) + ToString());
-            Console.WriteLine(m_content.ToPrettyPrintXml());
-            foreach (var block in m_childBlocks)
-            {
-                block.Print(i + 2);
-            }
-        }
-
-        public void CloseBlock(Text endTextNode, PatternMatch matchedEndNode)
-        {
-            EndTextNode = endTextNode;
-            EndMatch = matchedEndNode;
-        }
-
-        public virtual void ExtractContentRecursively()
-        {
-            foreach (var child in m_childBlocks)
-            {
-                child.ExtractContentRecursively();
-            }
-            m_content = ParentNode.ChildsBetween(FirstElement, LastElement).ToList();
-            foreach (var content in m_content)
-            {
-                content.Remove();
-            }
-        }
-
-        public virtual void Validate()
-        {
-            foreach (var child in ChildBlocks)
-            {
-                var childIp = child.m_insertionPoint;
-                if (!m_content.SelectMany(x => x.Descendants()).Concat(m_content).Any(childIp.IsForElement))
-                {
-                    throw new OpenXmlTemplateException($"Insertion Point {childIp.Id} of child {child} not found in {this}\r\n{m_content.ToPrettyPrintXml()}");
-                }
-            }
-        }
-
-        public void AddInsertionPointsRecursively()
-        {
-            AddInsertionPoints();
-            foreach (var child in m_childBlocks)
-            {
-                child.AddInsertionPointsRecursively();
-            }
-        }
-
-        private void AddInsertionPoints()
-        {
-            ParentNode = StartTextNode.FindCommonParent(EndTextNode) ?? throw new OpenXmlTemplateException("Start and end text are not in the same tree");
-            if (ParentNode is TableRow tableRow)
-            {
-                FirstElement = tableRow.InsertBeforeSelf(new TableRow());
-                LastElement = tableRow.InsertAfterSelf(new TableRow());
-                ParentNode = tableRow.Parent;
-            }
-            else if (ParentNode is Table)
-            {
-                var firstRow = ParentNode.Elements<TableRow>().First(StartTextNode.IsChildOf);
-                var lastRow = ParentNode.Elements<TableRow>().First(EndTextNode.IsChildOf);
-                FirstElement = firstRow.InsertBeforeSelf(new TableRow());
-                LastElement = lastRow.InsertAfterSelf(new TableRow());
-            }
-            else
-            {
-                // find childs of common parent that contains start and end text
-                var startChildOfCommonParent = ParentNode.ChildElements.Single(c => c == StartTextNode || c.Descendants<Text>().Any(d => d == StartTextNode));
-                var endChildOfCommonParent = ParentNode.ChildElements.Single(c => c == EndTextNode || c.Descendants<Text>().Any(d => d == EndTextNode));
-                var split = startChildOfCommonParent.SplitAfterElement(StartTextNode);
-                OpenXmlElement anchorElement = null;
-                if (split.Count == 1)
-                {
-                    // already split - only first part returned
-                    var nextElement = split.First().NextSibling();
-
-                    // if two blocks opens there is already an anchor of the parent element
-                    while (InsertionPoint.HasAlreadyInsertionPointMarker(nextElement))
-                    {
-                        nextElement = nextElement.NextSibling();
-                    }
-                    anchorElement = nextElement.InsertBeforeSelf(new Paragraph());
-                }
-                else
-                {
-                    var splitLastPart = split.Last();
-                    anchorElement = splitLastPart.InsertBeforeSelf(new Paragraph());
-                }
-
-                if (startChildOfCommonParent == endChildOfCommonParent)
-                {
-                    FirstElement = anchorElement;
-                    LastElement = endChildOfCommonParent;
-                }
-                else
-                {
-                    var endSplit = endChildOfCommonParent.SplitBeforeElement(EndTextNode);
-                    FirstElement = anchorElement;
-                    LastElement = endSplit.Last();
-                }
-            }
-            m_insertionPoint = InsertionPoint.CreateForElement(FirstElement, $"{PatternType}");
-            m_lastElementMarker = InsertionPoint.CreateForElement(LastElement, $"End_{PatternType}");
-        }
-    }
+using DocumentFormat.OpenXml;
+using DocumentFormat.OpenXml.Wordprocessing;
+using DocxTemplater.Formatter;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace DocxTemplater.Blocks
+{
+    internal class ContentBlock
+    {
+        protected InsertionPoint m_insertionPoint;
+        protected IReadOnlyCollection<OpenXmlElement> m_content;
+        protected readonly List<ContentBlock> m_childBlocks;
+        protected readonly IVariableReplacer m_variableReplacer;
+#pragma warning disable IDE0052
+        private InsertionPoint m_lastElementMarker;
+#pragma warning restore IDE0052
+
+        public ContentBlock()
+        {
+            PatternType = PatternType.None;
+            m_content = new List<OpenXmlElement>();
+            m_childBlocks = new List<ContentBlock>();
+        }
+
+        public ContentBlock(IVariableReplacer variableReplacer, PatternType patternType, Text startTextNode, PatternMatch startMatch)
+        {
+            m_content = new List<OpenXmlElement>();
+            m_childBlocks = new List<ContentBlock>();
+            m_variableReplacer = variableReplacer;
+            PatternType = patternType;
+            StartTextNode = startTextNode ?? throw new ArgumentNullException(nameof(startTextNode));
+            StartMatch = startMatch ?? throw new ArgumentNullException(nameof(startMatch));
+        }
+
+        public static ContentBlock Crate(
+            IVariableReplacer variableReplacer,
+            IScriptCompiler scriptCompiler,
+            PatternType patternType,
+            Text startTextNode,
+            PatternMatch matchedStartNode)
+        {
+            return patternType switch
+            {
+                PatternType.CollectionStart when matchedStartNode.Formatter.Equals("dyntable", StringComparison.InvariantCultureIgnoreCase) => new DynamicTableBlock(variableReplacer, patternType, startTextNode, matchedStartNode),
+                PatternType.CollectionStart => new LoopBlock(variableReplacer, patternType, startTextNode, matchedStartNode),
+                PatternType.CollectionSeparator => new CollectionSeparatorBlock(variableReplacer, patternType, startTextNode, matchedStartNode),
+                PatternType.Condition => new ConditionalBlock(variableReplacer, scriptCompiler, patternType, startTextNode, matchedStartNode),
+                _ => new ContentBlock(variableReplacer, patternType, startTextNode, matchedStartNode)
+            };
+        }
+
+        public PatternType PatternType
+        {
+            get;
+        }
+
+        public Text StartTextNode
+        {
+            get;
+        }
+
+        public Text EndTextNode
+        {
+            get;
+            private set;
+        }
+
+        public PatternMatch StartMatch
+        {
+            get;
+        }
+
+        public PatternMatch EndMatch
+        {
+            get;
+            private set;
+        }
+
+        public IReadOnlyCollection<OpenXmlElement> Content => m_content;
+
+        public ContentBlock ParentBlock { get; private set; }
+
+        public OpenXmlElement ParentNode { get; set; }
+
+        public OpenXmlElement LastElement { get; set; }
+
+        public OpenXmlElement FirstElement { get; set; }
+
+
+        public IReadOnlyCollection<ContentBlock> ChildBlocks => m_childBlocks;
+
+        public virtual void Expand(IModelLookup models, OpenXmlElement parentNode)
+        {
+            InsertContentAndReplaceVariables(models, parentNode);
+            ExpandChildBlocks(models, parentNode);
+            RemoveChildBlockInsertionPoints(parentNode);
+        }
+
+        protected virtual void InsertContentAndReplaceVariables(IModelLookup models, OpenXmlElement parentNode)
+        {
+            var cloned = m_content.Select(x => x.CloneNode(true)).ToList();
+            InsertContent(parentNode, cloned);
+            m_variableReplacer.ReplaceVariables(cloned);
+        }
+
+        public virtual void ExpandChildBlocks(IModelLookup models, OpenXmlElement parentNode)
+        {
+            foreach (var child in m_childBlocks)
+            {
+                child.Expand(models, parentNode);
+            }
+        }
+
+        protected virtual void RemoveChildBlockInsertionPoints(OpenXmlElement parentNode)
+        {
+            foreach (var child in m_childBlocks)
+            {
+                child.RemoveAnchor(parentNode);
+            }
+        }
+
+        protected virtual void InsertContent(OpenXmlElement parentNode, IEnumerable<OpenXmlElement> paragraphs)
+        {
+            var element = m_insertionPoint.GetElement(parentNode) ?? throw new OpenXmlTemplateException($"Insertion point {m_insertionPoint.Id} not found");
+            element.InsertAfterSelf(paragraphs);
+        }
+
+        public void RemoveAnchor(OpenXmlElement parentNode)
+        {
+            var element = m_insertionPoint.GetElement(parentNode) ?? throw new OpenXmlTemplateException($"Insertion point {m_insertionPoint.Id} not found");
+            element.Remove();
+        }
+
+        public override string ToString()
+        {
+            return $"{StartTextNode.Text}_{m_insertionPoint}";
+        }
+
+
+        public virtual void AddChildBlock(ContentBlock block)
+        {
+            block.ParentBlock = this;
+            m_childBlocks.Add(block);
+        }
+
+        public void Print(int i)
+        {
+            Console.WriteLine(new string('-', i + 1) + ToString());
+            Console.WriteLine(m_content.ToPrettyPrintXml());
+            foreach (var block in m_childBlocks)
+            {
+                block.Print(i + 2);
+            }
+        }
+
+        public void CloseBlock(Text endTextNode, PatternMatch matchedEndNode)
+        {
+            EndTextNode = endTextNode;
+            EndMatch = matchedEndNode;
+        }
+
+        public virtual void ExtractContentRecursively()
+        {
+            foreach (var child in m_childBlocks)
+            {
+                child.ExtractContentRecursively();
+            }
+            m_content = ParentNode.ChildsBetween(FirstElement, LastElement).ToList();
+            foreach (var content in m_content)
+            {
+                content.Remove();
+            }
+        }
+
+        public virtual void Validate()
+        {
+            foreach (var child in ChildBlocks)
+            {
+                var childIp = child.m_insertionPoint;
+                if (!m_content.SelectMany(x => x.Descendants()).Concat(m_content).Any(childIp.IsForElement))
+                {
+                    throw new OpenXmlTemplateException($"Insertion Point {childIp.Id} of child {child} not found in {this}\r\n{m_content.ToPrettyPrintXml()}");
+                }
+            }
+        }
+
+        public void AddInsertionPointsRecursively()
+        {
+            AddInsertionPoints();
+            foreach (var child in m_childBlocks)
+            {
+                child.AddInsertionPointsRecursively();
+            }
+        }
+
+        private void AddInsertionPoints()
+        {
+            ParentNode = StartTextNode.FindCommonParent(EndTextNode) ?? throw new OpenXmlTemplateException("Start and end text are not in the same tree");
+            if (ParentNode is TableRow tableRow)
+            {
+                FirstElement = tableRow.InsertBeforeSelf(new TableRow());
+                LastElement = tableRow.InsertAfterSelf(new TableRow());
+                ParentNode = tableRow.Parent;
+            }
+            else if (ParentNode is Table)
+            {
+                var firstRow = ParentNode.Elements<TableRow>().First(StartTextNode.IsChildOf);
+                var lastRow = ParentNode.Elements<TableRow>().First(EndTextNode.IsChildOf);
+                FirstElement = firstRow.InsertBeforeSelf(new TableRow());
+                LastElement = lastRow.InsertAfterSelf(new TableRow());
+            }
+            else
+            {
+                // find childs of common parent that contains start and end text
+                var startChildOfCommonParent = ParentNode.ChildElements.Single(c => c == StartTextNode || c.Descendants<Text>().Any(d => d == StartTextNode));
+                var endChildOfCommonParent = ParentNode.ChildElements.Single(c => c == EndTextNode || c.Descendants<Text>().Any(d => d == EndTextNode));
+                var split = startChildOfCommonParent.SplitAfterElement(StartTextNode);
+                OpenXmlElement anchorElement = null;
+                if (split.Count == 1)
+                {
+                    // already split - only first part returned
+                    var nextElement = split.First().NextSibling();
+
+                    // if two blocks opens there is already an anchor of the parent element
+                    while (InsertionPoint.HasAlreadyInsertionPointMarker(nextElement))
+                    {
+                        nextElement = nextElement.NextSibling();
+                    }
+                    anchorElement = nextElement.InsertBeforeSelf(new Paragraph());
+                }
+                else
+                {
+                    var splitLastPart = split.Last();
+                    anchorElement = splitLastPart.InsertBeforeSelf(new Paragraph());
+                }
+
+                if (startChildOfCommonParent == endChildOfCommonParent)
+                {
+                    FirstElement = anchorElement;
+                    LastElement = endChildOfCommonParent;
+                }
+                else
+                {
+                    var endSplit = endChildOfCommonParent.SplitBeforeElement(EndTextNode);
+                    FirstElement = anchorElement;
+                    LastElement = endSplit.Last();
+                }
+            }
+            m_insertionPoint = InsertionPoint.CreateForElement(FirstElement, $"{PatternType}");
+            m_lastElementMarker = InsertionPoint.CreateForElement(LastElement, $"End_{PatternType}");
+        }
+    }
 }
\ No newline at end of file
diff --git a/DocxTemplater/Blocks/DynamicTableBlock.cs b/DocxTemplater/Blocks/DynamicTableBlock.cs
index fc06239..69dd9e2 100644
--- a/DocxTemplater/Blocks/DynamicTableBlock.cs
+++ b/DocxTemplater/Blocks/DynamicTableBlock.cs
@@ -1,119 +1,119 @@
-using System.Collections.Generic;
-using System.Linq;
-using DocumentFormat.OpenXml;
-using DocumentFormat.OpenXml.Wordprocessing;
-using DocxTemplater.Formatter;
-
-namespace DocxTemplater.Blocks
-{
-    internal class DynamicTableBlock : ContentBlock
-    {
-        private readonly string m_tablenName;
-
-        public DynamicTableBlock(VariableReplacer variableReplacer, PatternType patternType, Text startTextNode, PatternMatch startMatch)
-            : base(variableReplacer, patternType, startTextNode, startMatch)
-        {
-            m_tablenName = startMatch.Variable;
-        }
-
-        public override void Expand(ModelLookup models, OpenXmlElement parentNode)
-        {
-            var model = models.GetValue(m_tablenName);
-            if (model is IDynamicTable dynamicTable)
-            {
-                if (!dynamicTable.Headers.Any())
-                {
-                    return;
-                }
-
-                var headersName = $"{m_tablenName}.{nameof(IDynamicTable.Headers)}";
-                var columnsName = $"{m_tablenName}.{nameof(IDynamicTable.Rows)}";
-
-                // kind of a hack to get the table from the child block
-                // TODO: refactor this to create wrapper block as ContentBlock and DynamicTableBlock as child
-                var child = m_childBlocks.Single();
-                var childContent = m_childBlocks.Single().Content;
-                var table = childContent.OfType<Table>().FirstOrDefault();
-                var headerRow = table?.Elements<TableRow>().FirstOrDefault(row => row.Descendants<Text>().Any(d => d.HasMarker(PatternType.Variable) && d.Text.Contains($"{{{{{headersName}")));
-                var headerCell = headerRow?.Elements<TableCell>().FirstOrDefault();
-
-                var dataRow = table?.Elements<TableRow>().FirstOrDefault(row => row.Descendants<Text>().Any(d => d.HasMarker(PatternType.Variable) && d.Text.Contains($"{{{{{columnsName}")));
-                var dataCell = dataRow?.Elements<TableCell>().FirstOrDefault(row => row.Descendants<Text>().Any(d => d.HasMarker(PatternType.Variable) && d.Text.Contains($"{{{{{columnsName}")));
-                if (headerCell == null || dataCell == null)
-                {
-                    throw new OpenXmlTemplateException($"Dynamic table block must contain exactly one table with at least a header and a data row");
-                }
-
-                // write headers
-                foreach (var header in dynamicTable.Headers.Reverse())
-                {
-                    using var headerScope = models.OpenScope();
-                    headerScope.AddVariable(headersName, header);
-                    var clonedCell = headerCell.CloneNode(true);
-                    headerCell.InsertAfterSelf(clonedCell);
-                    m_variableReplacer.ReplaceVariables(clonedCell);
-                    child.ExpandChildBlocks(models, parentNode);
-                }
-                // remove header cell
-                headerCell.Remove();
-
-                // write data
-                var lastRow = dataRow;
-                var cellInsertionPoint = InsertionPoint.CreateForElement(dataCell, "dc");
-                foreach (var row in dynamicTable.Rows)
-                {
-                    TableRow clonedRow = (TableRow)dataRow.CloneNode(true);
-                    lastRow.InsertAfterSelf(clonedRow);
-                    lastRow = clonedRow;
-
-                    var insertion = cellInsertionPoint.GetElement(clonedRow);
-                    foreach (var column in row.Reverse())
-                    {
-                        using var columnScope = models.OpenScope();
-                        columnScope.AddVariable(columnsName, column);
-                        var clonedCell = dataCell.CloneNode(true);
-                        insertion.InsertAfterSelf(clonedCell);
-                        m_variableReplacer.ReplaceVariables(clonedCell);
-                        child.ExpandChildBlocks(models, parentNode);
-                    }
-                    insertion.Remove();
-                }
-                dataRow.Remove();
-                dataCell.Remove();
-
-                // ensure all rows have the same number of cells
-                var maxCells = dynamicTable.Rows.DefaultIfEmpty().Max(r => r?.Count() ?? 0);
-                foreach (var row in table.Elements<TableRow>())
-                {
-                    var cells = row.Elements<TableCell>().ToList();
-                    while (cells.Count < maxCells)
-                    {
-                        var cell = (TableCell)cells.Last().CloneNode(true);
-                        cells.Last().InsertAfterSelf(cell);
-                        cells.Add(cell);
-                    }
-                }
-
-                InsertContent(parentNode, new List<OpenXmlElement> { table });
-            }
-            else
-            {
-                throw new OpenXmlTemplateException($"Value of {m_tablenName} is not of type {typeof(IDynamicTable)}");
-            }
-        }
-
-        public override void Validate()
-        {
-            base.Validate();
-            if (m_childBlocks.Count != 1)
-            {
-                throw new OpenXmlTemplateException($"Dynamic table block must contain exactly one child block");
-            }
-        }
-
-        public override string ToString()
-        {
-            return $"Dynamic Table: {m_tablenName}";
-        }
-    }
-}
+using System.Collections.Generic;
+using System.Linq;
+using DocumentFormat.OpenXml;
+using DocumentFormat.OpenXml.Wordprocessing;
+using DocxTemplater.Formatter;
+
+namespace DocxTemplater.Blocks
+{
+    internal class DynamicTableBlock : ContentBlock
+    {
+        private readonly string m_tablenName;
+
+        public DynamicTableBlock(IVariableReplacer variableReplacer, PatternType patternType, Text startTextNode, PatternMatch startMatch)
+            : base(variableReplacer, patternType, startTextNode, startMatch)
+        {
+            m_tablenName = startMatch.Variable;
+        }
+
+        public override void Expand(IModelLookup models, OpenXmlElement parentNode)
+        {
+            var model = models.GetValue(m_tablenName);
+            if (model is IDynamicTable dynamicTable)
+            {
+                if (!dynamicTable.Headers.Any())
+                {
+                    return;
+                }
+
+                var headersName = $"{m_tablenName}.{nameof(IDynamicTable.Headers)}";
+                var columnsName = $"{m_tablenName}.{nameof(IDynamicTable.Rows)}";
+
+                // kind of a hack to get the table from the child block
+                // TODO: refactor this to create wrapper block as ContentBlock and DynamicTableBlock as child
+                var child = m_childBlocks.Single();
+                var childContent = m_childBlocks.Single().Content;
+                var table = childContent.OfType<Table>().FirstOrDefault();
+                var headerRow = table?.Elements<TableRow>().FirstOrDefault(row => row.Descendants<Text>().Any(d => d.HasMarker(PatternType.Variable) && d.Text.Contains($"{{{{{headersName}")));
+                var headerCell = headerRow?.Elements<TableCell>().FirstOrDefault();
+
+                var dataRow = table?.Elements<TableRow>().FirstOrDefault(row => row.Descendants<Text>().Any(d => d.HasMarker(PatternType.Variable) && d.Text.Contains($"{{{{{columnsName}")));
+                var dataCell = dataRow?.Elements<TableCell>().FirstOrDefault(row => row.Descendants<Text>().Any(d => d.HasMarker(PatternType.Variable) && d.Text.Contains($"{{{{{columnsName}")));
+                if (headerCell == null || dataCell == null)
+                {
+                    throw new OpenXmlTemplateException($"Dynamic table block must contain exactly one table with at least a header and a data row");
+                }
+
+                // write headers
+                foreach (var header in dynamicTable.Headers.Reverse())
+                {
+                    using var headerScope = models.OpenScope();
+                    headerScope.AddVariable(headersName, header);
+                    var clonedCell = headerCell.CloneNode(true);
+                    headerCell.InsertAfterSelf(clonedCell);
+                    m_variableReplacer.ReplaceVariables(clonedCell);
+                    child.ExpandChildBlocks(models, parentNode);
+                }
+                // remove header cell
+                headerCell.Remove();
+
+                // write data
+                var lastRow = dataRow;
+                var cellInsertionPoint = InsertionPoint.CreateForElement(dataCell, "dc");
+                foreach (var row in dynamicTable.Rows)
+                {
+                    TableRow clonedRow = (TableRow)dataRow.CloneNode(true);
+                    lastRow.InsertAfterSelf(clonedRow);
+                    lastRow = clonedRow;
+
+                    var insertion = cellInsertionPoint.GetElement(clonedRow);
+                    foreach (var column in row.Reverse())
+                    {
+                        using var columnScope = models.OpenScope();
+                        columnScope.AddVariable(columnsName, column);
+                        var clonedCell = dataCell.CloneNode(true);
+                        insertion.InsertAfterSelf(clonedCell);
+                        m_variableReplacer.ReplaceVariables(clonedCell);
+                        child.ExpandChildBlocks(models, parentNode);
+                    }
+                    insertion.Remove();
+                }
+                dataRow.Remove();
+                dataCell.Remove();
+
+                // ensure all rows have the same number of cells
+                var maxCells = dynamicTable.Rows.DefaultIfEmpty().Max(r => r?.Count() ?? 0);
+                foreach (var row in table.Elements<TableRow>())
+                {
+                    var cells = row.Elements<TableCell>().ToList();
+                    while (cells.Count < maxCells)
+                    {
+                        var cell = (TableCell)cells.Last().CloneNode(true);
+                        cells.Last().InsertAfterSelf(cell);
+                        cells.Add(cell);
+                    }
+                }
+
+                InsertContent(parentNode, new List<OpenXmlElement> { table });
+            }
+            else
+            {
+                throw new OpenXmlTemplateException($"Value of {m_tablenName} is not of type {typeof(IDynamicTable)}");
+            }
+        }
+
+        public override void Validate()
+        {
+            base.Validate();
+            if (m_childBlocks.Count != 1)
+            {
+                throw new OpenXmlTemplateException($"Dynamic table block must contain exactly one child block");
+            }
+        }
+
+        public override string ToString()
+        {
+            return $"Dynamic Table: {m_tablenName}";
+        }
+    }
+}
diff --git a/DocxTemplater/Blocks/LoopBlock.cs b/DocxTemplater/Blocks/LoopBlock.cs
index 7d6798a..ee2431a 100644
--- a/DocxTemplater/Blocks/LoopBlock.cs
+++ b/DocxTemplater/Blocks/LoopBlock.cs
@@ -1,48 +1,48 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using DocumentFormat.OpenXml;
-using DocxTemplater.Formatter;
-using Text = DocumentFormat.OpenXml.Wordprocessing.Text;
-
-namespace DocxTemplater.Blocks
-{
-    internal class LoopBlock : ContentBlock
-    {
-        private readonly string m_collectionName;
-
-        public LoopBlock(VariableReplacer variableReplacer, PatternType patternType, Text startTextNode, PatternMatch startMatch)
-            : base(variableReplacer, patternType, startTextNode, startMatch)
-        {
-            m_collectionName = startMatch.Variable;
-        }
-
-        public override void Expand(ModelLookup models, OpenXmlElement parentNode)
-        {
-            var model = models.GetValue(m_collectionName);
-            if (model is IEnumerable<object> enumerable)
-            {
-                var items = enumerable.Reverse().ToList();
-                int counter = items.Count;
-                foreach (var item in items)
-                {
-                    using var loopScope = models.OpenScope();
-                    loopScope.AddVariable(m_collectionName, item);
-                    loopScope.AddVariable($"{m_collectionName}._Idx", counter);
-                    loopScope.AddVariable($"{m_collectionName}._Length", items.Count);
-                    base.Expand(models, parentNode);
-                    counter--;
-                }
-            }
-            else if (model != null)
-            {
-                throw new OpenXmlTemplateException($"Value of {m_collectionName} is not enumerable - it is of type {model.GetType().FullName}");
-            }
-        }
-
-        public override string ToString()
-        {
-            return $"LoopBlock: {m_collectionName}";
-        }
-    }
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using DocumentFormat.OpenXml;
+using DocxTemplater.Formatter;
+using Text = DocumentFormat.OpenXml.Wordprocessing.Text;
+
+namespace DocxTemplater.Blocks
+{
+    internal class LoopBlock : ContentBlock
+    {
+        private readonly string m_collectionName;
+
+        public LoopBlock(IVariableReplacer variableReplacer, PatternType patternType, Text startTextNode, PatternMatch startMatch)
+            : base(variableReplacer, patternType, startTextNode, startMatch)
+        {
+            m_collectionName = startMatch.Variable;
+        }
+
+        public override void Expand(IModelLookup models, OpenXmlElement parentNode)
+        {
+            var model = models.GetValue(m_collectionName);
+            if (model is IEnumerable<object> enumerable)
+            {
+                var items = enumerable.Reverse().ToList();
+                int counter = items.Count;
+                foreach (var item in items)
+                {
+                    using var loopScope = models.OpenScope();
+                    loopScope.AddVariable(m_collectionName, item);
+                    loopScope.AddVariable($"{m_collectionName}._Idx", counter);
+                    loopScope.AddVariable($"{m_collectionName}._Length", items.Count);
+                    base.Expand(models, parentNode);
+                    counter--;
+                }
+            }
+            else if (model != null)
+            {
+                throw new OpenXmlTemplateException($"Value of {m_collectionName} is not enumerable - it is of type {model.GetType().FullName}");
+            }
+        }
+
+        public override string ToString()
+        {
+            return $"LoopBlock: {m_collectionName}";
+        }
+    }
 }
\ No newline at end of file
diff --git a/DocxTemplater/DocxTemplate.cs b/DocxTemplater/DocxTemplate.cs
index 4677ef5..f1891fd 100644
--- a/DocxTemplater/DocxTemplate.cs
+++ b/DocxTemplater/DocxTemplate.cs
@@ -1,115 +1,116 @@
-using DocumentFormat.OpenXml;
-using DocumentFormat.OpenXml.Packaging;
-using DocumentFormat.OpenXml.Validation;
-using DocxTemplater.Formatter;
-using System;
-using System.IO;
-using System.Linq;
-
-namespace DocxTemplater
-{
-    public sealed class DocxTemplate : TemplateProcessor, IDisposable
-    {
-        private readonly Stream m_stream;
-        private readonly WordprocessingDocument m_wpDocument;
-
-        private static readonly FileFormatVersions TargetMinimumVersion = FileFormatVersions.Office2010;
-
-        public DocxTemplate(Stream docXStream)
-        : this(docXStream, ProcessSettings.Default)
-        {
-        }
-
-        public DocxTemplate(Stream docXStream, ProcessSettings settings)
-            : this(docXStream, settings, new ModelLookup())
-        {
-        }
-
-        private DocxTemplate(Stream docXStream, ProcessSettings settings, ModelLookup modelLookup)
-        : base(settings, modelLookup, new VariableReplacer(modelLookup, settings), new ScriptCompiler(modelLookup, settings))
-        {
-            ArgumentNullException.ThrowIfNull(docXStream);
-            m_stream = new MemoryStream();
-            docXStream.CopyTo(m_stream);
-            m_stream.Position = 0;
-            // Add the MarkupCompatibilityProcessSettings
-            OpenSettings openSettings = new()
-            {
-                MarkupCompatibilityProcessSettings =
-                new MarkupCompatibilityProcessSettings(
-                    MarkupCompatibilityProcessMode.ProcessAllParts,
-                    TargetMinimumVersion)
-            };
-            m_wpDocument = WordprocessingDocument.Open(m_stream, true, openSettings);
-            Processed = false;
-        }
-
-        public static DocxTemplate Open(string pathToTemplate, ProcessSettings settings = null)
-        {
-            using var fileStream = new FileStream(pathToTemplate, FileMode.Open, FileAccess.Read);
-            return new DocxTemplate(fileStream, settings);
-        }
-
-        public bool Processed { get; private set; }
-
-        public void Save(string targetPath)
-        {
-            using var fileStream = new FileStream(targetPath, FileMode.Create, FileAccess.Write);
-            Save(fileStream);
-        }
-
-        public void Save(Stream target)
-        {
-            Process().CopyTo(target);
-        }
-
-        public Stream AsStream()
-        {
-            return Process();
-        }
-
-        public void Validate()
-        {
-            var v = new OpenXmlValidator(TargetMinimumVersion);
-            var errs = v.Validate(m_wpDocument);
-            if (errs.Any())
-            {
-                var sb = new System.Text.StringBuilder();
-                foreach (var err in errs)
-                {
-                    sb.AppendLine($"{err.Description} Node: {err.Node} RelatedNode: {err.RelatedNode}");
-                }
-                throw new OpenXmlTemplateException($"Validation failed - {sb}");
-            }
-        }
-
-        public Stream Process()
-        {
-            if (m_wpDocument.MainDocumentPart == null || Processed)
-            {
-                m_stream.Position = 0;
-                return m_stream;
-            }
-            Processed = true;
-            foreach (var header in m_wpDocument.MainDocumentPart.HeaderParts)
-            {
-                ProcessNode(header.Header);
-            }
-            ProcessNode(m_wpDocument.MainDocumentPart.RootElement);
-            foreach (var footer in m_wpDocument.MainDocumentPart.FooterParts)
-            {
-                ProcessNode(footer.Footer);
-            }
-            m_wpDocument.Save();
-            m_stream.Position = 0;
-            return m_stream;
-        }
-
-
-        public void Dispose()
-        {
-            m_stream?.Dispose();
-            m_wpDocument?.Dispose();
-        }
-    }
-}
+using DocumentFormat.OpenXml;
+using DocumentFormat.OpenXml.Packaging;
+using DocumentFormat.OpenXml.Validation;
+using DocxTemplater.Formatter;
+using System;
+using System.IO;
+using System.Linq;
+
+namespace DocxTemplater
+{
+    public sealed class DocxTemplate : TemplateProcessor, IDisposable
+    {
+        private readonly Stream m_stream;
+        private readonly WordprocessingDocument m_wpDocument;
+
+        private static readonly FileFormatVersions TargetMinimumVersion = FileFormatVersions.Office2010;
+
+        public DocxTemplate(Stream docXStream)
+        : this(docXStream, ProcessSettings.Default)
+        {
+        }
+
+        public DocxTemplate(Stream docXStream, ProcessSettings settings)
+            : this(docXStream, settings, new ModelLookup())
+        {
+        }
+
+        private DocxTemplate(Stream docXStream, ProcessSettings settings, ModelLookup modelLookup)
+        : base(settings, modelLookup, new VariableReplacer(modelLookup, settings), new ScriptCompiler(modelLookup, settings))
+        {
+            ArgumentNullException.ThrowIfNull(docXStream);
+            m_stream = new MemoryStream();
+            docXStream.CopyTo(m_stream);
+            m_stream.Position = 0;
+            // Add the MarkupCompatibilityProcessSettings
+            OpenSettings openSettings = new()
+            {
+                MarkupCompatibilityProcessSettings =
+                new MarkupCompatibilityProcessSettings(
+                    MarkupCompatibilityProcessMode.ProcessAllParts,
+                    TargetMinimumVersion)
+            };
+            m_wpDocument = WordprocessingDocument.Open(m_stream, true, openSettings);
+            Processed = false;
+            RegisterFormatter(new SubTemplateFormatter(modelLookup, settings));
+        }
+
+        public static DocxTemplate Open(string pathToTemplate, ProcessSettings settings = null)
+        {
+            using var fileStream = new FileStream(pathToTemplate, FileMode.Open, FileAccess.Read);
+            return new DocxTemplate(fileStream, settings);
+        }
+
+        public bool Processed { get; private set; }
+
+        public void Save(string targetPath)
+        {
+            using var fileStream = new FileStream(targetPath, FileMode.Create, FileAccess.Write);
+            Save(fileStream);
+        }
+
+        public void Save(Stream target)
+        {
+            Process().CopyTo(target);
+        }
+
+        public Stream AsStream()
+        {
+            return Process();
+        }
+
+        public void Validate()
+        {
+            var v = new OpenXmlValidator(TargetMinimumVersion);
+            var errs = v.Validate(m_wpDocument);
+            if (errs.Any())
+            {
+                var sb = new System.Text.StringBuilder();
+                foreach (var err in errs)
+                {
+                    sb.AppendLine($"{err.Description} Node: {err.Node} RelatedNode: {err.RelatedNode}");
+                }
+                throw new OpenXmlTemplateException($"Validation failed - {sb}");
+            }
+        }
+
+        public Stream Process()
+        {
+            if (m_wpDocument.MainDocumentPart == null || Processed)
+            {
+                m_stream.Position = 0;
+                return m_stream;
+            }
+            Processed = true;
+            foreach (var header in m_wpDocument.MainDocumentPart.HeaderParts)
+            {
+                ProcessNode(header.Header);
+            }
+            ProcessNode(m_wpDocument.MainDocumentPart.RootElement);
+            foreach (var footer in m_wpDocument.MainDocumentPart.FooterParts)
+            {
+                ProcessNode(footer.Footer);
+            }
+            m_wpDocument.Save();
+            m_stream.Position = 0;
+            return m_stream;
+        }
+
+
+        public void Dispose()
+        {
+            m_stream?.Dispose();
+            m_wpDocument?.Dispose();
+        }
+    }
+}
diff --git a/DocxTemplater/Formatter/IFormatter.cs b/DocxTemplater/Formatter/IFormatter.cs
index 7811f09..9a8f5a1 100644
--- a/DocxTemplater/Formatter/IFormatter.cs
+++ b/DocxTemplater/Formatter/IFormatter.cs
@@ -1,12 +1,12 @@
-using System;
-using DocumentFormat.OpenXml.Wordprocessing;
-
-namespace DocxTemplater.Formatter
-{
-    public interface IFormatter
-    {
-        public bool CanHandle(Type type, string prefix);
-
-        void ApplyFormat(FormatterContext context, Text target);
-    }
-}
+using System;
+using DocumentFormat.OpenXml.Wordprocessing;
+
+namespace DocxTemplater.Formatter
+{
+    public interface IFormatter
+    {
+        public bool CanHandle(Type type, string prefix);
+
+        void ApplyFormat(FormatterContext context, Text target);
+    }
+}
diff --git a/DocxTemplater/Formatter/IFormatterInitialization.cs b/DocxTemplater/Formatter/IFormatterInitialization.cs
new file mode 100644
index 0000000..7d374d6
--- /dev/null
+++ b/DocxTemplater/Formatter/IFormatterInitialization.cs
@@ -0,0 +1,11 @@
+namespace DocxTemplater.Formatter
+{
+
+    /// <summary>
+    /// Implement this interface on a <see cref="IFormatter"/> If the formatter needs to be initialized with the <see cref="IModelLookup"/> and <see cref="ProcessSettings"/>
+    /// </summary>
+    public interface IFormatterInitialization
+    {
+        void Initialize(IModelLookup modelLookup, IScriptCompiler scriptCompiler, IVariableReplacer variableReplacer, ProcessSettings processSettings);
+    }
+}
diff --git a/DocxTemplater/Formatter/IVariableReplacer.cs b/DocxTemplater/Formatter/IVariableReplacer.cs
new file mode 100644
index 0000000..5743ca2
--- /dev/null
+++ b/DocxTemplater/Formatter/IVariableReplacer.cs
@@ -0,0 +1,13 @@
+using DocumentFormat.OpenXml;
+using System.Collections.Generic;
+
+namespace DocxTemplater.Formatter
+{
+    public interface IVariableReplacer
+    {
+        void RegisterFormatter(IFormatter formatter);
+
+        void ReplaceVariables(IReadOnlyCollection<OpenXmlElement> content);
+        void ReplaceVariables(OpenXmlElement cloned);
+    }
+}
\ No newline at end of file
diff --git a/DocxTemplater/Formatter/VariableReplacer.cs b/DocxTemplater/Formatter/VariableReplacer.cs
index 0c94f71..92713fd 100644
--- a/DocxTemplater/Formatter/VariableReplacer.cs
+++ b/DocxTemplater/Formatter/VariableReplacer.cs
@@ -1,120 +1,120 @@
-using System;
-using DocumentFormat.OpenXml;
-using DocumentFormat.OpenXml.Wordprocessing;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace DocxTemplater.Formatter
-{
-    internal class VariableReplacer
-    {
-        private readonly ModelLookup m_models;
-        private readonly ProcessSettings m_processSettings;
-        private readonly List<IFormatter> m_formatters;
-
-        public VariableReplacer(ModelLookup models, ProcessSettings processSettings)
-        {
-            m_models = models;
-            m_processSettings = processSettings;
-            m_formatters = new List<IFormatter>();
-            m_formatters.Add(new FormatPatternFormatter());
-            m_formatters.Add(new HtmlFormatter());
-            m_formatters.Add(new CaseFormatter());
-        }
-
-
-        public void RegisterFormatter(IFormatter formatter)
-        {
-            m_formatters.Add(formatter);
-        }
-
-        /// <summary>
-        /// the formatter string is the leading formatter prefix, e.g. "FORMAT" followed by the formatter arguments ae image(100,200)
-        /// </summary>
-        public void ApplyFormatter(PatternMatch patternMatch, object value, Text target)
-        {
-            if (value == null)
-            {
-                target.Text = string.Empty;
-                return;
-            }
-            if (!string.IsNullOrWhiteSpace(patternMatch.Formatter))
-            {
-                foreach (var formatter in m_formatters)
-                {
-                    if (formatter.CanHandle(value.GetType(), patternMatch.Formatter))
-                    {
-                        var context = new FormatterContext(patternMatch.Variable, patternMatch.Formatter, patternMatch.Arguments, value, m_processSettings.Culture);
-                        formatter.ApplyFormat(context, target);
-                        return;
-                    }
-                }
-            }
-            if (value is IFormattable formattable)
-            {
-                target.Text = formattable.ToString(null, m_processSettings.Culture);
-                return;
-            }
-            target.Text = value.ToString() ?? string.Empty;
-
-        }
-
-        public void ReplaceVariables(IReadOnlyCollection<OpenXmlElement> content)
-        {
-            foreach (var element in content)
-            {
-                ReplaceVariables(element);
-            }
-        }
-
-        public void ReplaceVariables(OpenXmlElement cloned)
-        {
-            var variables = cloned.GetElementsWithMarker(PatternType.Variable).OfType<Text>().ToList();
-            foreach (var text in variables)
-            {
-                var variableMatch = PatternMatcher.FindSyntaxPatterns(text.Text).FirstOrDefault() ?? throw new OpenXmlTemplateException($"Invalid variable syntax '{text.Text}'");
-                try
-                {
-                    var value = m_models.GetValue(variableMatch.Variable);
-                    ApplyFormatter(variableMatch, value, text);
-                    VariableReplacer.SplitNewLinesInText(text);
-                }
-                catch (Exception e) when (e is OpenXmlTemplateException or FormatException)
-                {
-                    if (m_processSettings.BindingErrorHandling != BindingErrorHandling.ThrowException)
-                    {
-                        text.RemoveWithEmptyParent();
-                    }
-                    else
-                    {
-                        throw new OpenXmlTemplateException($"'{text.InnerText}' could not be replaced: {text.ElementBeforeInDocument<Text>()?.InnerText} >> {text.InnerText} << {text.ElementAfterInDocument<Text>()?.InnerText}", e);
-                    }
-                }
-            }
-        }
-
-        /// <summary>
-        /// Insert Breaks for line breaks in the text
-        /// </summary>
-        private static void SplitNewLinesInText(Text text)
-        {
-            if (text.Parent == null)
-            {
-                return;
-            }
-            text.Text = text.Text.Replace("\r\n", "\n").Replace("\r", "\n");
-            if (text.Text.Contains('\n'))
-            {
-                var parts = text.Text.Split('\n');
-                OpenXmlElement lastElement = text;
-                foreach (var part in parts)
-                {
-                    lastElement = lastElement.InsertAfterSelf(new Text(part));
-                    lastElement = lastElement.InsertAfterSelf(new Break());
-                }
-
-                text.Remove();
-            }
-        }
-    }
-}
+using System;
+using DocumentFormat.OpenXml;
+using DocumentFormat.OpenXml.Wordprocessing;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace DocxTemplater.Formatter
+{
+    internal class VariableReplacer : IVariableReplacer
+    {
+        private readonly IModelLookup m_models;
+        private readonly ProcessSettings m_processSettings;
+        private readonly List<IFormatter> m_formatters;
+
+        public VariableReplacer(IModelLookup models, ProcessSettings processSettings)
+        {
+            m_models = models;
+            m_processSettings = processSettings;
+            m_formatters = new List<IFormatter>();
+            m_formatters.Add(new FormatPatternFormatter());
+            m_formatters.Add(new HtmlFormatter());
+            m_formatters.Add(new CaseFormatter());
+        }
+
+
+        public void RegisterFormatter(IFormatter formatter)
+        {
+            m_formatters.Add(formatter);
+        }
+
+        /// <summary>
+        /// the formatter string is the leading formatter prefix, e.g. "FORMAT" followed by the formatter arguments ae image(100,200)
+        /// </summary>
+        private void ApplyFormatter(PatternMatch patternMatch, object value, Text target)
+        {
+            if (value == null)
+            {
+                target.Text = string.Empty;
+                return;
+            }
+            if (!string.IsNullOrWhiteSpace(patternMatch.Formatter))
+            {
+                foreach (var formatter in m_formatters)
+                {
+                    if (formatter.CanHandle(value.GetType(), patternMatch.Formatter))
+                    {
+                        var context = new FormatterContext(patternMatch.Variable, patternMatch.Formatter, patternMatch.Arguments, value, m_processSettings.Culture);
+                        formatter.ApplyFormat(context, target);
+                        return;
+                    }
+                }
+            }
+            if (value is IFormattable formattable)
+            {
+                target.Text = formattable.ToString(null, m_processSettings.Culture);
+                return;
+            }
+            target.Text = value.ToString() ?? string.Empty;
+
+        }
+
+        public void ReplaceVariables(IReadOnlyCollection<OpenXmlElement> content)
+        {
+            foreach (var element in content)
+            {
+                ReplaceVariables(element);
+            }
+        }
+
+        public void ReplaceVariables(OpenXmlElement cloned)
+        {
+            var variables = cloned.GetElementsWithMarker(PatternType.Variable).OfType<Text>().ToList();
+            foreach (var text in variables)
+            {
+                var variableMatch = PatternMatcher.FindSyntaxPatterns(text.Text).FirstOrDefault() ?? throw new OpenXmlTemplateException($"Invalid variable syntax '{text.Text}'");
+                try
+                {
+                    var value = m_models.GetValue(variableMatch.Variable);
+                    ApplyFormatter(variableMatch, value, text);
+                    VariableReplacer.SplitNewLinesInText(text);
+                }
+                catch (Exception e) when (e is OpenXmlTemplateException or FormatException)
+                {
+                    if (m_processSettings.BindingErrorHandling != BindingErrorHandling.ThrowException)
+                    {
+                        text.RemoveWithEmptyParent();
+                    }
+                    else
+                    {
+                        throw new OpenXmlTemplateException($"'{text.InnerText}' could not be replaced: {text.ElementBeforeInDocument<Text>()?.InnerText} >> {text.InnerText} << {text.ElementAfterInDocument<Text>()?.InnerText}", e);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Insert Breaks for line breaks in the text
+        /// </summary>
+        private static void SplitNewLinesInText(Text text)
+        {
+            if (text.Parent == null)
+            {
+                return;
+            }
+            text.Text = text.Text.Replace("\r\n", "\n").Replace("\r", "\n");
+            if (text.Text.Contains('\n'))
+            {
+                var parts = text.Text.Split('\n');
+                OpenXmlElement lastElement = text;
+                foreach (var part in parts)
+                {
+                    lastElement = lastElement.InsertAfterSelf(new Text(part));
+                    lastElement = lastElement.InsertAfterSelf(new Break());
+                }
+
+                text.Remove();
+            }
+        }
+    }
+}
diff --git a/DocxTemplater/IModelLookup.cs b/DocxTemplater/IModelLookup.cs
new file mode 100644
index 0000000..504028c
--- /dev/null
+++ b/DocxTemplater/IModelLookup.cs
@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+
+namespace DocxTemplater
+{
+    public interface IModelLookup
+    {
+        IReadOnlyDictionary<string, object> Models { get; }
+        void Add(string prefix, object model);
+        IVariableScope OpenScope();
+        object GetValue(string variableName);
+        object GetScopeParentLevel(int parentLevel);
+    }
+}
\ No newline at end of file
diff --git a/DocxTemplater/IScriptCompiler.cs b/DocxTemplater/IScriptCompiler.cs
new file mode 100644
index 0000000..80e4d34
--- /dev/null
+++ b/DocxTemplater/IScriptCompiler.cs
@@ -0,0 +1,10 @@
+using System;
+
+namespace DocxTemplater
+{
+    public interface IScriptCompiler
+    {
+        ProcessSettings ProcessSettings { get; }
+        Func<bool> CompileScript(string scriptAsString);
+    }
+}
\ No newline at end of file
diff --git a/DocxTemplater/InternalsVisibleTo.cs b/DocxTemplater/InternalsVisibleTo.cs
new file mode 100644
index 0000000..c5776a6
--- /dev/null
+++ b/DocxTemplater/InternalsVisibleTo.cs
@@ -0,0 +1,3 @@
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("DocxTemplater.Markdown")]
\ No newline at end of file
diff --git a/DocxTemplater/ModelLookup.cs b/DocxTemplater/ModelLookup.cs
index 4feafe2..848c767 100644
--- a/DocxTemplater/ModelLookup.cs
+++ b/DocxTemplater/ModelLookup.cs
@@ -1,167 +1,167 @@
-using System.Collections;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Linq;
-using System.Reflection;
-
-namespace DocxTemplater
-{
-    internal class ModelLookup
-    {
-        private readonly Dictionary<string, object> m_rootScope;
-        private readonly Stack<Dictionary<string, object>> m_blockScopes;
-
-        public ModelLookup()
-        {
-            m_rootScope = new Dictionary<string, object>();
-            m_blockScopes = new Stack<Dictionary<string, object>>();
-            m_blockScopes.Push(m_rootScope);
-        }
-
-        public IReadOnlyDictionary<string, object> Models => m_rootScope;
-
-        public void Add(string prefix, object model)
-        {
-            m_rootScope.Add(prefix, model);
-        }
-
-        public IVariableScope OpenScope()
-        {
-            return new VariableScope(m_blockScopes);
-        }
-
-        public object GetValue(string variableName)
-        {
-            var leadingDotsCount = variableName.TakeWhile(x => x == '.').Count();
-            variableName = variableName[leadingDotsCount..];
-            int partIndex = 0;
-            var parts = variableName.Split('.');
-            object model = null;
-            string modelRootPath = variableName;
-            if (leadingDotsCount == 0)
-            {
-                model = SearchLongestPathInLookup(parts, out modelRootPath, out partIndex, 0);
-                if (model == null && m_rootScope.Count > 0)
-                {
-                    var firstModelEntry = m_rootScope.First();
-                    // a.b.c.d and b.c.d.e ==> a.b.c.d.e
-                    parts = firstModelEntry.Key.Split('.').Concat(variableName.Split('.')).Distinct().ToArray();
-                    model = SearchLongestPathInLookup(parts, out modelRootPath, out partIndex, 0);
-                }
-
-                if (model == null)
-                {
-                    throw new OpenXmlTemplateException($"Model {variableName} not found");
-                }
-            }
-            else
-            {
-                modelRootPath = "parent scope";
-                model = m_blockScopes.ElementAt(leadingDotsCount - 1).Values.FirstOrDefault();
-                if (parts.Length == 1 && string.IsNullOrWhiteSpace(parts[0]))
-                {
-                    return model;
-                }
-            }
-            if (model == null)
-            {
-                throw new OpenXmlTemplateException($"Model {variableName} not found");
-            }
-
-            for (int i = partIndex; i < parts.Length; i++)
-            {
-                var propertyName = parts[i];
-                if (model is ITemplateModel templateModel)
-                {
-                    if (!templateModel.TryGetPropertyValue(propertyName, out model))
-                    {
-                        throw new OpenXmlTemplateException($"Property {propertyName} not found in {modelRootPath}");
-                    }
-                }
-                else if (model is IDictionary<string, object> dict)
-                {
-                    if (!dict.TryGetValue(parts[i], out model))
-                    {
-                        throw new OpenXmlTemplateException($"Property {propertyName} not found in {modelRootPath}");
-                    }
-                }
-                else
-                {
-                    var property = model.GetType().GetProperty(propertyName, BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.GetProperty | BindingFlags.Instance);
-                    if (property != null)
-                    {
-                        model = property.GetValue(model);
-                        if (model == null)
-                        {
-                            // if a property is null, we can't continue searching
-                            //same behavior as null propagation in C#
-                            // ae A.B.C.D --> A?.B?.C?.D
-                            return null;
-                        }
-                    }
-                    else if (model is ICollection)
-                    {
-                        throw new OpenXmlTemplateException($"Property {propertyName} on collection {modelRootPath} not found - is collection start missing? '#{variableName}'");
-                    }
-                    else
-                    {
-                        throw new OpenXmlTemplateException($"Property {propertyName} not found in {modelRootPath}");
-                    }
-                }
-            }
-            return model;
-        }
-
-        private object SearchLongestPathInLookup(string[] parts, out string modelRootPath, out int partIndex, int startScopeIndex)
-        {
-            modelRootPath = null;
-            partIndex = parts.Length;
-            foreach (Dictionary<string, object> scope in m_blockScopes.Skip(startScopeIndex))
-            {
-                partIndex = parts.Length;
-                // search the longest path in the lookup
-                for (; partIndex > 0; partIndex--)
-                {
-                    modelRootPath = string.Join('.', parts[..partIndex]);
-                    if (scope.TryGetValue(modelRootPath, out var model))
-                    {
-                        return model;
-                    }
-                }
-            }
-            return null;
-        }
-
-
-        internal class VariableScope : IVariableScope
-        {
-            private readonly Dictionary<string, object> m_scope;
-            private readonly Stack<Dictionary<string, object>> m_scopeStack;
-
-            public VariableScope(Stack<Dictionary<string, object>> scopeStack)
-            {
-                m_scopeStack = scopeStack;
-                m_scope = new Dictionary<string, object>();
-                scopeStack.Push(m_scope);
-            }
-
-            public void AddVariable(string name, object value)
-            {
-                // remove leading dots
-                name = name.TrimStart('.');
-                Debug.Assert(m_scopeStack.Count > 1, "Added Block variable in root scope");
-                m_scope.Add(name, value);
-            }
-
-            public void Dispose()
-            {
-                m_scopeStack.Pop();
-            }
-        }
-
-        public object GetScopeParentLevel(int parentLevel)
-        {
-            return m_blockScopes.ElementAt(parentLevel).Values.FirstOrDefault();
-        }
-    }
-}
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Reflection;
+
+namespace DocxTemplater
+{
+    internal class ModelLookup : IModelLookup
+    {
+        private readonly Dictionary<string, object> m_rootScope;
+        private readonly Stack<Dictionary<string, object>> m_blockScopes;
+
+        public ModelLookup()
+        {
+            m_rootScope = new Dictionary<string, object>();
+            m_blockScopes = new Stack<Dictionary<string, object>>();
+            m_blockScopes.Push(m_rootScope);
+        }
+
+        public IReadOnlyDictionary<string, object> Models => m_rootScope;
+
+        public void Add(string prefix, object model)
+        {
+            m_rootScope.Add(prefix, model);
+        }
+
+        public IVariableScope OpenScope()
+        {
+            return new VariableScope(m_blockScopes);
+        }
+
+        public object GetValue(string variableName)
+        {
+            var leadingDotsCount = variableName.TakeWhile(x => x == '.').Count();
+            variableName = variableName[leadingDotsCount..];
+            int partIndex = 0;
+            var parts = variableName.Split('.');
+            object model = null;
+            string modelRootPath = variableName;
+            if (leadingDotsCount == 0)
+            {
+                model = SearchLongestPathInLookup(parts, out modelRootPath, out partIndex, 0);
+                if (model == null && m_rootScope.Count > 0)
+                {
+                    var firstModelEntry = m_rootScope.First();
+                    // a.b.c.d and b.c.d.e ==> a.b.c.d.e
+                    parts = firstModelEntry.Key.Split('.').Concat(variableName.Split('.')).Distinct().ToArray();
+                    model = SearchLongestPathInLookup(parts, out modelRootPath, out partIndex, 0);
+                }
+
+                if (model == null)
+                {
+                    throw new OpenXmlTemplateException($"Model {variableName} not found");
+                }
+            }
+            else
+            {
+                modelRootPath = "parent scope";
+                model = m_blockScopes.ElementAt(leadingDotsCount - 1).Values.FirstOrDefault();
+                if (parts.Length == 1 && string.IsNullOrWhiteSpace(parts[0]))
+                {
+                    return model;
+                }
+            }
+            if (model == null)
+            {
+                throw new OpenXmlTemplateException($"Model {variableName} not found");
+            }
+
+            for (int i = partIndex; i < parts.Length; i++)
+            {
+                var propertyName = parts[i];
+                if (model is ITemplateModel templateModel)
+                {
+                    if (!templateModel.TryGetPropertyValue(propertyName, out model))
+                    {
+                        throw new OpenXmlTemplateException($"Property {propertyName} not found in {modelRootPath}");
+                    }
+                }
+                else if (model is IDictionary<string, object> dict)
+                {
+                    if (!dict.TryGetValue(parts[i], out model))
+                    {
+                        throw new OpenXmlTemplateException($"Property {propertyName} not found in {modelRootPath}");
+                    }
+                }
+                else
+                {
+                    var property = model.GetType().GetProperty(propertyName, BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.GetProperty | BindingFlags.Instance);
+                    if (property != null)
+                    {
+                        model = property.GetValue(model);
+                        if (model == null)
+                        {
+                            // if a property is null, we can't continue searching
+                            //same behavior as null propagation in C#
+                            // ae A.B.C.D --> A?.B?.C?.D
+                            return null;
+                        }
+                    }
+                    else if (model is ICollection)
+                    {
+                        throw new OpenXmlTemplateException($"Property {propertyName} on collection {modelRootPath} not found - is collection start missing? '#{variableName}'");
+                    }
+                    else
+                    {
+                        throw new OpenXmlTemplateException($"Property {propertyName} not found in {modelRootPath}");
+                    }
+                }
+            }
+            return model;
+        }
+
+        private object SearchLongestPathInLookup(string[] parts, out string modelRootPath, out int partIndex, int startScopeIndex)
+        {
+            modelRootPath = null;
+            partIndex = parts.Length;
+            foreach (Dictionary<string, object> scope in m_blockScopes.Skip(startScopeIndex))
+            {
+                partIndex = parts.Length;
+                // search the longest path in the lookup
+                for (; partIndex > 0; partIndex--)
+                {
+                    modelRootPath = string.Join('.', parts[..partIndex]);
+                    if (scope.TryGetValue(modelRootPath, out var model))
+                    {
+                        return model;
+                    }
+                }
+            }
+            return null;
+        }
+
+
+        internal class VariableScope : IVariableScope
+        {
+            private readonly Dictionary<string, object> m_scope;
+            private readonly Stack<Dictionary<string, object>> m_scopeStack;
+
+            public VariableScope(Stack<Dictionary<string, object>> scopeStack)
+            {
+                m_scopeStack = scopeStack;
+                m_scope = new Dictionary<string, object>();
+                scopeStack.Push(m_scope);
+            }
+
+            public void AddVariable(string name, object value)
+            {
+                // remove leading dots
+                name = name.TrimStart('.');
+                Debug.Assert(m_scopeStack.Count > 1, "Added Block variable in root scope");
+                m_scope.Add(name, value);
+            }
+
+            public void Dispose()
+            {
+                m_scopeStack.Pop();
+            }
+        }
+
+        public object GetScopeParentLevel(int parentLevel)
+        {
+            return m_blockScopes.ElementAt(parentLevel).Values.FirstOrDefault();
+        }
+    }
+}
diff --git a/DocxTemplater/PatternType.cs b/DocxTemplater/PatternType.cs
index 664b885..fa9c396 100644
--- a/DocxTemplater/PatternType.cs
+++ b/DocxTemplater/PatternType.cs
@@ -1,15 +1,15 @@
-namespace DocxTemplater
-{
-    internal enum PatternType
-    {
-        None,
-        Condition,
-        ConditionEnd,
-        CollectionStart,
-        DynamicTable,
-        CollectionSeparator,
-        CollectionEnd,
-        Variable,
-        ConditionElse
-    }
-}
+namespace DocxTemplater
+{
+    internal enum PatternType
+    {
+        None,
+        Condition,
+        ConditionEnd,
+        CollectionStart,
+        DynamicTable,
+        CollectionSeparator,
+        CollectionEnd,
+        Variable,
+        ConditionElse
+    }
+}
diff --git a/DocxTemplater/ScriptCompiler.cs b/DocxTemplater/ScriptCompiler.cs
index 2ba246e..2a370fe 100644
--- a/DocxTemplater/ScriptCompiler.cs
+++ b/DocxTemplater/ScriptCompiler.cs
@@ -1,92 +1,92 @@
-using DynamicExpresso;
-using System;
-using System.Dynamic;
-using System.Text.RegularExpressions;
-
-namespace DocxTemplater
-{
-    internal class ScriptCompiler
-    {
-        private readonly ModelLookup m_modelDictionary;
-        private static readonly Regex RegexWordStartingWithDot = new(@"^(\.+)([a-zA-z0-9_]+)", RegexOptions.Compiled);
-
-        public ScriptCompiler(ModelLookup modelDictionary, ProcessSettings processSettings)
-        {
-            this.m_modelDictionary = modelDictionary;
-            ProcessSettings = processSettings;
-        }
-
-        public ProcessSettings ProcessSettings { get; }
-
-        public Func<bool> CompileScript(string scriptAsString)
-        {
-            // replace replace leading dots (implicit scope) with variables
-            var interpreter = new Interpreter();
-            scriptAsString = RegexWordStartingWithDot.Replace(scriptAsString, (m) => OnVariableReplace(m, interpreter));
-            var identifiers = interpreter.DetectIdentifiers(scriptAsString);
-            foreach (var identifier in identifiers.UnknownIdentifiers)
-            {
-                var val = m_modelDictionary.GetValue(identifier);
-                if (val == null || val.GetType().IsPrimitive)
-                {
-                    interpreter.SetVariable(identifier, val);
-                }
-                else
-                {
-                    interpreter.SetVariable(identifier, new ModelVariable(m_modelDictionary, identifier));
-                }
-            }
-            try
-            {
-                return interpreter.ParseAsDelegate<Func<bool>>(scriptAsString);
-            }
-            catch (DynamicExpresso.Exceptions.ParseException e)
-            {
-                throw new OpenXmlTemplateException($"Error parsing script {scriptAsString}", e);
-            }
-        }
-
-        private string OnVariableReplace(Match match, Interpreter interpreter)
-        {
-            var dotCount = match.Groups[1].Length;
-            var scope = m_modelDictionary.GetScopeParentLevel(dotCount - 1);
-            var varName = $"__s{dotCount}_"; // choose a variable name that is unlikely to be used by the user
-            interpreter.SetVariable(varName, scope);
-            return $"{varName}.{match.Groups[2].Value}";
-        }
-
-        private class ModelVariable : DynamicObject
-        {
-            private readonly ModelLookup m_modelDictionary;
-            private readonly string m_rootName;
-
-            public ModelVariable(ModelLookup modelDictionary, string rootName)
-            {
-                m_modelDictionary = modelDictionary;
-                m_rootName = rootName;
-            }
-
-            // If you try to get a value of a property
-            // not defined in the class, this method is called.
-            public override bool TryGetMember(GetMemberBinder binder, out object result)
-            {
-                var name = m_rootName + "." + binder.Name;
-                result = m_modelDictionary.GetValue(name);
-                if (result != null && !result.GetType().IsPrimitive)
-                {
-                    result = new ModelVariable(m_modelDictionary, name);
-                }
-                return true;
-            }
-
-            // If you try to set a value of a property that is
-            // not defined in the class, this method is called.
-            public override bool TrySetMember(SetMemberBinder binder, object value)
-            {
-                return false;
-            }
-
-        }
-
-    }
-}
+using DynamicExpresso;
+using System;
+using System.Dynamic;
+using System.Text.RegularExpressions;
+
+namespace DocxTemplater
+{
+    internal class ScriptCompiler : IScriptCompiler
+    {
+        private readonly IModelLookup m_modelDictionary;
+        private static readonly Regex RegexWordStartingWithDot = new(@"^(\.+)([a-zA-z0-9_]+)", RegexOptions.Compiled);
+
+        public ScriptCompiler(IModelLookup modelDictionary, ProcessSettings processSettings)
+        {
+            this.m_modelDictionary = modelDictionary;
+            ProcessSettings = processSettings;
+        }
+
+        public ProcessSettings ProcessSettings { get; }
+
+        public Func<bool> CompileScript(string scriptAsString)
+        {
+            // replace replace leading dots (implicit scope) with variables
+            var interpreter = new Interpreter();
+            scriptAsString = RegexWordStartingWithDot.Replace(scriptAsString, (m) => OnVariableReplace(m, interpreter));
+            var identifiers = interpreter.DetectIdentifiers(scriptAsString);
+            foreach (var identifier in identifiers.UnknownIdentifiers)
+            {
+                var val = m_modelDictionary.GetValue(identifier);
+                if (val == null || val.GetType().IsPrimitive)
+                {
+                    interpreter.SetVariable(identifier, val);
+                }
+                else
+                {
+                    interpreter.SetVariable(identifier, new ModelVariable(m_modelDictionary, identifier));
+                }
+            }
+            try
+            {
+                return interpreter.ParseAsDelegate<Func<bool>>(scriptAsString);
+            }
+            catch (DynamicExpresso.Exceptions.ParseException e)
+            {
+                throw new OpenXmlTemplateException($"Error parsing script {scriptAsString}", e);
+            }
+        }
+
+        private string OnVariableReplace(Match match, Interpreter interpreter)
+        {
+            var dotCount = match.Groups[1].Length;
+            var scope = m_modelDictionary.GetScopeParentLevel(dotCount - 1);
+            var varName = $"__s{dotCount}_"; // choose a variable name that is unlikely to be used by the user
+            interpreter.SetVariable(varName, scope);
+            return $"{varName}.{match.Groups[2].Value}";
+        }
+
+        private class ModelVariable : DynamicObject
+        {
+            private readonly IModelLookup m_modelDictionary;
+            private readonly string m_rootName;
+
+            public ModelVariable(IModelLookup modelDictionary, string rootName)
+            {
+                m_modelDictionary = modelDictionary;
+                m_rootName = rootName;
+            }
+
+            // If you try to get a value of a property
+            // not defined in the class, this method is called.
+            public override bool TryGetMember(GetMemberBinder binder, out object result)
+            {
+                var name = m_rootName + "." + binder.Name;
+                result = m_modelDictionary.GetValue(name);
+                if (result != null && !result.GetType().IsPrimitive)
+                {
+                    result = new ModelVariable(m_modelDictionary, name);
+                }
+                return true;
+            }
+
+            // If you try to set a value of a property that is
+            // not defined in the class, this method is called.
+            public override bool TrySetMember(SetMemberBinder binder, object value)
+            {
+                return false;
+            }
+
+        }
+
+    }
+}
diff --git a/DocxTemplater/TemplateProcessor.cs b/DocxTemplater/TemplateProcessor.cs
index 0674f56..733ffdc 100644
--- a/DocxTemplater/TemplateProcessor.cs
+++ b/DocxTemplater/TemplateProcessor.cs
@@ -1,281 +1,284 @@
-#if DEBUG
-using System;
-#endif
-using DocumentFormat.OpenXml;
-using DocumentFormat.OpenXml.Drawing.Wordprocessing;
-using DocumentFormat.OpenXml.Wordprocessing;
-using DocxTemplater.Blocks;
-using DocxTemplater.Formatter;
-using System.Collections.Generic;
-using System.Linq;
-
-namespace DocxTemplater
-{
-    public abstract class TemplateProcessor
-    {
-        private readonly ModelLookup m_models;
-        private readonly VariableReplacer m_variableReplacer;
-        private readonly ScriptCompiler m_scriptCompiler;
-
-        public ProcessSettings Settings { get; }
-
-        private protected TemplateProcessor(
-            ProcessSettings settings,
-            ModelLookup modelLookup,
-            VariableReplacer variableReplacer,
-            ScriptCompiler scriptCompiler)
-        {
-            Settings = settings;
-            m_models = modelLookup;
-            m_variableReplacer = variableReplacer;
-            m_scriptCompiler = scriptCompiler;
-            m_variableReplacer.RegisterFormatter(new SubTemplateFormatter(modelLookup, settings));
-        }
-
-        public IReadOnlyDictionary<string, object> Models => m_models.Models;
-
-
-        protected void ProcessNode(OpenXmlCompositeElement rootElement)
-        {
-#if DEBUG
-            Console.WriteLine("----------- Original --------");
-            Console.WriteLine(rootElement.ToPrettyPrintXml());
-#endif
-            PreProcess(rootElement);
-
-            DocxTemplate.IsolateAndMergeTextTemplateMarkers(rootElement);
-
-#if DEBUG
-            Console.WriteLine("----------- Isolate Texts --------");
-            Console.WriteLine(rootElement.ToPrettyPrintXml());
-#endif
-
-            var loops = ExpandLoops(rootElement);
-#if DEBUG
-            Console.WriteLine("----------- After Loops --------");
-            Console.WriteLine(rootElement.ToPrettyPrintXml());
-#endif
-            m_variableReplacer.ReplaceVariables(rootElement);
-            foreach (var loop in loops)
-            {
-                loop.Expand(m_models, rootElement);
-            }
-
-            Cleanup(rootElement, removeEmptyElements: true);
-#if DEBUG
-            Console.WriteLine("----------- Completed --------");
-            Console.WriteLine(rootElement.ToPrettyPrintXml());
-#endif
-        }
-
-        private static void PreProcess(OpenXmlCompositeElement content)
-        {
-            content.Descendants<ProofError>().ToList().ForEach(x => x.Remove());
-        }
-
-        private static void IsolateAndMergeTextTemplateMarkers(OpenXmlCompositeElement content)
-        {
-            var charMap = new CharacterMap(content);
-            foreach (var m in PatternMatcher.FindSyntaxPatterns(charMap.Text))
-            {
-                var firstChar = charMap[m.Index];
-                var lastChar = charMap[m.Index + m.Length - 1];
-                var firstText = (Text)firstChar.Element;
-                var lastText = (Text)lastChar.Element;
-                var mergedText = firstText.MergeText(firstChar.Index, lastText, m.Length);
-                mergedText.Mark(m.Type);
-                // TODO: Ist this possible without recreate charMap?
-                charMap.MarkAsDirty();
-            }
-        }
-
-        private static void Cleanup(OpenXmlCompositeElement element, bool removeEmptyElements)
-        {
-            InsertionPoint.RemoveAll(element);
-            foreach (var markedText in element.Descendants<Text>().Where(x => x.IsMarked()).ToList())
-            {
-                var value = markedText.GetMarker();
-                if (removeEmptyElements && value is not PatternType.Variable)
-                {
-                    var parent = markedText.Parent;
-                    markedText.RemoveWithEmptyParent();
-                }
-                else
-                {
-                    markedText.RemoveAttribute("mrk", null);
-                }
-            }
-
-            // make all Bookmark ids unique
-            uint id = 0;
-            foreach (var bookmarkStart in element.Descendants<BookmarkStart>())
-            {
-                bookmarkStart.Id = $"{id++}";
-                bookmarkStart.NextSibling<BookmarkEnd>().Id = bookmarkStart.Id;
-            }
-
-            // make dock properties ids unique
-            id = 1;
-            var dockProperties = element.Descendants<DocProperties>().ToList();
-            var existingIds = new HashSet<uint>(dockProperties.Select(x => x.Id.Value).ToList());
-            foreach (var docPropertiesWithSameId in dockProperties.GroupBy(x => x.Id).Where(x => x.Count() > 1))
-            {
-                foreach (var docProperties in docPropertiesWithSameId.Skip(1))
-                {
-                    while (existingIds.Contains(id))
-                    {
-                        id++;
-                    }
-
-                    docProperties.Id = id;
-                    existingIds.Add(id);
-                }
-            }
-
-            //ensure all table cells have a paragraph
-            // 'If a table cell does not include at least one block-level element, then this document shall be considered corrupt
-            // https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.wordprocessing.tablecell?view=openxml-3.0.1#remarks
-            foreach (var tableCell in element.Descendants<TableCell>())
-            {
-                if (!tableCell.ChildElements.OfType<Paragraph>().Any())
-                {
-                    tableCell.Append(new Paragraph());
-                }
-            }
-        }
-
-        private IReadOnlyCollection<ContentBlock> ExpandLoops(OpenXmlCompositeElement element)
-        {
-            Stack<ContentBlock> blockStack = new();
-            blockStack.Push(new ContentBlock()); // dummy block for root
-            foreach (var text in element.Descendants<Text>().ToList().Where(x => x.IsMarked()))
-            {
-                var value = text.GetMarker();
-                var match = PatternMatcher.FindSyntaxPatterns(text.Text).Single();
-
-
-                if (value is PatternType.Condition or PatternType.CollectionStart)
-                {
-                    StartBlock(blockStack, match, value, text);
-                    StartBlock(blockStack, match, PatternType.None, text);
-                }
-                else if (value is PatternType.ConditionElse or PatternType.CollectionSeparator)
-                {
-                    CloseBlock(blockStack, match, text);
-                    StartBlock(blockStack, match, value, text);
-                }
-                if (value is PatternType.ConditionEnd or PatternType.CollectionEnd)
-                {
-                    CloseBlock(blockStack, match, text);
-                    CloseBlock(blockStack, match, text);
-                }
-            }
-            if (blockStack.Count != 1)
-            {
-                var notClosedBlocks = blockStack.Reverse().Skip(1).Select(x => x.StartMatch.Match.Value).Skip(1).ToList();
-                throw new OpenXmlTemplateException($"Not all blocks are closed: {string.Join(", ", notClosedBlocks)}");
-            }
-
-            var rootBlock = blockStack.Peek();
-            var rootChilds = rootBlock.ChildBlocks;
-
-            foreach (var block in rootChilds)
-            {
-                block.AddInsertionPointsRecursively();
-            }
-#if DEBUG
-            Console.WriteLine("--------- Assigned Insertion Points --------");
-            Console.WriteLine(element.ToPrettyPrintXml());
-#endif
-
-            foreach (var block in rootChilds)
-            {
-                block.ExtractContentRecursively();
-            }
-
-#if DEBUG
-            foreach (var block in rootChilds)
-            {
-                block.Validate();
-            }
-#endif
-
-            return rootChilds;
-        }
-
-        private void StartBlock(Stack<ContentBlock> blockStack, PatternMatch match, PatternType value, Text text)
-        {
-            var newBlock = ContentBlock.Crate(m_variableReplacer, m_scriptCompiler, value, text, match);
-            blockStack.Peek().AddChildBlock(newBlock);
-            blockStack.Push(newBlock);
-        }
-
-        private static void CloseBlock(Stack<ContentBlock> blockStack, PatternMatch match, Text text)
-        {
-            if (blockStack.Count == 1)
-            {
-                throw new OpenXmlTemplateException($"Block was not open {text.InnerText}");
-            }
-            var closedBlock = blockStack.Pop();
-            closedBlock.CloseBlock(text, match);
-        }
-
-        internal static IReadOnlyCollection<OpenXmlElement> ExtractBlockContent(OpenXmlElement startText,
-            OpenXmlElement endText, out OpenXmlElement leadingPart)
-        {
-            var commonParent = startText.FindCommonParent(endText) ??
-                               throw new OpenXmlTemplateException("Start and end text are not in the same tree");
-            var result = new List<OpenXmlElement>();
-            if (commonParent is TableRow)
-            {
-                var previousRow = commonParent.PreviousSibling();
-                if (previousRow == null)
-                {
-                    commonParent.InsertBeforeSelf(new TableRow());
-                }
-
-                leadingPart = commonParent.PreviousSibling();
-                commonParent.Remove();
-                result.Add(commonParent);
-            }
-            else
-            {
-                // find childs of common parent that contains start and end text
-                var startChildOfCommonParent = commonParent.ChildElements.Single(c =>
-                    c == startText || c.Descendants<Text>().Any(d => d == startText));
-                var endChildOfCommonParent =
-                    commonParent.ChildElements.Single(c =>
-                        c == endText || c.Descendants<Text>().Any(d => d == endText));
-
-                var startSplit = startChildOfCommonParent.SplitAfterElement(startText);
-                leadingPart = startSplit.First();
-                if (startChildOfCommonParent == endChildOfCommonParent)
-                {
-                    result.AddRange(commonParent.ChildsBetween(startSplit.First(), endChildOfCommonParent).ToList());
-                }
-                else
-                {
-                    var endSplit = endChildOfCommonParent.SplitBeforeElement(endText);
-                    result.AddRange(commonParent.ChildsBetween(leadingPart, endSplit.Last()).ToList());
-                }
-
-                foreach (var element in result)
-                {
-                    element.Remove();
-                }
-            }
-
-            return result;
-        }
-
-        public void BindModel(string prefix, object model)
-        {
-            m_models.Add(prefix, model);
-        }
-
-        public void RegisterFormatter(IFormatter formatter)
-        {
-            m_variableReplacer.RegisterFormatter(formatter);
-        }
-    }
+#if DEBUG
+using System;
+#endif
+using DocumentFormat.OpenXml;
+using DocumentFormat.OpenXml.Drawing.Wordprocessing;
+using DocumentFormat.OpenXml.Wordprocessing;
+using DocxTemplater.Blocks;
+using DocxTemplater.Formatter;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace DocxTemplater
+{
+    public abstract class TemplateProcessor
+    {
+        private readonly IModelLookup m_models;
+        private readonly IVariableReplacer m_variableReplacer;
+        private readonly IScriptCompiler m_scriptCompiler;
+
+        public ProcessSettings Settings { get; }
+
+        private protected TemplateProcessor(
+            ProcessSettings settings,
+            IModelLookup modelLookup,
+            IVariableReplacer variableReplacer,
+            IScriptCompiler scriptCompiler)
+        {
+            Settings = settings;
+            m_models = modelLookup;
+            m_variableReplacer = variableReplacer;
+            m_scriptCompiler = scriptCompiler;
+        }
+
+        public IReadOnlyDictionary<string, object> Models => m_models.Models;
+
+
+        protected void ProcessNode(OpenXmlCompositeElement rootElement)
+        {
+#if DEBUG
+            Console.WriteLine("----------- Original --------");
+            Console.WriteLine(rootElement.ToPrettyPrintXml());
+#endif
+            PreProcess(rootElement);
+
+            DocxTemplate.IsolateAndMergeTextTemplateMarkers(rootElement);
+
+#if DEBUG
+            Console.WriteLine("----------- Isolate Texts --------");
+            Console.WriteLine(rootElement.ToPrettyPrintXml());
+#endif
+
+            var loops = ExpandLoops(rootElement);
+#if DEBUG
+            Console.WriteLine("----------- After Loops --------");
+            Console.WriteLine(rootElement.ToPrettyPrintXml());
+#endif
+            m_variableReplacer.ReplaceVariables(rootElement);
+            foreach (var loop in loops)
+            {
+                loop.Expand(m_models, rootElement);
+            }
+
+            Cleanup(rootElement, removeEmptyElements: true);
+#if DEBUG
+            Console.WriteLine("----------- Completed --------");
+            Console.WriteLine(rootElement.ToPrettyPrintXml());
+#endif
+        }
+
+        private static void PreProcess(OpenXmlCompositeElement content)
+        {
+            content.Descendants<ProofError>().ToList().ForEach(x => x.Remove());
+        }
+
+        private static void IsolateAndMergeTextTemplateMarkers(OpenXmlCompositeElement content)
+        {
+            var charMap = new CharacterMap(content);
+            foreach (var m in PatternMatcher.FindSyntaxPatterns(charMap.Text))
+            {
+                var firstChar = charMap[m.Index];
+                var lastChar = charMap[m.Index + m.Length - 1];
+                var firstText = (Text)firstChar.Element;
+                var lastText = (Text)lastChar.Element;
+                var mergedText = firstText.MergeText(firstChar.Index, lastText, m.Length);
+                mergedText.Mark(m.Type);
+                // TODO: Ist this possible without recreate charMap?
+                charMap.MarkAsDirty();
+            }
+        }
+
+        private static void Cleanup(OpenXmlCompositeElement element, bool removeEmptyElements)
+        {
+            InsertionPoint.RemoveAll(element);
+            foreach (var markedText in element.Descendants<Text>().Where(x => x.IsMarked()).ToList())
+            {
+                var value = markedText.GetMarker();
+                if (removeEmptyElements && value is not PatternType.Variable)
+                {
+                    var parent = markedText.Parent;
+                    markedText.RemoveWithEmptyParent();
+                }
+                else
+                {
+                    markedText.RemoveAttribute("mrk", null);
+                }
+            }
+
+            // make all Bookmark ids unique
+            uint id = 0;
+            foreach (var bookmarkStart in element.Descendants<BookmarkStart>())
+            {
+                bookmarkStart.Id = $"{id++}";
+                bookmarkStart.NextSibling<BookmarkEnd>().Id = bookmarkStart.Id;
+            }
+
+            // make dock properties ids unique
+            id = 1;
+            var dockProperties = element.Descendants<DocProperties>().ToList();
+            var existingIds = new HashSet<uint>(dockProperties.Select(x => x.Id.Value).ToList());
+            foreach (var docPropertiesWithSameId in dockProperties.GroupBy(x => x.Id).Where(x => x.Count() > 1))
+            {
+                foreach (var docProperties in docPropertiesWithSameId.Skip(1))
+                {
+                    while (existingIds.Contains(id))
+                    {
+                        id++;
+                    }
+
+                    docProperties.Id = id;
+                    existingIds.Add(id);
+                }
+            }
+
+            //ensure all table cells have a paragraph
+            // 'If a table cell does not include at least one block-level element, then this document shall be considered corrupt
+            // https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.wordprocessing.tablecell?view=openxml-3.0.1#remarks
+            foreach (var tableCell in element.Descendants<TableCell>())
+            {
+                if (!tableCell.ChildElements.OfType<Paragraph>().Any())
+                {
+                    tableCell.Append(new Paragraph());
+                }
+            }
+        }
+
+        private IReadOnlyCollection<ContentBlock> ExpandLoops(OpenXmlCompositeElement element)
+        {
+            Stack<ContentBlock> blockStack = new();
+            blockStack.Push(new ContentBlock()); // dummy block for root
+            foreach (var text in element.Descendants<Text>().ToList().Where(x => x.IsMarked()))
+            {
+                var value = text.GetMarker();
+                var match = PatternMatcher.FindSyntaxPatterns(text.Text).Single();
+
+
+                if (value is PatternType.Condition or PatternType.CollectionStart)
+                {
+                    StartBlock(blockStack, match, value, text);
+                    StartBlock(blockStack, match, PatternType.None, text);
+                }
+                else if (value is PatternType.ConditionElse or PatternType.CollectionSeparator)
+                {
+                    CloseBlock(blockStack, match, text);
+                    StartBlock(blockStack, match, value, text);
+                }
+                if (value is PatternType.ConditionEnd or PatternType.CollectionEnd)
+                {
+                    CloseBlock(blockStack, match, text);
+                    CloseBlock(blockStack, match, text);
+                }
+            }
+            if (blockStack.Count != 1)
+            {
+                var notClosedBlocks = blockStack.Reverse().Skip(1).Select(x => x.StartMatch.Match.Value).Skip(1).ToList();
+                throw new OpenXmlTemplateException($"Not all blocks are closed: {string.Join(", ", notClosedBlocks)}");
+            }
+
+            var rootBlock = blockStack.Peek();
+            var rootChilds = rootBlock.ChildBlocks;
+
+            foreach (var block in rootChilds)
+            {
+                block.AddInsertionPointsRecursively();
+            }
+#if DEBUG
+            Console.WriteLine("--------- Assigned Insertion Points --------");
+            Console.WriteLine(element.ToPrettyPrintXml());
+#endif
+
+            foreach (var block in rootChilds)
+            {
+                block.ExtractContentRecursively();
+            }
+
+#if DEBUG
+            foreach (var block in rootChilds)
+            {
+                block.Validate();
+            }
+#endif
+
+            return rootChilds;
+        }
+
+        private void StartBlock(Stack<ContentBlock> blockStack, PatternMatch match, PatternType value, Text text)
+        {
+            var newBlock = ContentBlock.Crate(m_variableReplacer, m_scriptCompiler, value, text, match);
+            blockStack.Peek().AddChildBlock(newBlock);
+            blockStack.Push(newBlock);
+        }
+
+        private static void CloseBlock(Stack<ContentBlock> blockStack, PatternMatch match, Text text)
+        {
+            if (blockStack.Count == 1)
+            {
+                throw new OpenXmlTemplateException($"Block was not open {text.InnerText}");
+            }
+            var closedBlock = blockStack.Pop();
+            closedBlock.CloseBlock(text, match);
+        }
+
+        internal static IReadOnlyCollection<OpenXmlElement> ExtractBlockContent(OpenXmlElement startText,
+            OpenXmlElement endText, out OpenXmlElement leadingPart)
+        {
+            var commonParent = startText.FindCommonParent(endText) ??
+                               throw new OpenXmlTemplateException("Start and end text are not in the same tree");
+            var result = new List<OpenXmlElement>();
+            if (commonParent is TableRow)
+            {
+                var previousRow = commonParent.PreviousSibling();
+                if (previousRow == null)
+                {
+                    commonParent.InsertBeforeSelf(new TableRow());
+                }
+
+                leadingPart = commonParent.PreviousSibling();
+                commonParent.Remove();
+                result.Add(commonParent);
+            }
+            else
+            {
+                // find childs of common parent that contains start and end text
+                var startChildOfCommonParent = commonParent.ChildElements.Single(c =>
+                    c == startText || c.Descendants<Text>().Any(d => d == startText));
+                var endChildOfCommonParent =
+                    commonParent.ChildElements.Single(c =>
+                        c == endText || c.Descendants<Text>().Any(d => d == endText));
+
+                var startSplit = startChildOfCommonParent.SplitAfterElement(startText);
+                leadingPart = startSplit.First();
+                if (startChildOfCommonParent == endChildOfCommonParent)
+                {
+                    result.AddRange(commonParent.ChildsBetween(startSplit.First(), endChildOfCommonParent).ToList());
+                }
+                else
+                {
+                    var endSplit = endChildOfCommonParent.SplitBeforeElement(endText);
+                    result.AddRange(commonParent.ChildsBetween(leadingPart, endSplit.Last()).ToList());
+                }
+
+                foreach (var element in result)
+                {
+                    element.Remove();
+                }
+            }
+
+            return result;
+        }
+
+        public void BindModel(string prefix, object model)
+        {
+            m_models.Add(prefix, model);
+        }
+
+        public void RegisterFormatter(IFormatter formatter)
+        {
+            if (formatter is IFormatterInitialization formatterInitialization)
+            {
+                formatterInitialization.Initialize(m_models, m_scriptCompiler, m_variableReplacer, Settings);
+            }
+            m_variableReplacer.RegisterFormatter(formatter);
+        }
+    }
 }
\ No newline at end of file
diff --git a/DocxTemplater/VariableScope.cs b/DocxTemplater/VariableScope.cs
index f7cbe70..8e175e5 100644
--- a/DocxTemplater/VariableScope.cs
+++ b/DocxTemplater/VariableScope.cs
@@ -1,9 +1,9 @@
-using System;
-
-namespace DocxTemplater
-{
-    internal interface IVariableScope : IDisposable
-    {
-        void AddVariable(string name, object value);
-    }
-}
+using System;
+
+namespace DocxTemplater
+{
+    public interface IVariableScope : IDisposable
+    {
+        void AddVariable(string name, object value);
+    }
+}
diff --git a/DocxTemplater/XmlNodeTemplate.cs b/DocxTemplater/XmlNodeTemplate.cs
index 12b71d1..4db8a4e 100644
--- a/DocxTemplater/XmlNodeTemplate.cs
+++ b/DocxTemplater/XmlNodeTemplate.cs
@@ -1,21 +1,21 @@
-using DocumentFormat.OpenXml;
-using DocxTemplater.Formatter;
-
-namespace DocxTemplater
-{
-    internal class XmlNodeTemplate : TemplateProcessor
-    {
-        private readonly OpenXmlCompositeElement m_openXmlElement;
-
-        internal XmlNodeTemplate(OpenXmlCompositeElement openXmlElement, ProcessSettings settings, ModelLookup modelLookup, VariableReplacer variableReplacer, ScriptCompiler scriptCompiler)
-            : base(settings, modelLookup, variableReplacer, scriptCompiler)
-        {
-            m_openXmlElement = openXmlElement;
-        }
-
-        public void Process()
-        {
-            ProcessNode(m_openXmlElement);
-        }
-    }
-}
+using DocumentFormat.OpenXml;
+using DocxTemplater.Formatter;
+
+namespace DocxTemplater
+{
+    internal class XmlNodeTemplate : TemplateProcessor
+    {
+        private readonly OpenXmlCompositeElement m_openXmlElement;
+
+        internal XmlNodeTemplate(OpenXmlCompositeElement openXmlElement, ProcessSettings settings, IModelLookup modelLookup, IVariableReplacer variableReplacer, IScriptCompiler scriptCompiler)
+            : base(settings, modelLookup, variableReplacer, scriptCompiler)
+        {
+            m_openXmlElement = openXmlElement;
+        }
+
+        public void Process()
+        {
+            ProcessNode(m_openXmlElement);
+        }
+    }
+}

From d055a81b5b7484fae9d9e844a0554b18e22833e4 Mon Sep 17 00:00:00 2001
From: Manuel Amstutz <manuel.amstutz@orphis.ch>
Date: Wed, 12 Jun 2024 08:36:09 +0200
Subject: [PATCH 4/4] Support variable replacement in markdown templates

---
 DocxTemplater.Markdown/MarkdownFormatter.cs   | 66 +++++++++++++++++--
 .../MarkdownToOpenXmlRenderer.cs              | 13 ++--
 DocxTemplater.Test/MarkdownRendererTest.cs    |  8 +--
 3 files changed, 71 insertions(+), 16 deletions(-)

diff --git a/DocxTemplater.Markdown/MarkdownFormatter.cs b/DocxTemplater.Markdown/MarkdownFormatter.cs
index 82dacf2..c867136 100644
--- a/DocxTemplater.Markdown/MarkdownFormatter.cs
+++ b/DocxTemplater.Markdown/MarkdownFormatter.cs
@@ -1,16 +1,21 @@
 using DocumentFormat.OpenXml;
+using DocumentFormat.OpenXml.Packaging;
 using DocumentFormat.OpenXml.Wordprocessing;
 using DocxTemplater.Formatter;
+using Markdig;
 using Markdig.Parsers;
 using System;
-using DocumentFormat.OpenXml.Packaging;
-using Markdig;
 
 namespace DocxTemplater.Markdown
 {
-    public class MarkdownFormatter : IFormatter
+    public class MarkdownFormatter : IFormatter, IFormatterInitialization
     {
         private readonly MarkDownFormatterConfiguration m_configuration;
+        private IModelLookup m_modelLookup;
+        private ProcessSettings m_processSettings;
+        private IVariableReplacer m_variableReplacer;
+        private IScriptCompiler m_scriptCompiler;
+        private int m_nestingDepth;
 
         public MarkdownFormatter(MarkDownFormatterConfiguration configuration = null)
         {
@@ -29,24 +34,75 @@ public void ApplyFormat(FormatterContext context, Text target)
             {
                 return;
             }
+            if (m_nestingDepth > 3)
+            {
+                throw new OpenXmlTemplateException("Markdown nesting depth exceeded");
+            }
+            m_nestingDepth++;
+
 
             var root = target.GetRoot();
             if (root is OpenXmlPartRootElement openXmlPartRootElement && openXmlPartRootElement.OpenXmlPart != null)
             {
-
                 if (openXmlPartRootElement.OpenXmlPart is MainDocumentPart mainDocumentPart)
                 {
                     var pipeline = new MarkdownPipelineBuilder().UsePipeTables().Build();
                     var markdownDocument = MarkdownParser.Parse(mdText, pipeline);
                     var renderer = new MarkdownToOpenXmlRenderer(target, mainDocumentPart, m_configuration);
+                    var firstParagraph = renderer.CurrentParagraph;
                     renderer.Render(markdownDocument);
+                    var lastParagraph = renderer.CurrentParagraph;
+                    try
+                    {
+                        target.RemoveWithEmptyParent();
+                        DoVariableReplacementInParagraphs(firstParagraph, lastParagraph);
+                    }
+                    catch (Exception e)
+                    {
+                        throw new OpenXmlTemplateException("Variable Replacement in markdown failed", e);
+                    }
                 }
                 else
                 {
-                    throw new InvalidOperationException("Markdown currently only supported in MainDocument");
+                    throw new OpenXmlTemplateException("Markdown currently only supported in MainDocument");
                 }
             }
+            m_nestingDepth--;
             target.RemoveWithEmptyParent();
         }
+
+        private void DoVariableReplacementInParagraphs(Paragraph firstParagraph, Paragraph lastParagraph)
+        {
+            var currentParagraph = firstParagraph;
+            do
+            {
+                if (currentParagraph.InnerText.Contains('{'))
+                {
+                    var processor = new XmlNodeTemplate(currentParagraph, m_processSettings, m_modelLookup, m_variableReplacer, m_scriptCompiler);
+                    processor.Process();
+                }
+                currentParagraph = currentParagraph.NextSibling<Paragraph>();
+                if (currentParagraph == null)
+                {
+                    break;
+                }
+            }
+            while (currentParagraph != lastParagraph);
+        }
+
+        public void Initialize(IModelLookup modelLookup, ProcessSettings processSettings)
+        {
+            m_modelLookup = modelLookup;
+            m_processSettings = processSettings;
+        }
+
+        public void Initialize(IModelLookup modelLookup, IScriptCompiler scriptCompiler, IVariableReplacer variableReplacer,
+            ProcessSettings processSettings)
+        {
+            m_modelLookup = modelLookup;
+            m_processSettings = processSettings;
+            m_variableReplacer = variableReplacer;
+            m_scriptCompiler = scriptCompiler;
+        }
     }
 }
diff --git a/DocxTemplater.Markdown/MarkdownToOpenXmlRenderer.cs b/DocxTemplater.Markdown/MarkdownToOpenXmlRenderer.cs
index 846de3a..38208b4 100644
--- a/DocxTemplater.Markdown/MarkdownToOpenXmlRenderer.cs
+++ b/DocxTemplater.Markdown/MarkdownToOpenXmlRenderer.cs
@@ -42,7 +42,6 @@ public MarkdownToOpenXmlRenderer(
         public bool ExplicitParagraph { get; set; }
 
         public Paragraph CurrentParagraph => m_parentElement as Paragraph;
-        
         public MarkdownToOpenXmlRenderer Write(ref StringSlice slice)
         {
             Write(slice.AsSpan());
@@ -53,7 +52,12 @@ public void Write(ReadOnlySpan<char> content)
         {
             if (!content.IsEmpty)
             {
-                var newRun = new Run(new Text(content.ToString()){ Space = SpaceProcessingModeValues.Preserve });
+                var text = new Text(content.ToString());
+                if (string.IsNullOrWhiteSpace(text.Text))
+                {
+                    text.Space = SpaceProcessingModeValues.Preserve;
+                }
+                var newRun = new Run(text);
                 var format = m_formatStack.Peek();
                 if (format.Bold || format.Italic || format.Style != null)
                 {
@@ -104,11 +108,6 @@ public IDisposable PushFormat(bool? bold, bool? italic)
             return new FormatScope(m_formatStack, bold.Value, italic.Value, currentStyle.Style);
         }
 
-        public IDisposable PushStyle(string style)
-        {
-            return new FormatScope(m_formatStack, m_formatStack.Peek().Bold, m_formatStack.Peek().Italic, style);
-        }
-
         public void NewLine()
         {
             m_parentElement.Append(new Run(new Break()));
diff --git a/DocxTemplater.Test/MarkdownRendererTest.cs b/DocxTemplater.Test/MarkdownRendererTest.cs
index ff4ca34..dd445f7 100644
--- a/DocxTemplater.Test/MarkdownRendererTest.cs
+++ b/DocxTemplater.Test/MarkdownRendererTest.cs
@@ -24,9 +24,9 @@ public void PlainText()
 
 
         [Test]
-        public void MarkdownWithPlaceholder()
+        public void MarkdownWithPlaceholderReplacement()
         {
-            var markdown = "_Hello_  **{{ds:Name}}**";
+            var markdown = "_Hello_ **{{ds.Name}:ToUpper}**";
             using var memStream = new MemoryStream();
             using var wpDocument = WordprocessingDocument.Create(memStream, WordprocessingDocumentType.Document);
             MainDocumentPart mainPart = wpDocument.AddMainDocumentPart();
@@ -36,7 +36,7 @@ public void MarkdownWithPlaceholder()
             memStream.Position = 0;
 
             var docTemplate = new DocxTemplate(memStream);
-            docTemplate.RegisterFormatter(new DocxTemplater.Markdown.MarkdownFormatter());
+            docTemplate.RegisterFormatter(new MarkdownFormatter());
             docTemplate.BindModel("ds", new
             {
                 Name = "John",
@@ -52,7 +52,7 @@ public void MarkdownWithPlaceholder()
             var body = document.MainDocumentPart.Document.Body;
 
             // {{ds.markdown}:md} --> "_Hello_ **{{ds:Name}}**" --> "Hello John"
-            Assert.That(body.InnerText, Is.EqualTo("Hello John"));
+            Assert.That(body.InnerText, Is.EqualTo("Hello JOHN"));
         }
 
         [TestCase("**Hello**")]