Bump to 0.15.2

Make AutoIdentifierExtension thread safe

.editorconfig

@@ -6,7 +6,6 @@ root = true
 # All Files
 [*]
 charset = utf-8
-end_of_line = crlf
 indent_style = space
 indent_size = 4
 insert_final_newline = false

changelog.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.15.2 (21 Aug 2018)
+- Fix footnotes parsing when they are defined after a container that has been closed in the meantime (#223)
+
+## 0.15.1 (10 July 2018)
+- Add support for `netstandard2.0`
+- Make AutoIdentifierExtension thread safe
+
+## 0.15.0 (4 Apr 2018)
+- Add `ConfigureNewLine` extension method to `MarkdownPipelineBuilder` ([(PR #214)](https://github.com/lunet-io/markdig/pull/214))
+- Add alternative `Use` extension method to `MarkdownPipelineBuilder` that receives an object instance ([(PR #213)](https://github.com/lunet-io/markdig/pull/213))
+- Added class attribute to media link extension ([(PR #203)](https://github.com/lunet-io/markdig/pull/203))
+- Optional link rewriter func for HtmlRenderer #143 ([(PR #201)](https://github.com/lunet-io/markdig/pull/201))
+- Upgrade NUnit3TestAdapter from 3.2 to 3.9 to address Resharper test runner problems ([(PR #199)](https://github.com/lunet-io/markdig/pull/199))
+- HTML renderer supports converting relative URLs on links and images to absolute #143 ([(PR #197)](https://github.com/lunet-io/markdig/pull/197))
+
+## 0.14.9 (15 Jan 2018)
+- AutoLinkParser should to remove mailto: in outputted text ([(PR #195)](https://github.com/lunet-io/markdig/pull/195))
+- Add support for `music.yandex.ru` and `ok.ru` for MediaLinks extension ([(PR #193)](https://github.com/lunet-io/markdig/pull/193))
 ## 0.14.8 (05 Dec 2017)
 - Fix potential StackOverflow exception when processing deep nested `|` delimiters (#179)
 ## 0.14.7 (25 Nov 2017)

license.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2016, Alexandre Mutel
+Copyright (c) 2018, Alexandre Mutel
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without modification

readme.md

@@ -52,6 +52,12 @@ You can **try Markdig online** and compare it to other implementations on [babel
   - [**JIRA links**](src/Markdig.Tests/Specs/JiraLinks.md) to automatically generate links for JIRA project references (Thanks to @clarkd: https://github.com/clarkd/MarkdigJiraLinker)
 - Compatible with .NET 3.5, 4.0+ and .NET Core (`netstandard1.1+`)
 	
+### Third Party Extensions
+
+- [**WPF/XAML Markdown Renderer**: `markdig.wpf`](https://github.com/Kryptos-FR/markdig.wpf)
+- [**Syntax highlighting**: `Markdig.SyntaxHighlighting`](https://github.com/RichardSlater/Markdig.SyntaxHighlighting)
+- [**Embedded C# scripting**: `Markdig.Extensions.ScriptCs`](https://github.com/macaba/Markdig.Extensions.ScriptCs)
+
 ## Documentation
 
 > The repository is under construction. There will be a dedicated website and proper documentation at some point!

src/Markdig.Tests/Markdig.Tests.csproj

@@ -57,6 +57,7 @@
       <DependentUpon>Specs.tt</DependentUpon>
     </Compile>
     <Compile Include="Specs\TestEmphasisPlus.cs" />
+    <Compile Include="TestConfigureNewLine.cs" />
     <Compile Include="TestHtmlAttributes.cs" />
     <Compile Include="TestHtmlHelper.cs" />
     <Compile Include="TestLineReader.cs" />
@@ -65,6 +66,8 @@
     <Compile Include="TestOrderedList.cs" />
     <Compile Include="TestPlainText.cs" />
     <Compile Include="TestPragmaLines.cs" />
+    <Compile Include="TestLinkRewriter.cs" />
+    <Compile Include="TestRelativeUrlReplacement.cs" />
     <Compile Include="TestSourcePosition.cs" />
     <Compile Include="TestStringSliceList.cs" />
     <Compile Include="TestPlayParser.cs" />

src/Markdig.Tests/Specs/AutoIdentifierSpecs.md

@@ -12,7 +12,7 @@ Allows to automatically creates an identifier for a heading:
 <h1 id="this-is-a-heading">This is a heading</h1>
 ````````````````````````````````
 
-Only punctuation `-`, `_` and `.` is kept, all over non letter characters are discarded.
+Only punctuation `-`, `_` and `.` is kept, all other non letter characters are discarded.
 Consecutive same character `-`, `_` or `.` are rendered into a single one
 Characters `-`, `_` and `.` at the end of the string are also discarded.
 

src/Markdig.Tests/Specs/AutoLinks.md

@@ -19,7 +19,7 @@ And a plain www.google.com
 .
 <p>This is a <a href="http://www.google.com">http://www.google.com</a> URL and <a href="https://www.google.com">https://www.google.com</a>
 This is a <a href="ftp://test.com">ftp://test.com</a>
-And a <a href="mailto:email@toto.com">mailto:email@toto.com</a>
+And a <a href="mailto:email@toto.com">email@toto.com</a>
 And a plain <a href="http://www.google.com">www.google.com</a></p>
 ````````````````````````````````
 

src/Markdig.Tests/Specs/FootnotesSpecs.md

@@ -118,3 +118,24 @@ Here is a footnote[^1]. And another one[^2]. And a third one[^3]. And a fourth[^
 </ol>
 </div>
 ````````````````````````````````
+
+A footnote link inside a list should work as well:
+
+```````````````````````````````` example
+- abc
+- def[^1]
+
+[^1]: Here is the footnote.
+.
+<ul>
+<li>abc</li>
+<li>def<a id="fnref:1" href="#fn:1" class="footnote-ref"><sup>1</sup></a></li>
+</ul>
+<div class="footnotes">
+<hr />
+<ol>
+<li id="fn:1">
+<p>Here is the footnote.<a href="#fnref:1" class="footnote-back-ref">&#8617;</a></p></li>
+</ol>
+</div>
+````````````````````````````````

src/Markdig.Tests/Specs/MediaSpecs.md

@@ -12,8 +12,14 @@ Allows to embed audio/video links to popular website:
 ![Video2](https://vimeo.com/8607834)
 
 ![Video3](https://sample.com/video.mp4)
+
+![Audio4](https://music.yandex.ru/album/411845/track/4402274)
+
+![Video5](https://ok.ru/video/26870090463)
 .
 <p><iframe src="https://www.youtube.com/embed/mswPy5bt3TQ" width="500" height="281" frameborder="0" allowfullscreen></iframe></p>
 <p><iframe src="https://player.vimeo.com/video/8607834" width="500" height="281" frameborder="0" allowfullscreen></iframe></p>
 <p><video width="500" height="281" controls><source type="video/mp4" src="https://sample.com/video.mp4"></source></video></p>
+<p><iframe src="https://music.yandex.ru/iframe/#track/4402274/411845/" width="500" height="281" frameborder="0"></iframe></p>
+<p><iframe src="https://ok.ru/videoembed/26870090463" width="500" height="281" frameborder="0" allowfullscreen></iframe></p>
 ````````````````````````````````

src/Markdig.Tests/Specs/Specs.tt

@@ -67,6 +67,7 @@ SOFTWARE.
     var emptyLines = false;
     var displayEmptyLines = false;
 #>
+// Generated the <#= DateTime.Now #>
 using System;
 using NUnit.Framework;
 
@@ -148,7 +149,7 @@ private class Spec
 
     public string Name
     {
-        get { return string.Format("Example{0:000}", Example); }
+        get { return string.Format("{0}_Example{1:000}", SecHeadingCompact, Example); }
     }
 }
 

src/Markdig.Tests/TestConfigureNewLine.cs

@@ -0,0 +1,25 @@
+using NUnit.Framework;
+
+namespace Markdig.Tests
+{
+    [TestFixture]
+    public class TestConfigureNewLine
+    {
+        [Test]
+        [TestCase(/* newLineForWriting: */ "\n",   /* markdownText: */ "*1*\n*2*\n",     /* expected: */ "<p><em>1</em>\n<em>2</em></p>\n")]
+        [TestCase(/* newLineForWriting: */ "\n",   /* markdownText: */ "*1*\r\n*2*\r\n", /* expected: */ "<p><em>1</em>\n<em>2</em></p>\n")]
+        [TestCase(/* newLineForWriting: */ "\r\n", /* markdownText: */ "*1*\n*2*\n",     /* expected: */ "<p><em>1</em>\r\n<em>2</em></p>\r\n")]
+        [TestCase(/* newLineForWriting: */ "\r\n", /* markdownText: */ "*1*\r\n*2*\r\n", /* expected: */ "<p><em>1</em>\r\n<em>2</em></p>\r\n")]
+        [TestCase(/* newLineForWriting: */ "!!!" , /* markdownText: */ "*1*\n*2*\n",     /* expected: */ "<p><em>1</em>!!!<em>2</em></p>!!!")]
+        [TestCase(/* newLineForWriting: */ "!!!" , /* markdownText: */ "*1*\r\n*2*\r\n", /* expected: */ "<p><em>1</em>!!!<em>2</em></p>!!!")]
+        public void TestHtmlOutputWhenConfiguringNewLine(string newLineForWriting, string markdownText, string expected)
+        {
+            var pipeline = new MarkdownPipelineBuilder()
+                .ConfigureNewLine(newLineForWriting)
+                .Build();
+
+            var actual = Markdown.ToHtml(markdownText, pipeline);
+            Assert.AreEqual(expected, actual);
+        }
+    }
+}

src/Markdig.Tests/TestLinkRewriter.cs

@@ -0,0 +1,44 @@
+using System;
+using System.IO;
+using Markdig.Parsers;
+using Markdig.Renderers;
+using NUnit.Framework;
+
+namespace Markdig.Tests
+{
+    public class TestLinkRewriter
+    {
+        [Test]
+        public void ReplacesRelativeLinks()
+        {
+            TestSpec(s => "abc" + s, "Link: [hello](/relative.jpg)", "abc/relative.jpg");
+            TestSpec(s => s + "xyz", "Link: [hello](relative.jpg)", "relative.jpgxyz");
+            TestSpec(null, "Link: [hello](relative.jpg)", "relative.jpg");
+            TestSpec(null, "Link: [hello](/relative.jpg)", "/relative.jpg");
+        }
+
+        [Test]
+        public void ReplacesRelativeImageSources()
+        {
+            TestSpec(s => "abc" + s, "Image: ![alt text](/image.jpg)", "abc/image.jpg");
+            TestSpec(s => "abc" + s, "Image: ![alt text](image.jpg \"title\")", "abcimage.jpg");
+            TestSpec(null, "Image: ![alt text](/image.jpg)", "/image.jpg");
+        }
+
+        public static void TestSpec(Func<string,string> linkRewriter, string markdown, string expectedLink)
+        {
+            var pipeline = new MarkdownPipelineBuilder().Build();
+
+            var writer = new StringWriter();
+            var renderer = new HtmlRenderer(writer);
+            renderer.LinkRewriter = linkRewriter;
+            pipeline.Setup(renderer);
+
+            var document = MarkdownParser.Parse(markdown, pipeline);
+            renderer.Render(document);
+            writer.Flush();
+
+            Assert.That(writer.ToString(), Contains.Substring("=\"" + expectedLink + "\""));
+        }
+    }
+}

src/Markdig.Tests/TestNormalize.cs

@@ -411,6 +411,28 @@ This is a last line";
 
 
 
+        [Test]
+        public void JiraLinks()
+        {
+            AssertNormalizeNoTrim("FOO-1234");
+            AssertNormalizeNoTrim("AB-1");
+
+            AssertNormalizeNoTrim("**Hello World AB-1**");
+        }
+
+        [Test]
+        public void AutoLinks()
+        {
+            AssertNormalizeNoTrim("Hello from http://example.com/foo", "Hello from [http://example.com/foo](http://example.com/foo)", new NormalizeOptions() { ExpandAutoLinks = true, });
+            AssertNormalizeNoTrim("Hello from www.example.com/foo", "Hello from [www.example.com/foo](http://www.example.com/foo)", new NormalizeOptions() { ExpandAutoLinks = true, });
+            AssertNormalizeNoTrim("Hello from ftp://example.com", "Hello from [ftp://example.com](ftp://example.com)", new NormalizeOptions() { ExpandAutoLinks = true, });
+            AssertNormalizeNoTrim("Hello from mailto:hello@example.com", "Hello from [hello@example.com](mailto:hello@example.com)", new NormalizeOptions() { ExpandAutoLinks = true, });
+
+            AssertNormalizeNoTrim("Hello from http://example.com/foo", "Hello from http://example.com/foo", new NormalizeOptions() { ExpandAutoLinks = false, });
+            AssertNormalizeNoTrim("Hello from www.example.com/foo", "Hello from http://www.example.com/foo", new NormalizeOptions() { ExpandAutoLinks = false, });
+            AssertNormalizeNoTrim("Hello from mailto:hello@example.com", "Hello from mailto:hello@example.com", new NormalizeOptions() { ExpandAutoLinks = false, });
+        }
+
         private static void AssertSyntax(string expected, MarkdownObject syntax)
         {
             var writer = new StringWriter();
@@ -441,6 +463,8 @@ This is a last line";
             expected = NormText(expected, trim);
 
             var pipeline = new MarkdownPipelineBuilder()
+                .UseAutoLinks()
+                .UseJiraLinks(new Extensions.JiraLinks.JiraLinkOptions("https://jira.example.com"))
                 .UseTaskLists()
                 .Build();
 

src/Markdig.Tests/TestRelativeUrlReplacement.cs

@@ -0,0 +1,48 @@
+using System;
+using System.IO;
+using Markdig.Parsers;
+using Markdig.Renderers;
+using NUnit.Framework;
+
+namespace Markdig.Tests
+{
+    public class TestRelativeUrlReplacement
+    {
+        [Test]
+        public void ReplacesRelativeLinks()
+        {
+            TestSpec("https://example.com", "Link: [hello](/relative.jpg)", "https://example.com/relative.jpg");
+            TestSpec("https://example.com", "Link: [hello](relative.jpg)", "https://example.com/relative.jpg");
+            TestSpec("https://example.com/", "Link: [hello](/relative.jpg?a=b)", "https://example.com/relative.jpg?a=b");
+            TestSpec("https://example.com/", "Link: [hello](relative.jpg#x)", "https://example.com/relative.jpg#x");
+            TestSpec(null, "Link: [hello](relative.jpg)", "relative.jpg");
+            TestSpec(null, "Link: [hello](/relative.jpg)", "/relative.jpg");
+            TestSpec("https://example.com", "Link: [hello](/relative.jpg)", "https://example.com/relative.jpg");
+        }
+
+        [Test]
+        public void ReplacesRelativeImageSources()
+        {
+            TestSpec("https://example.com", "Image: ![alt text](/image.jpg)", "https://example.com/image.jpg");
+            TestSpec("https://example.com", "Image: ![alt text](image.jpg \"title\")", "https://example.com/image.jpg");
+            TestSpec(null, "Image: ![alt text](/image.jpg)", "/image.jpg");
+        }
+
+        public static void TestSpec(string baseUrl, string markdown, string expectedLink)
+        {
+            var pipeline = new MarkdownPipelineBuilder().Build();
+
+            var writer = new StringWriter();
+            var renderer = new HtmlRenderer(writer);
+            if (baseUrl != null)
+                renderer.BaseUrl = new Uri(baseUrl);
+            pipeline.Setup(renderer);
+
+            var document = MarkdownParser.Parse(markdown, pipeline);
+            renderer.Render(document);
+            writer.Flush();
+
+            Assert.That(writer.ToString(), Contains.Substring("=\"" + expectedLink + "\""));
+        }
+    }
+}

src/Markdig.Tests/project.json

@@ -19,6 +19,6 @@
   },
   "dependencies": {
     "NUnit": "3.2.0",
-    "NUnit3TestAdapter": "3.2.0"
+    "NUnit3TestAdapter": "3.9.0"
   }
 }

src/Markdig/Extensions/AutoIdentifiers/AutoIdentifierExtension.cs

@@ -1,201 +1,199 @@
-// Copyright (c) Alexandre Mutel. All rights reserved.
-// This file is licensed under the BSD-Clause 2 license. 
-// See the license.txt file in the project root for more information.
-
-using System;
-using System.Collections.Generic;
-using System.IO;
-using Markdig.Helpers;
-using Markdig.Parsers;
-using Markdig.Renderers;
-using Markdig.Renderers.Html;
-using Markdig.Syntax;
-using Markdig.Syntax.Inlines;
-
-namespace Markdig.Extensions.AutoIdentifiers
-{
-    /// <summary>
-    /// The auto-identifier extension
-    /// </summary>
-    /// <seealso cref="Markdig.IMarkdownExtension" />
-    public class AutoIdentifierExtension : IMarkdownExtension
-    {
-        private const string AutoIdentifierKey = "AutoIdentifier";
-        private readonly HtmlRenderer stripRenderer;
-        private readonly StringWriter headingWriter;
-        private readonly AutoIdentifierOptions options;
-
-        /// <summary>
-        /// Initializes a new instance of the <see cref="AutoIdentifierExtension"/> class.
-        /// </summary>
-        /// <param name="options">The options.</param>
-        public AutoIdentifierExtension(AutoIdentifierOptions options)
-        {
-            this.options = options;
-            headingWriter = new StringWriter();
-            // Use internally a HtmlRenderer to strip links from a heading
-            stripRenderer = new HtmlRenderer(headingWriter)
-            {
-                // Set to false both to avoid having any HTML tags in the output
-                EnableHtmlForInline = false,
-                EnableHtmlEscape = false
-            };
-        }
-
-        public void Setup(MarkdownPipelineBuilder pipeline)
-        {
-            var headingBlockParser = pipeline.BlockParsers.Find<HeadingBlockParser>();
-            if (headingBlockParser != null)
-            {
-                // Install a hook on the HeadingBlockParser when a HeadingBlock is actually processed
-                headingBlockParser.Closed -= HeadingBlockParser_Closed;
-                headingBlockParser.Closed += HeadingBlockParser_Closed;
-            }
-            var paragraphBlockParser = pipeline.BlockParsers.FindExact<ParagraphBlockParser>();
-            if (paragraphBlockParser != null)
-            {
-                // Install a hook on the ParagraphBlockParser when a HeadingBlock is actually processed as a Setex heading
-                paragraphBlockParser.Closed -= HeadingBlockParser_Closed;
-                paragraphBlockParser.Closed += HeadingBlockParser_Closed;
-            }
-        }
-
-        public void Setup(MarkdownPipeline pipeline, IMarkdownRenderer renderer)
-        {
-        }
-
-        /// <summary>
-        /// Process on a new <see cref="HeadingBlock"/>
-        /// </summary>
-        /// <param name="processor">The processor.</param>
-        /// <param name="block">The heading block.</param>
-        private void HeadingBlockParser_Closed(BlockProcessor processor, Block block)
-        {
-            // We may have a ParagraphBlock here as we have a hook on the ParagraphBlockParser
-            var headingBlock = block as HeadingBlock;
-            if (headingBlock == null)
-            {
-                return;
-            }
-
-            // If the AutoLink options is set, we register a LinkReferenceDefinition at the document level
-            if ((options & AutoIdentifierOptions.AutoLink) != 0)
-            {
-                var headingLine = headingBlock.Lines.Lines[0];
-
-                var text = headingLine.ToString();
-
-                var linkRef = new HeadingLinkReferenceDefinition()
-                {
-                    Heading = headingBlock,
-                    CreateLinkInline = CreateLinkInlineForHeading
-                };
-
-                var doc = processor.Document;
-                var dictionary = doc.GetData(this) as Dictionary<string, HeadingLinkReferenceDefinition>;
-                if (dictionary == null)
-                {
-                    dictionary = new Dictionary<string, HeadingLinkReferenceDefinition>();
-                    doc.SetData(this, dictionary);
-                    doc.ProcessInlinesBegin += DocumentOnProcessInlinesBegin;
-                }
-                dictionary[text] = linkRef;
-            }
-
-            // Then we register after inline have been processed to actually generate the proper #id
-            headingBlock.ProcessInlinesEnd += HeadingBlock_ProcessInlinesEnd;
-        }
-
-        private void DocumentOnProcessInlinesBegin(InlineProcessor processor, Inline inline)
-        {
-            var doc = processor.Document;
-            doc.ProcessInlinesBegin -= DocumentOnProcessInlinesBegin;
-            var dictionary = (Dictionary<string, HeadingLinkReferenceDefinition>)doc.GetData(this);
-            foreach (var keyPair in dictionary)
-            {
-                // Here we make sure that auto-identifiers will not override an existing link definition
-                // defined in the document
-                // If it is the case, we skip the auto identifier for the Heading
-                if (!doc.TryGetLinkReferenceDefinition(keyPair.Key, out var linkDef))
-                {
-                    doc.SetLinkReferenceDefinition(keyPair.Key, keyPair.Value);
-                }
-            }
-            // Once we are done, we don't need to keep the intermediate dictionary arround
-            doc.RemoveData(this);
-        }
-
-        /// <summary>
-        /// Callback when there is a reference to found to a heading. 
-        /// Note that reference are only working if they are declared after.
-        /// </summary>
-        private Inline CreateLinkInlineForHeading(InlineProcessor inlineState, LinkReferenceDefinition linkRef, Inline child)
-        {
-            var headingRef = (HeadingLinkReferenceDefinition) linkRef;
-            return new LinkInline()
-            {
-                // Use GetDynamicUrl to allow late binding of the Url (as a link may occur before the heading is declared and
-                // the inlines of the heading are actually processed by HeadingBlock_ProcessInlinesEnd)
-                GetDynamicUrl = () => HtmlHelper.Unescape("#" + headingRef.Heading.GetAttributes().Id),
-                Title = HtmlHelper.Unescape(linkRef.Title),
-            };
-        }
-
-        /// <summary>
-        /// Process the inlines of the heading to create a unique identifier
-        /// </summary>
-        /// <param name="processor">The processor.</param>
-        /// <param name="inline">The inline.</param>
-        private void HeadingBlock_ProcessInlinesEnd(InlineProcessor processor, Inline inline)
-        {
-            var identifiers = processor.Document.GetData(AutoIdentifierKey) as HashSet<string>;
-            if (identifiers == null)
-            {
-                identifiers = new HashSet<string>();
-                processor.Document.SetData(AutoIdentifierKey, identifiers);
-            }
-
-            var headingBlock = (HeadingBlock) processor.Block;
-            if (headingBlock.Inline == null)
-            {
-                return;
-            }
-
-            // If id is already set, don't try to modify it
-            var attributes = processor.Block.GetAttributes();
-            if (attributes.Id != null)
-            {
-                return;
-            }
-
-            // Use a HtmlRenderer with 
-            stripRenderer.Render(headingBlock.Inline);
-            var headingText = headingWriter.ToString();
-            headingWriter.GetStringBuilder().Length = 0;
-
-            // Urilize the link
-            headingText = (options & AutoIdentifierOptions.GitHub) != 0
-                ? LinkHelper.UrilizeAsGfm(headingText)
-                : LinkHelper.Urilize(headingText, (options & AutoIdentifierOptions.AllowOnlyAscii) != 0);
-
-            // If the heading is empty, use the word "section" instead
-            var baseHeadingId = string.IsNullOrEmpty(headingText) ? "section" : headingText;
-
-            // Add a trailing -1, -2, -3...etc. in case of collision
-            int index = 0;
-            var headingId = baseHeadingId;
-            var headingBuffer = StringBuilderCache.Local();
-            while (!identifiers.Add(headingId))
-            {
-                index++;
-                headingBuffer.Append(baseHeadingId);
-                headingBuffer.Append('-');
-                headingBuffer.Append(index);
-                headingId = headingBuffer.ToString();
-                headingBuffer.Length = 0;
-            }
-
-            attributes.Id = headingId;
-        }
-    }
+// Copyright (c) Alexandre Mutel. All rights reserved.
+// This file is licensed under the BSD-Clause 2 license. 
+// See the license.txt file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Markdig.Helpers;
+using Markdig.Parsers;
+using Markdig.Renderers;
+using Markdig.Renderers.Html;
+using Markdig.Syntax;
+using Markdig.Syntax.Inlines;
+
+namespace Markdig.Extensions.AutoIdentifiers
+{
+    /// <summary>
+    /// The auto-identifier extension
+    /// </summary>
+    /// <seealso cref="Markdig.IMarkdownExtension" />
+    public class AutoIdentifierExtension : IMarkdownExtension
+    {
+        private const string AutoIdentifierKey = "AutoIdentifier";
+        private readonly AutoIdentifierOptions options;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AutoIdentifierExtension"/> class.
+        /// </summary>
+        /// <param name="options">The options.</param>
+        public AutoIdentifierExtension(AutoIdentifierOptions options)
+        {
+            this.options = options;
+        }
+
+        public void Setup(MarkdownPipelineBuilder pipeline)
+        {
+            var headingBlockParser = pipeline.BlockParsers.Find<HeadingBlockParser>();
+            if (headingBlockParser != null)
+            {
+                // Install a hook on the HeadingBlockParser when a HeadingBlock is actually processed
+                headingBlockParser.Closed -= HeadingBlockParser_Closed;
+                headingBlockParser.Closed += HeadingBlockParser_Closed;
+            }
+            var paragraphBlockParser = pipeline.BlockParsers.FindExact<ParagraphBlockParser>();
+            if (paragraphBlockParser != null)
+            {
+                // Install a hook on the ParagraphBlockParser when a HeadingBlock is actually processed as a Setex heading
+                paragraphBlockParser.Closed -= HeadingBlockParser_Closed;
+                paragraphBlockParser.Closed += HeadingBlockParser_Closed;
+            }
+        }
+
+        public void Setup(MarkdownPipeline pipeline, IMarkdownRenderer renderer)
+        {
+        }
+
+        /// <summary>
+        /// Process on a new <see cref="HeadingBlock"/>
+        /// </summary>
+        /// <param name="processor">The processor.</param>
+        /// <param name="block">The heading block.</param>
+        private void HeadingBlockParser_Closed(BlockProcessor processor, Block block)
+        {
+            // We may have a ParagraphBlock here as we have a hook on the ParagraphBlockParser
+            var headingBlock = block as HeadingBlock;
+            if (headingBlock == null)
+            {
+                return;
+            }
+
+            // If the AutoLink options is set, we register a LinkReferenceDefinition at the document level
+            if ((options & AutoIdentifierOptions.AutoLink) != 0)
+            {
+                var headingLine = headingBlock.Lines.Lines[0];
+
+                var text = headingLine.ToString();
+
+                var linkRef = new HeadingLinkReferenceDefinition()
+                {
+                    Heading = headingBlock,
+                    CreateLinkInline = CreateLinkInlineForHeading
+                };
+
+                var doc = processor.Document;
+                var dictionary = doc.GetData(this) as Dictionary<string, HeadingLinkReferenceDefinition>;
+                if (dictionary == null)
+                {
+                    dictionary = new Dictionary<string, HeadingLinkReferenceDefinition>();
+                    doc.SetData(this, dictionary);
+                    doc.ProcessInlinesBegin += DocumentOnProcessInlinesBegin;
+                }
+                dictionary[text] = linkRef;
+            }
+
+            // Then we register after inline have been processed to actually generate the proper #id
+            headingBlock.ProcessInlinesEnd += HeadingBlock_ProcessInlinesEnd;
+        }
+
+        private void DocumentOnProcessInlinesBegin(InlineProcessor processor, Inline inline)
+        {
+            var doc = processor.Document;
+            doc.ProcessInlinesBegin -= DocumentOnProcessInlinesBegin;
+            var dictionary = (Dictionary<string, HeadingLinkReferenceDefinition>)doc.GetData(this);
+            foreach (var keyPair in dictionary)
+            {
+                // Here we make sure that auto-identifiers will not override an existing link definition
+                // defined in the document
+                // If it is the case, we skip the auto identifier for the Heading
+                if (!doc.TryGetLinkReferenceDefinition(keyPair.Key, out var linkDef))
+                {
+                    doc.SetLinkReferenceDefinition(keyPair.Key, keyPair.Value);
+                }
+            }
+            // Once we are done, we don't need to keep the intermediate dictionary arround
+            doc.RemoveData(this);
+        }
+
+        /// <summary>
+        /// Callback when there is a reference to found to a heading. 
+        /// Note that reference are only working if they are declared after.
+        /// </summary>
+        private Inline CreateLinkInlineForHeading(InlineProcessor inlineState, LinkReferenceDefinition linkRef, Inline child)
+        {
+            var headingRef = (HeadingLinkReferenceDefinition) linkRef;
+            return new LinkInline()
+            {
+                // Use GetDynamicUrl to allow late binding of the Url (as a link may occur before the heading is declared and
+                // the inlines of the heading are actually processed by HeadingBlock_ProcessInlinesEnd)
+                GetDynamicUrl = () => HtmlHelper.Unescape("#" + headingRef.Heading.GetAttributes().Id),
+                Title = HtmlHelper.Unescape(linkRef.Title),
+            };
+        }
+
+        /// <summary>
+        /// Process the inlines of the heading to create a unique identifier
+        /// </summary>
+        /// <param name="processor">The processor.</param>
+        /// <param name="inline">The inline.</param>
+        private void HeadingBlock_ProcessInlinesEnd(InlineProcessor processor, Inline inline)
+        {
+            var identifiers = processor.Document.GetData(AutoIdentifierKey) as HashSet<string>;
+            if (identifiers == null)
+            {
+                identifiers = new HashSet<string>();
+                processor.Document.SetData(AutoIdentifierKey, identifiers);
+            }
+
+            var headingBlock = (HeadingBlock) processor.Block;
+            if (headingBlock.Inline == null)
+            {
+                return;
+            }
+
+            // If id is already set, don't try to modify it
+            var attributes = processor.Block.GetAttributes();
+            if (attributes.Id != null)
+            {
+                return;
+            }
+
+            // Use internally a HtmlRenderer to strip links from a heading
+            var headingWriter = new StringWriter();
+            var stripRenderer = new HtmlRenderer(headingWriter)
+            {
+                // Set to false both to avoid having any HTML tags in the output
+                EnableHtmlForInline = false,
+                EnableHtmlEscape = false
+            };
+
+            stripRenderer.Render(headingBlock.Inline);
+            var headingText = headingWriter.ToString();
+            headingWriter.GetStringBuilder().Length = 0;
+
+            // Urilize the link
+            headingText = (options & AutoIdentifierOptions.GitHub) != 0
+                ? LinkHelper.UrilizeAsGfm(headingText)
+                : LinkHelper.Urilize(headingText, (options & AutoIdentifierOptions.AllowOnlyAscii) != 0);
+
+            // If the heading is empty, use the word "section" instead
+            var baseHeadingId = string.IsNullOrEmpty(headingText) ? "section" : headingText;
+
+            // Add a trailing -1, -2, -3...etc. in case of collision
+            int index = 0;
+            var headingId = baseHeadingId;
+            var headingBuffer = StringBuilderCache.Local();
+            while (!identifiers.Add(headingId))
+            {
+                index++;
+                headingBuffer.Append(baseHeadingId);
+                headingBuffer.Append('-');
+                headingBuffer.Append(index);
+                headingId = headingBuffer.ToString();
+                headingBuffer.Length = 0;
+            }
+
+            attributes.Id = headingId;
+        }
+    }
 }

src/Markdig/Extensions/AutoLinks/AutoLinkExtension.cs

@@ -1,9 +1,10 @@
-// Copyright (c) Alexandre Mutel. All rights reserved.
+// Copyright (c) Alexandre Mutel. All rights reserved.
 // This file is licensed under the BSD-Clause 2 license. 
 // See the license.txt file in the project root for more information.
 
 using Markdig.Renderers;
-using Markdig.Syntax.Inlines;
+using Markdig.Renderers.Normalize;
+using Markdig.Renderers.Normalize.Inlines;
 
 namespace Markdig.Extensions.AutoLinks
 {
@@ -24,6 +25,11 @@ namespace Markdig.Extensions.AutoLinks
 
         public void Setup(MarkdownPipeline pipeline, IMarkdownRenderer renderer)
         {
+            var normalizeRenderer = renderer as NormalizeRenderer;
+            if (normalizeRenderer != null && !normalizeRenderer.ObjectRenderers.Contains<NormalizeAutoLinkRenderer>())
+            {
+                normalizeRenderer.ObjectRenderers.InsertBefore<LinkInlineRenderer>(new NormalizeAutoLinkRenderer());
+            }
         }
     }
 }

src/Markdig/Extensions/AutoLinks/AutoLinkParser.cs

@@ -158,7 +158,11 @@ namespace Markdig.Extensions.AutoLinks
                 Column = column,
                 Url = c == 'w' ? "http://" + link : link,
                 IsClosed = true,
+                IsAutoLink = true,
             };
+
+            var skipFromBeginning = c == 'm' ? 7 : 0; // For mailto: skip "mailto:" for content
+
             inline.Span.End = inline.Span.Start + link.Length - 1;
             inline.UrlSpan = inline.Span;
             inline.AppendChild(new LiteralInline()
@@ -166,7 +170,7 @@ namespace Markdig.Extensions.AutoLinks
                 Span = inline.Span,
                 Line = line,
                 Column = column,
-                Content = new StringSlice(slice.Text, startPosition, startPosition + link.Length - 1),
+                Content = new StringSlice(slice.Text, startPosition + skipFromBeginning, startPosition + link.Length - 1),
                 IsClosed = true
             });
             processor.Inline = inline;

src/Markdig/Extensions/AutoLinks/NormalizeAutoLinkRenderer.cs

@@ -0,0 +1,29 @@
+using Markdig.Renderers;
+using Markdig.Renderers.Normalize;
+using Markdig.Syntax;
+using Markdig.Syntax.Inlines;
+
+namespace Markdig.Extensions.AutoLinks
+{
+    public class NormalizeAutoLinkRenderer : NormalizeObjectRenderer<LinkInline>
+    {
+        public override bool Accept(RendererBase renderer, MarkdownObject obj)
+        {
+            if (base.Accept(renderer, obj))
+            {
+                var normalizeRenderer = renderer as NormalizeRenderer;
+                var link = obj as LinkInline;
+
+                return normalizeRenderer != null && link != null && !normalizeRenderer.Options.ExpandAutoLinks && link.IsAutoLink;
+            }
+            else
+            {
+                return false;
+            }
+        }
+        protected override void Write(NormalizeRenderer renderer, LinkInline obj)
+        {
+            renderer.Write(obj.Url);
+        }
+    }
+}

src/Markdig/Extensions/Footnotes/FootnoteParser.cs

@@ -33,7 +33,8 @@ namespace Markdig.Extensions.Footnotes
         private BlockState TryOpen(BlockProcessor processor, bool isContinue)
         {
             // We expect footnote to appear only at document level and not indented more than a code indent block
-            if (processor.IsCodeIndent || (!isContinue && processor.CurrentContainer.GetType() != typeof(MarkdownDocument)) || (isContinue && !(processor.CurrentContainer is Footnote)))
+            var currentContainer = processor.GetCurrentContainerOpened();
+            if (processor.IsCodeIndent || (!isContinue && currentContainer.GetType() != typeof(MarkdownDocument)) || (isContinue && !(currentContainer is FootnoteGroup)))
             {
                 return BlockState.None;
             }

src/Markdig/Extensions/JiraLinks/JiraLinkExtension.cs

@@ -1,8 +1,10 @@
-// Copyright (c) Alexandre Mutel. All rights reserved.
+// Copyright (c) Alexandre Mutel. All rights reserved.
 // This file is licensed under the BSD-Clause 2 license. 
 // See the license.txt file in the project root for more information.
 using Markdig.Parsers.Inlines;
 using Markdig.Renderers;
+using Markdig.Renderers.Normalize.Inlines;
+using Markdig.Renderers.Normalize;
 
 namespace Markdig.Extensions.JiraLinks
 {
@@ -30,7 +32,13 @@ namespace Markdig.Extensions.JiraLinks
 
         public void Setup(MarkdownPipeline pipeline, IMarkdownRenderer renderer)
         {
-            // Nothing to setup, JiraLinks used a normal LinkInlineRenderer
+            // No HTML renderer required, since JiraLink type derives from InlineLink (which already has an HTML renderer)
+
+            var normalizeRenderer = renderer as NormalizeRenderer;
+            if (normalizeRenderer != null && !normalizeRenderer.ObjectRenderers.Contains<NormalizeJiraLinksRenderer>())
+            {
+                normalizeRenderer.ObjectRenderers.InsertBefore<LinkInlineRenderer>(new NormalizeJiraLinksRenderer());
+            }
         }
     }
     

src/Markdig/Extensions/JiraLinks/NormalizeJiraLinksRenderer.cs

@@ -0,0 +1,18 @@
+using Markdig.Renderers.Normalize;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Markdig.Extensions.JiraLinks
+{
+    public class NormalizeJiraLinksRenderer : NormalizeObjectRenderer<JiraLink>
+    {
+        protected override void Write(NormalizeRenderer renderer, JiraLink obj)
+        {
+            renderer.Write(obj.ProjectKey);
+            renderer.Write("-");
+            renderer.Write(obj.Issue);
+        }
+    }
+}

src/Markdig/Extensions/MediaLinks/MediaLinkExtension.cs

@@ -1,8 +1,10 @@
-// Copyright (c) Alexandre Mutel. All rights reserved.
+// Copyright (c) Alexandre Mutel. All rights reserved.
 // This file is licensed under the BSD-Clause 2 license. 
 // See the license.txt file in the project root for more information.
 
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using Markdig.Renderers;
 using Markdig.Renderers.Html;
 using Markdig.Renderers.Html.Inlines;
@@ -47,88 +49,178 @@ namespace Markdig.Extensions.MediaLinks
 
         private bool TryLinkInlineRenderer(HtmlRenderer renderer, LinkInline linkInline)
         {
-            if (linkInline.IsImage && linkInline.Url != null)
+            if (!linkInline.IsImage || linkInline.Url == null)
             {
-                Uri uri;
-                // Only process absolute Uri
-                if (Uri.TryCreate(linkInline.Url, UriKind.RelativeOrAbsolute, out uri) && uri.IsAbsoluteUri)
+                return false;
+            }
+
+            Uri uri;
+            // Only process absolute Uri
+            if (!Uri.TryCreate(linkInline.Url, UriKind.RelativeOrAbsolute, out uri) || !uri.IsAbsoluteUri)
+            {
+                return false;
+            }
+
+            if (TryRenderIframeFromKnownProviders(uri, renderer, linkInline))
+            {
+                return true;
+            }
+
+            if (TryGuessAudioVideoFile(uri, renderer, linkInline))
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        private static HtmlAttributes GetHtmlAttributes(LinkInline linkInline)
+        {
+            var htmlAttributes = new HtmlAttributes();
+            var fromAttributes = linkInline.TryGetAttributes();
+            if (fromAttributes != null)
+            {
+                fromAttributes.CopyTo(htmlAttributes, false, false);
+            }
+
+            return htmlAttributes;
+        }
+
+        private bool TryGuessAudioVideoFile(Uri uri, HtmlRenderer renderer, LinkInline linkInline)
+        {
+            var path = uri.GetComponents(UriComponents.Path, UriFormat.Unescaped);
+            // Otherwise try to detect if we have an audio/video from the file extension
+            string mimeType;
+            var lastDot = path.LastIndexOf('.');
+            if (lastDot >= 0 &&
+                Options.ExtensionToMimeType.TryGetValue(path.Substring(lastDot), out mimeType))
+            {
+                var htmlAttributes = GetHtmlAttributes(linkInline);
+                var isAudio = mimeType.StartsWith("audio");
+                var tagType = isAudio ? "audio" : "video";
+
+                renderer.Write($"<{tagType}");
+                htmlAttributes.AddPropertyIfNotExist("width", Options.Width);
+                if (!isAudio)
                 {
-                    var htmlAttributes = new HtmlAttributes();
-                    var fromAttributes = linkInline.TryGetAttributes();
-                    if (fromAttributes != null)
-                    {
-                        fromAttributes.CopyTo(htmlAttributes, false, false);
-                    }
-
-                    // TODO: this code is not pluggable, so for now, we handle only the following web providers:
-                    // - youtube
-                    // - vimeo
-                    var path = uri.GetComponents(UriComponents.Path, UriFormat.Unescaped);
-
-                    string iFrameUrl = null;
-                    if (uri.Host.StartsWith("www.youtube.com", StringComparison.OrdinalIgnoreCase))
-                    {
-                        var query = SplitQuery(uri);
-                        if (query.Length > 0 && query[0].StartsWith("v="))
-                        {
-                            iFrameUrl = $"https://www.youtube.com/embed/{query[0].Substring(2)}";
-                        }
-                    }
-                    else if (uri.Host.StartsWith("vimeo.com", StringComparison.OrdinalIgnoreCase))
-                    {
-                        var items = path.Split('/');
-                        if (items.Length > 0)
-                        {
-                            iFrameUrl = $"https://player.vimeo.com/video/{items[items.Length - 1]}";
-                        }
-                    }
-
-                    if (iFrameUrl != null)
-                    {
-                        renderer.Write($"<iframe src=\"{iFrameUrl}\"");
-                        htmlAttributes.AddPropertyIfNotExist("width", Options.Width);
-                        htmlAttributes.AddPropertyIfNotExist("height", Options.Height);
-                        htmlAttributes.AddPropertyIfNotExist("frameborder", "0");
-                        htmlAttributes.AddPropertyIfNotExist("allowfullscreen", null);
-                        renderer.WriteAttributes(htmlAttributes);
-                        renderer.Write("></iframe>");
-                        return true;
-                    }
-                    else
-                    {
-                        // Otherwise try to detect if we have an audio/video from the file extension
-                        string mimeType;
-                        var lastDot = path.LastIndexOf('.');
-                        if (lastDot >= 0 &&
-                            Options.ExtensionToMimeType.TryGetValue(path.Substring(lastDot), out mimeType))
-                        {
-                            var isAudio = mimeType.StartsWith("audio");
-                            var tagType = isAudio ? "audio" : "video";
-
-                            renderer.Write($"<{tagType}");
-                            htmlAttributes.AddPropertyIfNotExist("width", Options.Width);
-                            if (!isAudio)
-                            {
-                                htmlAttributes.AddPropertyIfNotExist("height", Options.Height);
-                            }
-                            htmlAttributes.AddPropertyIfNotExist("controls", null);
-                            renderer.WriteAttributes(htmlAttributes);
-
-                            renderer.Write($"><source type=\"{mimeType}\" src=\"{linkInline.Url}\"></source></{tagType}>");
-
-                            return true;
-                        }
-                    }
+                    htmlAttributes.AddPropertyIfNotExist("height", Options.Height);
                 }
+                htmlAttributes.AddPropertyIfNotExist("controls", null);
+                renderer.WriteAttributes(htmlAttributes);
+
+                renderer.Write($"><source type=\"{mimeType}\" src=\"{linkInline.Url}\"></source></{tagType}>");
+
+                return true;
             }
             return false;
         }
 
+        #region Known providers
+
+        private class KnownProvider
+        {
+            public string HostPrefix { get; set; }
+            public Func<Uri, string> Delegate { get; set; }
+            public bool AllowFullScreen { get; set; } = true; //Should be false for audio embedding
+        }
+
+        private static readonly List<KnownProvider> KnownHosts = new List<KnownProvider>()
+        {
+            new KnownProvider {HostPrefix = "www.youtube.com", Delegate = YouTube},
+            new KnownProvider {HostPrefix = "vimeo.com", Delegate = Vimeo},
+            new KnownProvider {HostPrefix = "music.yandex.ru", Delegate = Yandex, AllowFullScreen = false},
+            new KnownProvider {HostPrefix = "ok.ru", Delegate = Odnoklassniki},
+        };
+
+
+        private bool TryRenderIframeFromKnownProviders(Uri uri, HtmlRenderer renderer, LinkInline linkInline)
+        {
+            var foundProvider = 
+                KnownHosts
+                    .Where(pair => uri.Host.StartsWith(pair.HostPrefix, StringComparison.OrdinalIgnoreCase))  // when host is match
+                    .Select(provider =>
+                        new
+                        {
+                            provider.AllowFullScreen,
+                            Result = provider.Delegate(uri) // try to call delegate to get iframeUrl
+                        }
+                        )
+                    .FirstOrDefault(provider => provider.Result != null);                                   // use first success
+
+            if (foundProvider == null)
+            {
+                return false;
+            }
+
+            var htmlAttributes = GetHtmlAttributes(linkInline);
+            renderer.Write($"<iframe src=\"{foundProvider.Result}\"");
+
+            if(!string.IsNullOrEmpty(Options.Width))
+                htmlAttributes.AddPropertyIfNotExist("width", Options.Width);
+
+            if (!string.IsNullOrEmpty(Options.Height))
+                htmlAttributes.AddPropertyIfNotExist("height", Options.Height);
+
+            if (!string.IsNullOrEmpty(Options.Class))
+                htmlAttributes.AddPropertyIfNotExist("class", Options.Class);
+
+            htmlAttributes.AddPropertyIfNotExist("frameborder", "0");
+            if (foundProvider.AllowFullScreen)
+            {
+                htmlAttributes.AddPropertyIfNotExist("allowfullscreen", null);
+            }
+            renderer.WriteAttributes(htmlAttributes);
+            renderer.Write("></iframe>");
+
+            return true;
+        }
+
         private static readonly string[] SplitAnd = {"&"};
         private static string[] SplitQuery(Uri uri)
         {
             var query = uri.Query.Substring(uri.Query.IndexOf('?') + 1);
             return query.Split(SplitAnd, StringSplitOptions.RemoveEmptyEntries);
         }
+
+        private static string YouTube(Uri uri)
+        {
+            var query = SplitQuery(uri);
+            return query.Length > 0 && query[0].StartsWith("v=")
+                ? $"https://www.youtube.com/embed/{query[0].Substring(2)}"
+                : null;
+        }
+
+        private static string Vimeo(Uri uri)
+        {
+            var items = uri.GetComponents(UriComponents.Path, UriFormat.Unescaped).Split('/');
+            return items.Length > 0 ? $"https://player.vimeo.com/video/{items[items.Length - 1]}" : null;
+        }
+
+        private static string Odnoklassniki(Uri uri)
+        {
+            var items = uri.GetComponents(UriComponents.Path, UriFormat.Unescaped).Split('/');
+            return items.Length > 0 ? $"https://ok.ru/videoembed/{items[items.Length - 1]}" : null;
+        }
+
+        private static string Yandex(Uri uri)
+        {
+            var items = uri.GetComponents(UriComponents.Path, UriFormat.Unescaped).Split('/');
+            var albumKeyword
+                = items.Skip(0).FirstOrDefault();
+            var albumId
+                = items.Skip(1).FirstOrDefault();
+            var trackKeyword
+                = items.Skip(2).FirstOrDefault();
+            var trackId
+                = items.Skip(3).FirstOrDefault();
+
+            if (albumKeyword != "album" || albumId == null || trackKeyword != "track" || trackId == null)
+            {
+                return null;
+            }
+
+            return $"https://music.yandex.ru/iframe/#track/{trackId}/{albumId}/";
+        }
+        #endregion
     }
 }

src/Markdig/Extensions/MediaLinks/MediaOptions.cs

@@ -16,6 +16,7 @@ namespace Markdig.Extensions.MediaLinks
         {
             Width = "500";
             Height = "281";
+            Class = "";
             ExtensionToMimeType = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
             {
                 {".3gp", "video/3gpp"},
@@ -68,6 +69,7 @@ namespace Markdig.Extensions.MediaLinks
                 {".wma", "audio/x-ms-wma"},
                 {".wax", "audio/x-ms-wax"},
                 {".mid", "audio/midi"},
+                {".mp3", "audio/mpeg"},
                 {".mpga", "audio/mpeg"},
                 {".mp4a", "audio/mp4"},
                 {".ecelp4800", "audio/vnd.nuera.ecelp4800"},
@@ -86,6 +88,8 @@ namespace Markdig.Extensions.MediaLinks
 
         public string Height { get; set; }
 
+        public string Class { get; set; }
+
         public Dictionary<string, string> ExtensionToMimeType { get; }
     }
-}
+}

src/Markdig/Extensions/TextRenderer/ConfigureNewLineExtension.cs

@@ -0,0 +1,34 @@
+using Markdig.Renderers;
+
+namespace Markdig.Extensions.TextRenderer
+{
+    /// <summary>
+    /// Extension that allows setting line-endings for any IMarkdownRenderer
+    /// that inherits from <see cref="Markdig.Renderers.TextRendererBase"/>
+    /// </summary>
+    /// <seealso cref="Markdig.IMarkdownExtension" />
+    public class ConfigureNewLineExtension : IMarkdownExtension
+    {
+        private readonly string newLine;
+
+        public ConfigureNewLineExtension(string newLine)
+        {
+            this.newLine = newLine;
+        }
+
+        public void Setup(MarkdownPipelineBuilder pipeline)
+        {
+        }
+
+        public void Setup(MarkdownPipeline pipeline, IMarkdownRenderer renderer)
+        {
+            var textRenderer = renderer as TextRendererBase;
+            if (textRenderer == null)
+            {
+                return;
+            }
+
+            textRenderer.Writer.NewLine = newLine;
+        }
+    }
+}

src/Markdig/Helpers/CharHelper.cs

@@ -21,7 +21,7 @@ namespace Markdig.Helpers
         public const string ZeroSafeString = "\uFFFD";
 
         // We don't support LCDM
-        private static IDictionary<char, int> romanMap = new Dictionary<char, int> { { 'I', 1 }, { 'V', 5 }, { 'X', 10 } };
+        private static readonly Dictionary<char, int> romanMap = new Dictionary<char, int> { { 'I', 1 }, { 'V', 5 }, { 'X', 10 } };
 
         private static readonly char[] punctuationExceptions = { '−', '-', '†', '‡' };
 

src/Markdig/Markdig.csproj

@@ -1,13 +1,13 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <Description>A fast, powerfull, CommonMark compliant, extensible Markdown processor for .NET with 20+ builtin extensions (pipetables, footnotes, definition lists... etc.)</Description>
+    <Description>A fast, powerful, CommonMark compliant, extensible Markdown processor for .NET with 20+ builtin extensions (pipetables, footnotes, definition lists... etc.)</Description>
     <Copyright>Alexandre Mutel</Copyright>
     <AssemblyTitle>Markdig</AssemblyTitle>
     <NeutralLanguage>en-US</NeutralLanguage>
-    <VersionPrefix>0.14.8</VersionPrefix>
+    <VersionPrefix>0.15.2</VersionPrefix>
     <Authors>Alexandre Mutel</Authors>
-    <TargetFrameworks>net35;net40;portable40-net40+sl5+win8+wp8+wpa81;netstandard1.1;uap10.0</TargetFrameworks>
+    <TargetFrameworks>net35;net40;portable40-net40+sl5+win8+wp8+wpa81;netstandard1.1;netstandard2.0;uap10.0</TargetFrameworks>
     <AssemblyName>Markdig</AssemblyName>
     <PackageId>Markdig</PackageId>
     <PackageId Condition="'$(SignAssembly)' == 'true'">Markdig.Signed</PackageId>
@@ -51,6 +51,10 @@
     <DefineConstants>$(DefineConstants);NETSTANDARD_11;SUPPORT_UNSAFE</DefineConstants>
   </PropertyGroup>
 
+  <PropertyGroup Condition=" '$(TargetFramework)' == 'netstandard2.0' ">
+    <DefineConstants>$(DefineConstants);SUPPORT_FIXED_STRING;SUPPORT_UNSAFE</DefineConstants>
+  </PropertyGroup>
+  
   <PropertyGroup Condition=" '$(TargetFramework)' == 'uap10.0' ">
     <TargetPlatformIdentifier>UAP</TargetPlatformIdentifier>
     <TargetPlatformVersion Condition="'$(TargetPlatformVersion)' == ''">10.0.10240.0</TargetPlatformVersion>

src/Markdig/MarkdownExtensions.cs

@@ -29,6 +29,7 @@ using Markdig.Extensions.SmartyPants;
 using Markdig.Extensions.NonAsciiNoEscape;
 using Markdig.Extensions.Tables;
 using Markdig.Extensions.TaskLists;
+using Markdig.Extensions.TextRenderer;
 using Markdig.Extensions.Yaml;
 using Markdig.Parsers;
 using Markdig.Parsers.Inlines;
@@ -51,6 +52,19 @@ namespace Markdig
             return pipeline;
         }
 
+        /// <summary>
+        /// Adds the specified extension instance to the extensions collection.
+        /// </summary>
+        /// <param name="pipeline">The pipeline.</param>
+        /// <param name="extension">The instance of the extension to be added.</param>
+        /// <typeparam name="TExtension">The type of the extension.</typeparam>
+        /// <returns>The modified pipeline</returns>
+        public static MarkdownPipelineBuilder Use<TExtension>(this MarkdownPipelineBuilder pipeline, TExtension extension) where TExtension : class, IMarkdownExtension
+        {
+            pipeline.Extensions.AddIfNotAlready(extension);
+            return pipeline;
+        }
+
         /// <summary>
         /// Uses all extensions except the BootStrap, Emoji, SmartyPants and soft line as hard line breaks extensions.
         /// </summary>
@@ -575,5 +589,17 @@ namespace Markdig
             }
             return pipeline;
         }
+
+        /// <summary>
+        /// Configures the string to be used for line-endings, when writing.
+        /// </summary>
+        /// <param name="pipeline">The pipeline.</param>
+        /// <param name="newLine">The string to be used for line-endings.</param>
+        /// <returns>The modified pipeline</returns>
+        public static MarkdownPipelineBuilder ConfigureNewLine(this MarkdownPipelineBuilder pipeline, string newLine)
+        {
+            pipeline.Use(new ConfigureNewLineExtension(newLine));
+            return pipeline;
+        }
     }
 }

src/Markdig/Parsers/BlockProcessor.cs

@@ -1,4 +1,4 @@
-// Copyright (c) Alexandre Mutel. All rights reserved.
+// Copyright (c) Alexandre Mutel. All rights reserved.
 // This file is licensed under the BSD-Clause 2 license. 
 // See the license.txt file in the project root for more information.
 using System;
@@ -162,6 +162,21 @@ namespace Markdig.Parsers
         /// </summary>
         private bool ContinueProcessingLine { get; set; }
 
+        /// <summary>
+        /// Get the current Container that is currently opened
+        /// </summary>
+        /// <returns>The current Container that is currently opened</returns>
+        public ContainerBlock GetCurrentContainerOpened()
+        {
+            var container = CurrentContainer;
+            while (container != null && !container.IsOpen)
+            {
+                container = container.Parent;
+            }
+
+            return container;
+        }
+
         /// <summary>
         /// Returns the next character in the line being processed. Update <see cref="Start"/> and <see cref="Column"/>.
         /// </summary>

src/Markdig/Renderers/HtmlRenderer.cs

@@ -75,6 +75,16 @@ namespace Markdig.Renderers
 
         public bool UseNonAsciiNoEscape { get; set; }
 
+        /// <summary>
+        /// Gets a value to use as the base url for all relative links
+        /// </summary>
+        public Uri BaseUrl { get; set; }
+
+        /// <summary>
+        /// Allows links to be rewritten
+        /// </summary>
+        public Func<string,string> LinkRewriter { get; set; }
+
         /// <summary>
         /// Writes the content escaped for HTML.
         /// </summary>
@@ -192,6 +202,16 @@ namespace Markdig.Renderers
             if (content == null)
                 return this;
 
+            if (BaseUrl != null && !Uri.TryCreate(content, UriKind.Absolute, out Uri _))
+            {
+                content = new Uri(BaseUrl, content).AbsoluteUri;
+            }
+
+            if (LinkRewriter != null)
+            {
+                content = LinkRewriter(content);
+            }
+
             int previousPosition = 0;
             int length = content.Length;
 

src/Markdig/Renderers/Normalize/NormalizeOptions.cs

@@ -17,6 +17,7 @@ namespace Markdig.Renderers.Normalize
             EmptyLineAfterCodeBlock = true;
             EmptyLineAfterHeading = true;
             EmptyLineAfterThematicBreak = true;
+            ExpandAutoLinks = true;
             ListItemCharacter = null;
         }
 
@@ -44,5 +45,10 @@ namespace Markdig.Renderers.Normalize
         /// The bullet character used for list items. Default is <c>null</c> leaving the original bullet character as-is.
         /// </summary>
         public char? ListItemCharacter { get; set; }
+
+        /// <summary>
+        /// Expands AutoLinks to the normal inline representation. Default is <c>true</c>
+        /// </summary>
+        public bool ExpandAutoLinks { get; set; }
     }
 }

src/Markdig/Syntax/Inlines/LinkInline.cs

@@ -69,6 +69,11 @@ namespace Markdig.Syntax.Inlines
         /// </summary>
         public bool IsShortcut { get; set; }
 
+        /// <summary>
+        /// Gets or sets a boolean indicating whether the inline link was parsed using markdown syntax or was automatic recognized.
+        /// </summary>
+        public bool IsAutoLink { get; set; }
+
         /// <summary>
         /// Gets or sets the reference this link is attached to. May be null.
         /// </summary>