Bump version to 0.7.2

Bugfix colspan for grid tables

img/markdig.svg

@@ -0,0 +1,131 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   width="192"
+   height="192"
+   viewBox="0 0 192 192"
+   id="svg2"
+   version="1.1"
+   inkscape:version="0.91 r13725"
+   sodipodi:docname="markdig.svg"
+   inkscape:export-filename="C:\Code\lunet-io\markdig\markdig.png"
+   inkscape:export-xdpi="93.400002"
+   inkscape:export-ydpi="93.400002">
+  <defs
+     id="defs4" />
+  <sodipodi:namedview
+     id="base"
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1.0"
+     inkscape:pageopacity="0.0"
+     inkscape:pageshadow="2"
+     inkscape:zoom="4.4374889"
+     inkscape:cx="174.14769"
+     inkscape:cy="93.189838"
+     inkscape:document-units="px"
+     inkscape:current-layer="layer1"
+     showgrid="false"
+     inkscape:window-width="2560"
+     inkscape:window-height="1377"
+     inkscape:window-x="-8"
+     inkscape:window-y="-8"
+     inkscape:window-maximized="1"
+     units="px" />
+  <metadata
+     id="metadata7">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+        <dc:title></dc:title>
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <g
+     inkscape:label="Layer 1"
+     inkscape:groupmode="layer"
+     id="layer1"
+     style="display:inline"
+     transform="translate(0,-860.36216)">
+    <path
+       style="fill:#000000"
+       d="M 75.009766 60.486328 L 34.648438 122.74414 C 33.793918 123.59769 37.647081 134.96384 37.052734 136.09766 L 4.0234375 177.69727 C 2.4142291 180.39677 3.2900484 182.21846 4.8730469 183.84766 C 5.9214414 184.93636 6.6591287 186.06887 8.3828125 185.67188 C 9.0750612 185.50987 10.104893 185.27338 10.875 184.76758 L 52.806641 151.81445 C 53.912466 151.23195 64.44071 154.77813 65.289062 153.92383 L 126.45312 111.46875 L 75.009766 60.486328 z M 89.632812 84.769531 L 103.77539 98.912109 L 79.027344 123.66016 L 86.238281 130.87109 L 48.621094 139.92383 L 57.435547 102.30859 L 64.884766 109.51758 L 89.632812 84.769531 z "
+       transform="translate(0,860.36216)"
+       id="path4140" />
+    <path
+       style="fill:#000000;fill-opacity:1"
+       d="m 111.18463,862.06984 c -1.98231,0 -3.96282,0.78454 -5.54759,2.38445 L 88.200894,881.94537 75.123368,868.82653 c -3.169466,-3.18017 -7.92567,-3.18017 -11.095213,0 -3.169466,3.18017 -3.169466,7.95108 0,11.13109 l 13.077526,13.11885 -11.095212,10.73223 82.031621,81.49227 11.09525,-11.13109 13.87084,13.51554 c 1.57915,1.59105 3.56724,2.38445 5.54759,2.38445 1.98231,0 3.96285,-0.78453 5.54762,-2.38445 3.16947,-3.18017 3.16947,-7.95111 0,-11.13109 l -13.87083,-13.11884 17.43611,-17.09442 c 1.17983,-1.59105 1.98231,-3.5788 1.98231,-5.96329 0,-1.98351 -0.79863,-3.97554 -2.37816,-5.56446 l -70.54053,-70.35856 c -1.57914,-1.59105 -3.56724,-2.38446 -5.54758,-2.38446 z m 15.86949,20.75826 9.50139,9.5291 -4.04453,23.11372 23.04691,-4.05619 9.50138,9.5291 -36.8437,36.95052 -9.50135,-9.5291 21.13082,-21.19197 -23.04672,4.05619 4.04453,-23.11396 -21.131009,21.19198 -9.501383,-9.5291 36.843662,-36.95048 z"
+       id="path4142"
+       inkscape:connector-curvature="0" />
+    <rect
+       id="rect4168"
+       mask="url(#a)"
+       ry="0"
+       height="0"
+       width="0"
+       x="141.51523"
+       y="364.10403" />
+    <rect
+       id="rect4184"
+       mask="url(#a)"
+       ry="0"
+       height="0"
+       width="0"
+       x="96.108383"
+       y="352.01443" />
+    <rect
+       id="rect4200"
+       mask="url(#a)"
+       ry="2.1886277"
+       height="0.14590852"
+       width="0.17464182"
+       x="87.014519"
+       y="276.38696" />
+    <flowRoot
+       xml:space="preserve"
+       id="flowRoot4797"
+       style="font-style:normal;font-weight:normal;font-size:40px;line-height:125%;font-family:sans-serif;letter-spacing:0px;word-spacing:0px;fill:#000000;fill-opacity:1;stroke:none;stroke-width:1px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
+       transform="matrix(0.1746417,0,0,0.1459084,499.69318,366.39614)"><flowRegion
+         id="flowRegion4799"><rect
+           id="rect4801"
+           width="972.27185"
+           height="618.71844"
+           x="959.01355"
+           y="-976.15039" /></flowRegion><flowPara
+         id="flowPara4803" /></flowRoot>    <g
+       id="g4833"
+       transform="matrix(0.09510056,0,0,0.09061765,496.09965,368.83934)">
+      <rect
+         id="rect4823"
+         height="1"
+         width="1"
+         x="0"
+         y="0"
+         style="fill:#ffffff" />
+    </g>
+    <path
+       inkscape:connector-curvature="0"
+       id="path4886"
+       d="m 111.18463,862.06984 c -1.98231,0 -3.96282,0.78454 -5.54759,2.38445 L 88.200894,881.94537 75.123368,868.82653 c -3.169466,-3.18017 -7.92567,-3.18017 -11.095213,0 -3.169466,3.18017 -3.169466,7.95108 0,11.13109 l 13.077526,13.11885 -11.095212,10.73223 82.031621,81.49227 11.09525,-11.13109 13.87084,13.51554 c 1.57915,1.59105 3.56724,2.38445 5.54759,2.38445 1.98231,0 3.96285,-0.78453 5.54762,-2.38445 3.16947,-3.18017 3.16947,-7.95111 0,-11.13109 l -13.87083,-13.11884 17.43611,-17.09442 c 1.17983,-1.59105 1.98231,-3.5788 1.98231,-5.96329 0,-1.98351 -0.79863,-3.97554 -2.37816,-5.56446 l -70.54053,-70.35856 c -1.57914,-1.59105 -3.56724,-2.38446 -5.54758,-2.38446 z m 15.86949,20.75826 9.50139,9.5291 -4.04453,23.11372 23.04691,-4.05619 9.50138,9.5291 -36.8437,36.95052 -9.50135,-9.5291 21.13082,-21.19197 -23.04672,4.05619 4.04453,-23.11396 -21.131009,21.19198 -9.501383,-9.5291 36.843662,-36.95048 z"
+       style="fill:#000000;fill-opacity:1" />
+    <g
+       transform="translate(234.63786,787.55486)"
+       id="g4170" />
+    <path
+       id="path4225"
+       transform="translate(0,860.36216)"
+       d="M 75.009766 60.486328 L 34.648438 122.74414 C 33.793918 123.59769 37.647081 134.96384 37.052734 136.09766 L 4.0234375 177.69727 C 2.4142291 180.39677 3.2900484 182.21846 4.8730469 183.84766 C 5.9214414 184.93636 6.6591287 186.06887 8.3828125 185.67188 C 9.0750612 185.50987 10.104893 185.27338 10.875 184.76758 L 52.806641 151.81445 C 53.912466 151.23195 64.44071 154.77813 65.289062 153.92383 L 126.45312 111.46875 L 75.009766 60.486328 z M 89.632812 84.769531 L 103.77539 98.912109 L 79.027344 123.66016 L 86.238281 130.87109 L 48.621094 139.92383 L 57.435547 102.30859 L 64.884766 109.51758 L 89.632812 84.769531 z "
+       style="fill:#000000" />
+  </g>
+</svg>

readme.md

@@ -1,20 +1,25 @@
 # Markdig [![Build status](https://ci.appveyor.com/api/projects/status/hk391x8jcskxt1u8?svg=true)](https://ci.appveyor.com/project/xoofx/markdig) [![NuGet](https://img.shields.io/nuget/v/Markdig.svg)](https://www.nuget.org/packages/Markdig/)
 
-Markdig is a fast, powerfull, [CommonMark](http://commonmark.org/) compliant, extensible Markdown processor for .NET.
+<img align="right" width="160px" height="160px" src="img/markdig.png">
+
+Markdig is a fast, powerful, [CommonMark](http://commonmark.org/) compliant, extensible Markdown processor for .NET.
 
 > NOTE: The repository is under construction. There will be a dedicated website and proper documentation at some point!
 
+You can **try Markdig online** and compare it to other implementations on [babelmark3](https://babelmark.github.io/?text=Hello+**Markdig**!)
+
 ## Features
 
-- **Very fast parser** (no-regexp), very lightweight in terms of GC pressure. See benchmarks
-- **Abstract Syntax Tree**
+- **Very fast parser and html renderer** (no-regexp), very lightweight in terms of GC pressure. See benchmarks
+- **Abstract Syntax Tree** with precise source code location for syntax tree, useful when building a Markdown editor.
+  - Checkout [MarkdownEditor for Visual Studio](https://visualstudiogallery.msdn.microsoft.com/eaab33c3-437b-4918-8354-872dfe5d1bfe) powered by Markdig!
 - Converter to **HTML**
 - Passing more than **600+ tests** from the latest [CommonMark specs](http://spec.commonmark.org/)
 - Includes all the core elements of CommonMark:
-  - including GFM fenced code blocks. 
+  - including **GFM fenced code blocks**.  
 - **Extensible** architecture
   - Even the core Markdown/CommonMark parsing is pluggable, so it allows to disable builtin Markdown/Commonmark parsing (e.g [Disable HTML parsing](https://github.com/lunet-io/markdig/blob/7964bd0160d4c18e4155127a4c863d61ebd8944a/src/Markdig/MarkdownExtensions.cs#L306)) or change behaviour (e.g change matching `#` of a headers with `@`)   
-- Built-in with **18+ extensions**, including:
+- Built-in with **20+ extensions**, including:
   - 2 kind of tables:
     - **Pipe tables** (inspired from Github tables and [PanDoc - Pipe Tables](http://pandoc.org/README.html#extension-pipe_tables))
     - **Grid tables** (inspired from [Pandoc - Grid Tables](http://pandoc.org/README.html#extension-grid_tables)) 
@@ -28,6 +33,7 @@ Markdig is a fast, powerfull, [CommonMark](http://commonmark.org/) compliant, ex
   - **Definition lists** (inspired from [PHP Markdown Extra - Definitions Lists](https://michelf.ca/projects/php-markdown/extra/#def-list))
   - **Footnotes** (inspired from [PHP Markdown Extra - Footnotes](https://michelf.ca/projects/php-markdown/extra/#footnotes))
   - **Auto-identifiers** for headings (similar to [Pandoc - Auto Identifiers](http://pandoc.org/README.html#extension-auto_identifiers))
+  - **Task Lists** inspired from [Github Task lists](https://github.com/blog/1375-task-lists-in-gfm-issues-pulls-comments).
   - **Extra bullet lists**, supporting alpha bullet `a.` `b.` and roman bullet (`i`, `ii`...etc.)
   - **Media support** for media url (youtube, vimeo, mp4...etc.) (inspired from this [CommonMark discussion](https://talk.commonmark.org/t/embedded-audio-and-video/441))
   - **Abbreviations** (inspired from [PHP Markdown Extra - Abbreviations](https://michelf.ca/projects/php-markdown/extra/#abbr))
@@ -42,6 +48,13 @@ Markdig is a fast, powerfull, [CommonMark](http://commonmark.org/) compliant, ex
   - **Bootstrap** class (to output bootstrap class)
 - Compatible with .NET 3.5, 4.0+ and .NET Core (`netstandard1.1+`)
 	
+## Documentation
+
+> The repository is under construction. There will be a dedicated website and proper documentation at some point!
+
+In the meantime, you can have a "behind the scene" article about Markdig in my blog post ["Implementing a Markdown Engine for .NET"](http://xoofx.com/blog/2016/06/13/implementing-a-markdown-processor-for-dotnet/)
+
+
 ## Download
 
 Markdig is available as a NuGet package: [![NuGet](https://img.shields.io/nuget/v/Markdig.svg)](https://www.nuget.org/packages/Markdig/)
@@ -67,6 +80,10 @@ var result = Markdown.ToHtml("This is a text with some *emphasis*", pipeline);
 
 You can have a look at the [MarkdownExtensions](https://github.com/lunet-io/markdig/blob/master/src/Markdig/MarkdownExtensions.cs) that describes all actionable extensions (by modifying the MarkdownPipeline)
 
+## Build
+
+In order to build Markdig, you need to install [.NET Core RTM](https://www.microsoft.com/net/core)
+
 ## License
 
 This software is released under the [BSD-Clause 2 license](https://github.com/lunet-io/markdig/blob/master/license.txt).
@@ -76,24 +93,44 @@ This software is released under the [BSD-Clause 2 license](https://github.com/lu
 
 This is an early preview of the benchmarking against various implementations:
 
-- Markdig: itself
-- CommonMarkCpp: [cmark](https://github.com/jgm/cmark), Reference C implementation of CommonMark, no support for extensions
-- [CommonMark.NET](https://github.com/Knagis/CommonMark.NET): CommonMark implementation for .NET, no support for extensions, port of cmark
-  - [CommonMarkNet (devel)](https://github.com/AMDL/CommonMark.NET/tree/pipe-tables): An evolution of CommonMark.NET, supports extensions, not released yet
-- [MarkdownDeep](https://github.com/toptensoftware/markdowndeep) another .NET implementation
-- [MarkdownSharp](https://github.com/Kiri-rin/markdownsharp): Open source C# implementation of Markdown processor, as featured on Stack Overflow, regexp based.
-- [Moonshine](https://github.com/brandonc/moonshine): popular C Markdown processor
+**C implementations**:
 
-Markdig is roughly x100 times faster than MarkdownSharp and extremelly competitive to other implems (that are not feature wise comparable) 
+- [cmark](https://github.com/jgm/cmark) (version: 0.25.0): Reference C implementation of CommonMark, no support for extensions
+- [Moonshine](https://github.com/brandonc/moonshine) (version: : popular C Markdown processor
 
-Performance in x86:
+**.NET implementations**:
+
+- [Markdig](https://github.com/lunet-io/markdig) (version: 0.5.x): itself
+- [CommonMark.NET(master)](https://github.com/Knagis/CommonMark.NET) (version: 0.11.0): CommonMark implementation for .NET, no support for extensions, port of cmark
+  - [CommonMark.NET(pipe_tables)](https://github.com/AMDL/CommonMark.NET/tree/pipe-tables): An evolution of CommonMark.NET, supports extensions, not released yet
+- [MarkdownDeep](https://github.com/toptensoftware/markdowndeep) (version: 1.5.0): another .NET implementation
+- [MarkdownSharp](https://github.com/Kiri-rin/markdownsharp) (version: 1.13.0): Open source C# implementation of Markdown processor, as featured on Stack Overflow, regexp based.
+- [Marked.NET](https://github.com/T-Alex/MarkedNet) (version: 1.0.5) port of original [marked.js](https://github.com/chjj/marked) project
+- [Microsoft.DocAsCode.MarkdownLite](https://github.com/dotnet/docfx/tree/dev/src/Microsoft.DocAsCode.MarkdownLite) (version: 2.0.1) used by the [docfx](https://github.com/dotnet/docfx) project
+
+**JavaScript/V8 implementations**:
+
+- [Strike.V8](https://github.com/SimonCropp/Strike) (version: 1.5.0)  [marked.js](https://github.com/chjj/marked) running in Google V8 (not .NET based)
+
+### Analysis of the results:
+
+- Markdig is roughly **x100 times faster than MarkdownSharp**, **30x times faster than docfx**
+- **Among the best in CPU**, Extremely competitive and often faster than other implementations (not feature wise equivalent) 
+- **15% to 30% less allocations** and GC pressure
+
+Because Marked.NET,  MarkdownSharp and DocAsCode.MarkdownLite are way too slow, they are not included in the following charts:
+
+![BenchMark CPU Time](img/BenchmarkCPU.png)
+
+![BenchMark Memory](img/BenchmarkMemory.png)
+
+
+### Performance for x86:
 
 ```
-// * Summary *
-
-BenchmarkDotNet-Dev=v0.9.6.0+
+BenchmarkDotNet-Dev=v0.9.7.0+
 OS=Microsoft Windows NT 6.2.9200.0
-Processor=Intel(R) Core(TM) i7-4770 CPU @ 3.40GHz, ProcessorCount=8
+Processor=Intel(R) Core(TM) i7-4770 CPU 3.40GHz, ProcessorCount=8
 Frequency=3319351 ticks, Resolution=301.2637 ns, Timer=TSC
 HostCLR=MS.NET 4.0.30319.42000, Arch=32-bit RELEASE
 JitModules=clrjit-v4.6.1080.0
@@ -101,26 +138,23 @@ JitModules=clrjit-v4.6.1080.0
 Type=Program  Mode=SingleRun  LaunchCount=2
 WarmupCount=2  TargetCount=10
 
-               Method |    Median |    StdDev |  Gen 0 | Gen 1 |  Gen 2 | Bytes Allocated/Op |
---------------------- |---------- |---------- |------- |------ |------- |------------------- |
-          TestMarkdig | 5.4870 ms | 0.0158 ms | 193.00 | 12.00 |  84.00 |       1,425,192.72 |
-    TestCommonMarkCpp | 4.0134 ms | 0.1008 ms |      - |     - | 180.00 |         454,859.74 |
-    TestCommonMarkNet | 4.6139 ms | 0.0581 ms | 193.00 | 12.00 |  84.00 |       1,406,367.27 |
- TestCommonMarkNetNew | 5.5327 ms | 0.0461 ms | 193.00 | 96.00 |  84.00 |       1,738,465.42 |
-     TestMarkdownDeep | 7.5910 ms | 0.1006 ms | 205.00 | 96.00 |  84.00 |       1,758,383.79 |
-        TestMoonshine | 5.8843 ms | 0.1758 ms |      - |     - | 215.00 |         565,000.73 |
-
-// * Diagnostic Output - MemoryDiagnoser *
-
-
-// ***** BenchmarkRunner: End *****
+                     Method |      Median |    StdDev |Scaled |  Gen 0 | Gen 1|    Gen 2|Bytes Allocated/Op |
+--------------------------- |------------ |---------- |------ | ------ |------|---------|------------------ |
+                    Markdig |   5.5316 ms | 0.0372 ms |  0.71 |   56.00| 21.00|    49.00|      1,285,917.31 |
+     CommonMark.NET(master) |   4.7035 ms | 0.0422 ms |  0.60 |  113.00|  7.00|    49.00|      1,502,404.60 |
+CommonMark.NET(pipe_tables) |   5.6164 ms | 0.0298 ms |  0.72 |  111.00| 56.00|    49.00|      1,863,128.13 |
+               MarkdownDeep |   7.8193 ms | 0.0334 ms |  1.00 |  120.00| 56.00|    49.00|      1,884,854.85 |
+                      cmark |   4.2698 ms | 0.1526 ms |  0.55 |       -|     -|        -|                NA |
+                  Moonshine |   6.0929 ms | 0.1053 ms |  1.28 |       -|     -|        -|                NA |
+                  Strike.V8 |  10.5895 ms | 0.0492 ms |  1.35 |       -|     -|        -|                NA |
+                 Marked.NET | 207.3169 ms | 5.2628 ms | 26.51 |    0.00|  0.00|     0.00|    303,125,228.65 |
+              MarkdownSharp | 675.0185 ms | 2.8447 ms | 86.32 |   40.00| 27.00|    41.00|      2,413,394.17 |
+Microsoft DocfxMarkdownLite | 166.3357 ms | 0.4529 ms | 21.27 |4,452.00|948.00|11,167.00|    180,218,359.60 |
 ```
 
-Performance for x64:
+### Performance for x64:
 
 ```
-// * Summary *
-
 BenchmarkDotNet-Dev=v0.9.6.0+
 OS=Microsoft Windows NT 6.2.9200.0
 Processor=Intel(R) Core(TM) i7-4770 CPU @ 3.40GHz, ProcessorCount=8
@@ -133,15 +167,10 @@ WarmupCount=2  TargetCount=10
 
                Method |    Median |    StdDev |  Gen 0 |  Gen 1 | Gen 2 | Bytes Allocated/Op |
 --------------------- |---------- |---------- |------- |------- |------ |------------------- |
-          TestMarkdig | 5.9539 ms | 0.0495 ms | 157.00 |  96.00 | 84.00 |       1,767,834.52 |
-    TestCommonMarkNet | 4.3158 ms | 0.0161 ms | 157.00 |  96.00 | 84.00 |       1,747,432.06 |
- TestCommonMarkNetNew | 5.3421 ms | 0.0435 ms | 229.00 | 168.00 | 84.00 |       2,323,922.97 |
-     TestMarkdownDeep | 7.4750 ms | 0.0281 ms | 318.00 | 186.00 | 84.00 |       2,576,728.69 |
-
-// * Diagnostic Output - MemoryDiagnoser *
-
-
-// ***** BenchmarkRunner: End *****
+          TestMarkdig | 5.5276 ms | 0.0402 ms | 109.00 |  96.00 | 84.00 |       1,537,027.66 |
+    TestCommonMarkNet | 4.4661 ms | 0.1190 ms | 157.00 |  96.00 | 84.00 |       1,747,432.06 |
+ TestCommonMarkNetNew | 5.3151 ms | 0.0815 ms | 229.00 | 168.00 | 84.00 |       2,323,922.97 |
+     TestMarkdownDeep | 7.4076 ms | 0.0617 ms | 318.00 | 186.00 | 84.00 |       2,576,728.69 |
 ```
 
 ## Credits
@@ -150,7 +179,9 @@ Thanks to the fantastic work done by [John Mac Farlane](http://johnmacfarlane.ne
 
 This project would not have been possible without this huge foundation.
 
-Thanks also to the project [BenchmarkDotNet](https://github.com/PerfDotNet/BenchmarkDotNet) that makes benchmarking so easy to setup!  
+Thanks also to the project [BenchmarkDotNet](https://github.com/PerfDotNet/BenchmarkDotNet) that makes benchmarking so easy to setup!
+
+Some decoding part (e.g HTML [EntityHelper.cs](https://github.com/lunet-io/markdig/blob/master/src/Markdig/Helpers/EntityHelper.cs)) have been re-used from [CommonMark.NET](https://github.com/Knagis/CommonMark.NET)
 
 ## Author
 

src/Markdig.Tests/Markdig.Tests.csproj

@@ -24,6 +24,7 @@
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+    <Prefer32Bit>false</Prefer32Bit>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <PlatformTarget>AnyCPU</PlatformTarget>
@@ -59,8 +60,12 @@
       <DesignTime>True</DesignTime>
       <DependentUpon>Specs.tt</DependentUpon>
     </Compile>
+    <Compile Include="TestHtmlAttributes.cs" />
     <Compile Include="TestHtmlHelper.cs" />
+    <Compile Include="TestLineReader.cs" />
     <Compile Include="TestLinkHelper.cs" />
+    <Compile Include="TestPragmaLines.cs" />
+    <Compile Include="TestSourcePosition.cs" />
     <Compile Include="TestStringSliceList.cs" />
     <Compile Include="TestPlayParser.cs" />
     <Compile Include="TextAssert.cs" />
@@ -81,6 +86,8 @@
     <None Include="Specs\GridTableSpecs.md" />
     <None Include="Specs\HardlineBreakSpecs.md" />
     <None Include="Specs\BootstrapSpecs.md" />
+    <None Include="Specs\DiagramsSpecs.md" />
+    <None Include="Specs\TaskListSpecs.md" />
     <None Include="Specs\SmartyPantsSpecs.md" />
     <None Include="Specs\MediaSpecs.md" />
     <None Include="Specs\MathSpecs.md" />
@@ -95,6 +102,7 @@
   </ItemGroup>
   <ItemGroup>
     <Service Include="{508349B6-6B84-4DF5-91F0-309BEEBAD82D}" />
+    <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 

src/Markdig.Tests/Specs/DiagramsSpecs.md

@@ -0,0 +1,26 @@
+# Extensions
+
+Adds support for diagrams extension:
+
+## Mermaid diagrams
+ 
+Using a fenced code block with the `mermaid` language info will output a `<div class='mermaid'>` instead of a `pre/code` block:
+
+```````````````````````````````` example
+```mermaid
+graph TD;
+    A-->B;
+    A-->C;
+    B-->D;
+    C-->D;
+```
+.
+<div class="mermaid">graph TD;
+    A-->B;
+    A-->C;
+    B-->D;
+    C-->D;
+</div>
+````````````````````````````````
+
+TODO: Add other text diagram languages

src/Markdig.Tests/Specs/EmojiSpecs.md

@@ -11,3 +11,11 @@ This is a test with a :) and a :angry: smiley
 .
 <p>This is a test with a 😃 and a 😠 smiley</p>
 ````````````````````````````````
+
+An emoji needs to be preceded by a space and followed by a space:
+
+```````````````````````````````` example
+These are not:) an :)emoji with a:) x:angry:x
+.
+<p>These are not:) an :)emoji with a:) x:angry:x</p>
+````````````````````````````````

src/Markdig.Tests/Specs/FootnotesSpecs.md

@@ -61,3 +61,60 @@ multi-paragraph list items.<a href="#fnref:3" class="footnote-back-ref">&#8617;<
 </div>
 ````````````````````````````````
 
+Check with mulitple consecutive footnotes:
+
+```````````````````````````````` example
+Here is a footnote[^1]. And another one[^2]. And a third one[^3]. And a fourth[^4].
+
+[^1]: Footnote 1 text
+
+[^2]: Footnote 2 text
+
+a
+
+[^3]: Footnote 3 text
+
+[^4]: Footnote 4 text
+.
+<p>Here is a footnote<a id="fnref:1" href="#fn:1" class="footnote-ref"><sup>1</sup></a>. And another one<a id="fnref:2" href="#fn:2" class="footnote-ref"><sup>2</sup></a>. And a third one<a id="fnref:3" href="#fn:3" class="footnote-ref"><sup>3</sup></a>. And a fourth<a id="fnref:4" href="#fn:4" class="footnote-ref"><sup>4</sup></a>.</p>
+<p>a</p>
+<div class="footnotes">
+<hr />
+<ol>
+<li id="fn:1">
+<p>Footnote 1 text<a href="#fnref:1" class="footnote-back-ref">&#8617;</a></p></li>
+<li id="fn:2">
+<p>Footnote 2 text<a href="#fnref:2" class="footnote-back-ref">&#8617;</a></p></li>
+<li id="fn:3">
+<p>Footnote 3 text<a href="#fnref:3" class="footnote-back-ref">&#8617;</a></p></li>
+<li id="fn:4">
+<p>Footnote 4 text<a href="#fnref:4" class="footnote-back-ref">&#8617;</a></p></li>
+</ol>
+</div>
+````````````````````````````````
+
+Another test with consecutive footnotes without a blank line separator:
+
+```````````````````````````````` example
+Here is a footnote[^1]. And another one[^2]. And a third one[^3]. And a fourth[^4].
+
+[^1]: Footnote 1 text
+[^2]: Footnote 2 text
+[^3]: Footnote 3 text
+[^4]: Footnote 4 text
+.
+<p>Here is a footnote<a id="fnref:1" href="#fn:1" class="footnote-ref"><sup>1</sup></a>. And another one<a id="fnref:2" href="#fn:2" class="footnote-ref"><sup>2</sup></a>. And a third one<a id="fnref:3" href="#fn:3" class="footnote-ref"><sup>3</sup></a>. And a fourth<a id="fnref:4" href="#fn:4" class="footnote-ref"><sup>4</sup></a>.</p>
+<div class="footnotes">
+<hr />
+<ol>
+<li id="fn:1">
+<p>Footnote 1 text<a href="#fnref:1" class="footnote-back-ref">&#8617;</a></p></li>
+<li id="fn:2">
+<p>Footnote 2 text<a href="#fnref:2" class="footnote-back-ref">&#8617;</a></p></li>
+<li id="fn:3">
+<p>Footnote 3 text<a href="#fnref:3" class="footnote-back-ref">&#8617;</a></p></li>
+<li id="fn:4">
+<p>Footnote 4 text<a href="#fnref:4" class="footnote-back-ref">&#8617;</a></p></li>
+</ol>
+</div>
+````````````````````````````````

src/Markdig.Tests/Specs/GridTableSpecs.md

@@ -70,8 +70,8 @@ A regular row can continue a previous regular row when column separator `|` are
 +---------+---------+---------+
 | Col1    | Col2    | Col3    |
 | Col1a   | Col2a   | Col3a   |
-| Col12             | Col3b   |
-| Col123                      |
+| Col1b             | Col3b   |
+| Col1c                       |
 .
 <table>
 <col style="width:33.33%">
@@ -87,11 +87,11 @@ Col2a</td>
 Col3a</td>
 </tr>
 <tr>
-<td colspan="2">Col12</td>
-<td></td>
+<td colspan="2">Col1b</td>
+<td>Col3b</td>
 </tr>
 <tr>
-<td colspan="3">Col123</td>
+<td colspan="3">Col1c</td>
 </tr>
 </tbody>
 </table>

src/Markdig.Tests/Specs/PipeTableSpecs.md

@@ -38,18 +38,27 @@ a | b
 </table>
 ````````````````````````````````
 
-While the following would be considered as a plain paragraph with a list item:
+The following is also considered as a table, even if the second line starts like a list:
 
 ```````````````````````````````` example
 a | b
 - | -
 0 | 1
 .
-<p>a | b</p>
-<ul>
-<li>| -
-0 | 1</li>
-</ul>
+<table>
+<thead>
+<tr>
+<th>a</th>
+<th>b</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td>0</td>
+<td>1</td>
+</tr>
+</tbody>
+</table>
 ````````````````````````````````
 
 A pipe table with only one header row is allowed:
@@ -205,6 +214,76 @@ Column delimiters `|` at the very beginning of a line or just before a line endi
 </tbody>
 </table>
 ````````````````````````````````
+
+A pipe may be present at both the beginning/ending of each line:
+
+```````````````````````````````` example
+|a|b|
+|-|-|
+|0|1|
+.
+<table>
+<thead>
+<tr>
+<th>a</th>
+<th>b</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td>0</td>
+<td>1</td>
+</tr>
+</tbody>
+</table>
+````````````````````````````````
+
+Or may be ommitted on one side:
+
+```````````````````````````````` example
+a|b|
+-|-|
+0|1|
+.
+<table>
+<thead>
+<tr>
+<th>a</th>
+<th>b</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td>0</td>
+<td>1</td>
+</tr>
+</tbody>
+</table>
+````````````````````````````````
+
+```````````````````````````````` example
+|a|b
+|-|-
+|0|1
+.
+<table>
+<thead>
+<tr>
+<th>a</th>
+<th>b</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td>0</td>
+<td>1</td>
+</tr>
+</tbody>
+</table>
+````````````````````````````````
+
+
+
 Single column table can be declared with lines starting only by a column delimiter: 
 
 ```````````````````````````````` example
@@ -298,6 +377,31 @@ The text alignment can be changed by using the character `:` with the header col
 </table>
 ````````````````````````````````
 
+Test alignment with starting and ending pipes:
+
+```````````````````````````````` example
+| abc | def | ghi |
+|:---:|-----|----:|
+|  1  | 2   | 3   |
+.
+<table>
+<thead>
+<tr>
+<th style="text-align: center;">abc</th>
+<th>def</th>
+<th style="text-align: right;">ghi</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td style="text-align: center;">1</td>
+<td>2</td>
+<td style="text-align: right;">3</td>
+</tr>
+</tbody>
+</table>
+````````````````````````````````
+
 The following example shows a non matching header column separator:
  
 ```````````````````````````````` example

src/Markdig.Tests/Specs/SmartyPantsSpecs.md

@@ -83,29 +83,6 @@ They are' not matching 'quotes
 .
 <p>They are' not matching 'quotes</p>
 ````````````````````````````````
-
-Double quotes using ``` `` ``` are working if they match another `''` pair, and there is no other double quotes on the line (otherwise they would be parsed as a code span):
-
-```````````````````````````````` example
-This is ``a double quote''
-.
-<p>This is &ldquo;a double quote&rdquo;</p>
-````````````````````````````````
-
-```````````````````````````````` example
-This is ``a code span''`` 
-.
-<p>This is <code>a code span''</code></p>
-````````````````````````````````
-
-```````````````````````````````` example
-hello ``there```
-test
-.
-<p>hello &ldquo;there&rdquo;`
-test</p>
-````````````````````````````````
-
 An emphasis starting inside left/right quotes will span over the right quote:
 
 ```````````````````````````````` example
@@ -133,3 +110,36 @@ This is a en ellipsis...
 .
 <p>This is a en ellipsis&hellip;</p>
 ````````````````````````````````
+
+Check that a smartypants are not breaking pipetable parsing:
+
+```````````````````````````````` example
+a  | b
+-- | --
+0  | 1
+.
+<table>
+<thead>
+<tr>
+<th>a</th>
+<th>b</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td>0</td>
+<td>1</td>
+</tr>
+</tbody>
+</table>
+````````````````````````````````
+
+Check quotes and dash:
+
+```````````````````````````````` example
+A "quote" with a ---
+.
+<p>A &ldquo;quote&rdquo; with a &mdash;</p>
+````````````````````````````````
+
+

src/Markdig.Tests/Specs/Specs.tt

@@ -38,24 +38,27 @@ SOFTWARE.
 <#@ import namespace="System.CodeDom.Compiler" #>
 <#@ output extension=".cs" #><#
     var specFiles = new KeyValuePair<string, string>[] {
-		new KeyValuePair<string, string>("https://raw.githubusercontent.com/jgm/CommonMark/master/spec.txt", string.Empty),
-		new KeyValuePair<string, string>(Host.ResolvePath("PipeTableSpecs.md"), "pipetables"),
-		new KeyValuePair<string, string>(Host.ResolvePath("FootnotesSpecs.md"), "footnotes"),
-		new KeyValuePair<string, string>(Host.ResolvePath("GenericAttributesSpecs.md"), "attributes"),
-		new KeyValuePair<string, string>(Host.ResolvePath("EmphasisExtraSpecs.md"), "emphasisextra"),
-		new KeyValuePair<string, string>(Host.ResolvePath("HardlineBreakSpecs.md"), "hardlinebreak"),
-		new KeyValuePair<string, string>(Host.ResolvePath("GridTableSpecs.md"), "gridtables"),
-		new KeyValuePair<string, string>(Host.ResolvePath("CustomContainerSpecs.md"), "customcontainers+attributes"),
-		new KeyValuePair<string, string>(Host.ResolvePath("DefinitionListSpecs.md"), "definitionlists+attributes"),
-		new KeyValuePair<string, string>(Host.ResolvePath("EmojiSpecs.md"), "emojis"),
-		new KeyValuePair<string, string>(Host.ResolvePath("AbbreviationSpecs.md"), "abbreviations"),
-		new KeyValuePair<string, string>(Host.ResolvePath("ListExtraSpecs.md"), "listextra"),
-		new KeyValuePair<string, string>(Host.ResolvePath("FigureFooterAndCiteSpecs.md"), "figures+footers+cites"),
-		new KeyValuePair<string, string>(Host.ResolvePath("MathSpecs.md"), "math"),
+		// new KeyValuePair<string, string>("https://raw.githubusercontent.com/jgm/CommonMark/master/spec.txt", string.Empty),
+		new KeyValuePair<string, string>("https://raw.githubusercontent.com/jgm/CommonMark/91e045ca370258903ed138450373043a496ec64b/spec.txt", string.Empty), // 0.26 specs
+		new KeyValuePair<string, string>(Host.ResolvePath("PipeTableSpecs.md"), "pipetables|advanced"),
+		new KeyValuePair<string, string>(Host.ResolvePath("FootnotesSpecs.md"), "footnotes|advanced"),
+		new KeyValuePair<string, string>(Host.ResolvePath("GenericAttributesSpecs.md"), "attributes|advanced"),
+		new KeyValuePair<string, string>(Host.ResolvePath("EmphasisExtraSpecs.md"), "emphasisextras|advanced"),
+		new KeyValuePair<string, string>(Host.ResolvePath("HardlineBreakSpecs.md"), "hardlinebreak|advanced+hardlinebreak"),
+		new KeyValuePair<string, string>(Host.ResolvePath("GridTableSpecs.md"), "gridtables|advanced"),
+		new KeyValuePair<string, string>(Host.ResolvePath("CustomContainerSpecs.md"), "customcontainers+attributes|advanced"),
+		new KeyValuePair<string, string>(Host.ResolvePath("DefinitionListSpecs.md"), "definitionlists+attributes|advanced"),
+		new KeyValuePair<string, string>(Host.ResolvePath("EmojiSpecs.md"), "emojis|advanced+emojis"),
+		new KeyValuePair<string, string>(Host.ResolvePath("AbbreviationSpecs.md"), "abbreviations|advanced"),
+		new KeyValuePair<string, string>(Host.ResolvePath("ListExtraSpecs.md"), "listextras|advanced"),
+		new KeyValuePair<string, string>(Host.ResolvePath("FigureFooterAndCiteSpecs.md"), "figures+footers+citations|advanced"),
+		new KeyValuePair<string, string>(Host.ResolvePath("MathSpecs.md"), "mathematics|advanced"),
 		new KeyValuePair<string, string>(Host.ResolvePath("BootstrapSpecs.md"), "bootstrap+pipetables+figures+attributes"),
-		new KeyValuePair<string, string>(Host.ResolvePath("MediaSpecs.md"), "medias"),
-		new KeyValuePair<string, string>(Host.ResolvePath("SmartyPantsSpecs.md"), "smartypants"),
-		new KeyValuePair<string, string>(Host.ResolvePath("AutoIdentifierSpecs.md"), "autoidentifiers"),
+		new KeyValuePair<string, string>(Host.ResolvePath("MediaSpecs.md"), "medialinks|advanced+medialinks"),
+		new KeyValuePair<string, string>(Host.ResolvePath("SmartyPantsSpecs.md"), "pipetables+smartypants|advanced+smartypants"),   // Check with smartypants to make sure that it doesn't break pipetables
+		new KeyValuePair<string, string>(Host.ResolvePath("AutoIdentifierSpecs.md"), "autoidentifiers|advanced"),
+		new KeyValuePair<string, string>(Host.ResolvePath("TaskListSpecs.md"), "tasklists|advanced"),
+		new KeyValuePair<string, string>(Host.ResolvePath("DiagramsSpecs.md"), "diagrams|advanced"),
 	};
     var emptyLines = false;
     var displayEmptyLines = false;

src/Markdig.Tests/Specs/TaskListSpecs.md

@@ -0,0 +1,29 @@
+# Extensions
+
+Adds support for task lists:
+
+## TaskLists
+ 
+A task list item consist of `[ ]` or `[x]` or `[X]` inside a list item (ordered or unordered)
+
+```````````````````````````````` example
+- [ ] Item1
+- [x] Item2
+- [ ] Item3
+- Item4
+.
+<ul class="contains-task-list">
+<li class="task-list-item"><input disabled="disabled" type="checkbox" /> Item1</li>
+<li class="task-list-item"><input disabled="disabled" type="checkbox" checked="checked" /> Item2</li>
+<li class="task-list-item"><input disabled="disabled" type="checkbox" /> Item3</li>
+<li>Item4</li>
+</ul>
+````````````````````````````````
+
+A task is not recognized outside a list item:
+
+```````````````````````````````` example
+[ ] This is not a task list
+.
+<p>[ ] This is not a task list</p>
+````````````````````````````````

src/Markdig.Tests/TestHtmlAttributes.cs

@@ -0,0 +1,96 @@
+// 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.Html;
+using NUnit.Framework;
+using System.Collections.Generic;
+
+namespace Markdig.Tests
+{
+    [TestFixture()]
+    public class TestHtmlAttributes
+    {
+        [Test]
+        public void TestAddClass()
+        {
+            var attributes = new HtmlAttributes();
+            attributes.AddClass("test");
+            Assert.NotNull(attributes.Classes);
+            Assert.AreEqual(new List<string>() { "test" }, attributes.Classes);
+
+            attributes.AddClass("test");
+            Assert.AreEqual(1, attributes.Classes.Count);
+
+            attributes.AddClass("test1");
+            Assert.AreEqual(new List<string>() { "test", "test1" }, attributes.Classes);
+        }
+
+        [Test]
+        public void TestAddProperty()
+        {
+            var attributes = new HtmlAttributes();
+            attributes.AddProperty("key1", "1");
+            Assert.NotNull(attributes.Properties);
+            Assert.AreEqual(new List<KeyValuePair<string, string>>() { new KeyValuePair<string, string>("key1", "1") }, attributes.Properties);
+
+            attributes.AddPropertyIfNotExist("key1", "1");
+            Assert.NotNull(attributes.Properties);
+            Assert.AreEqual(new List<KeyValuePair<string, string>>() { new KeyValuePair<string, string>("key1", "1") }, attributes.Properties);
+
+            attributes.AddPropertyIfNotExist("key2", "2");
+            Assert.AreEqual(new List<KeyValuePair<string, string>>() { new KeyValuePair<string, string>("key1", "1"), new KeyValuePair<string, string>("key2", "2") }, attributes.Properties);
+        }
+
+        [Test]
+        public void TestCopyTo()
+        {
+            var from = new HtmlAttributes();
+            from.AddClass("test");
+            from.AddProperty("key1", "1");
+
+            var to = new HtmlAttributes();
+            from.CopyTo(to);
+
+            Assert.True(ReferenceEquals(from.Classes, to.Classes));
+            Assert.True(ReferenceEquals(from.Properties, to.Properties));
+
+            //          From: Classes      From: Properties     To: Classes     To: Properties
+            // test1:        null                null              null             null
+            from = new HtmlAttributes();
+            to = new HtmlAttributes();
+            from.CopyTo(to, false, false);
+            Assert.Null(to.Classes);
+            Assert.Null(to.Properties);
+
+            // test2:      ["test"]            ["key1", "1"]       null             null
+            from = new HtmlAttributes();
+            to = new HtmlAttributes();
+            from.AddClass("test");
+            from.AddProperty("key1", "1");
+            from.CopyTo(to, false, false);
+            Assert.AreEqual(new List<string>() { "test" }, to.Classes);
+            Assert.AreEqual(new List<KeyValuePair<string, string>>() { new KeyValuePair<string, string>("key1", "1")}, to.Properties);
+
+            // test3:        null                null            ["test"]       ["key1", "1"]       
+            from = new HtmlAttributes();
+            to = new HtmlAttributes();
+            to.AddClass("test");
+            to.AddProperty("key1", "1");
+            from.CopyTo(to, false, false);
+            Assert.AreEqual(new List<string>() { "test" }, to.Classes);
+            Assert.AreEqual(new List<KeyValuePair<string, string>>() { new KeyValuePair<string, string>("key1", "1") }, to.Properties);
+
+            // test4:      ["test1"]           ["key2", "2"]     ["test"]       ["key1", "1"]       
+            from = new HtmlAttributes();
+            to = new HtmlAttributes();
+            from.AddClass("test1");
+            from.AddProperty("key2", "2");
+            to.AddClass("test");
+            to.AddProperty("key1", "1");
+            from.CopyTo(to, false, false);
+            Assert.AreEqual(new List<string>() { "test", "test1" }, to.Classes);
+            Assert.AreEqual(new List<KeyValuePair<string, string>>() { new KeyValuePair<string, string>("key1", "1"), new KeyValuePair<string, string>("key2", "2") }, to.Properties);
+        }
+    }
+}

src/Markdig.Tests/TestLineReader.cs

@@ -0,0 +1,128 @@
+// 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.IO;
+using NUnit.Framework;
+using Markdig.Helpers;
+
+namespace Markdig.Tests
+{
+    /// <summary>
+    /// Test for <see cref="LineReader"/>.
+    /// </summary>
+    [TestFixture]
+    public class TestLineReader
+    {
+        [Test]
+        public void TestEmpty()
+        {
+            var lineReader = new LineReader("");
+            Assert.Null(lineReader.ReadLine()?.ToString());
+        }
+
+        [Test]
+        public void TestLinesOnlyLf()
+        {
+            var lineReader = new LineReader("\n\n\n");
+            Assert.AreEqual(string.Empty, lineReader.ReadLine()?.ToString());
+            Assert.AreEqual(1, lineReader.SourcePosition);
+            Assert.AreEqual(string.Empty, lineReader.ReadLine()?.ToString());
+            Assert.AreEqual(2, lineReader.SourcePosition);
+            Assert.AreEqual(string.Empty, lineReader.ReadLine()?.ToString());
+            Assert.Null(lineReader.ReadLine()?.ToString());
+        }
+
+        [Test]
+        public void TestLinesOnlyCr()
+        {
+            var lineReader = new LineReader("\r\r\r");
+            Assert.AreEqual(string.Empty, lineReader.ReadLine()?.ToString());
+            Assert.AreEqual(1, lineReader.SourcePosition);
+            Assert.AreEqual(string.Empty, lineReader.ReadLine()?.ToString());
+            Assert.AreEqual(2, lineReader.SourcePosition);
+            Assert.AreEqual(string.Empty, lineReader.ReadLine()?.ToString());
+            Assert.Null(lineReader.ReadLine()?.ToString());
+        }
+
+        [Test]
+        public void TestLinesOnlyCrLf()
+        {
+            var lineReader = new LineReader("\r\n\r\n\r\n");
+            Assert.AreEqual(string.Empty, lineReader.ReadLine()?.ToString());
+            Assert.AreEqual(2, lineReader.SourcePosition);
+            Assert.AreEqual(string.Empty, lineReader.ReadLine()?.ToString());
+            Assert.AreEqual(4, lineReader.SourcePosition);
+            Assert.AreEqual(string.Empty, lineReader.ReadLine()?.ToString());
+            Assert.Null(lineReader.ReadLine()?.ToString());
+        }
+
+        [Test]
+        public void TestNoEndOfLine()
+        {
+            var lineReader = new LineReader("123");
+            Assert.AreEqual("123", lineReader.ReadLine()?.ToString());
+            Assert.Null(lineReader.ReadLine()?.ToString());
+        }
+
+        [Test]
+        public void TestLf()
+        {
+            var lineReader = new LineReader("123\n");
+            Assert.AreEqual("123", lineReader.ReadLine()?.ToString());
+            Assert.AreEqual(4, lineReader.SourcePosition);
+            Assert.Null(lineReader.ReadLine()?.ToString());
+        }
+
+        [Test]
+        public void TestLf2()
+        {
+            // When limited == true, we limit the internal buffer exactly after the first new line char '\n'
+            var lineReader = new LineReader("123\n456");
+            Assert.AreEqual("123", lineReader.ReadLine()?.ToString());
+            Assert.AreEqual(4, lineReader.SourcePosition);
+            Assert.AreEqual("456", lineReader.ReadLine()?.ToString());
+            Assert.Null(lineReader.ReadLine()?.ToString());
+        }
+
+        [Test]
+        public void TestCr()
+        {
+            var lineReader = new LineReader("123\r");
+            Assert.AreEqual("123", lineReader.ReadLine()?.ToString());
+            Assert.AreEqual(4, lineReader.SourcePosition);
+            Assert.Null(lineReader.ReadLine()?.ToString());
+        }
+
+        [Test]
+        public void TestCr2()
+        {
+            var lineReader = new LineReader("123\r456");
+            Assert.AreEqual("123", lineReader.ReadLine()?.ToString());
+            Assert.AreEqual(4, lineReader.SourcePosition);
+            Assert.AreEqual("456", lineReader.ReadLine()?.ToString());
+            Assert.Null(lineReader.ReadLine()?.ToString());
+        }
+
+        [Test]
+        public void TestCrLf()
+        {
+            // When limited == true, we limit the internal buffer exactly after the first new line char '\r'
+            // and we check that we don't get a new line for `\n` 
+            var lineReader = new LineReader("123\r\n");
+            Assert.AreEqual("123", lineReader.ReadLine()?.ToString());
+            Assert.AreEqual(5, lineReader.SourcePosition);
+            Assert.Null(lineReader.ReadLine()?.ToString());
+        }
+
+        [Test]
+        public void TestCrLf2()
+        {
+            var lineReader = new LineReader("123\r\n456");
+            Assert.AreEqual("123", lineReader.ReadLine()?.ToString());
+            Assert.AreEqual(5, lineReader.SourcePosition);
+            Assert.AreEqual("456", lineReader.ReadLine()?.ToString());
+            Assert.Null(lineReader.ReadLine()?.ToString());
+        }
+    }
+}

src/Markdig.Tests/TestLinkHelper.cs

@@ -80,36 +80,52 @@ namespace Markdig.Tests
         [Test]
         public void TestUrlAndTitle()
         {
+            //                           0         1         2         3
+            //                           0123456789012345678901234567890123456789
             var text = new StringSlice(@"(http://google.com 'this is a title')ABC");
             string link;
             string title;
-            Assert.True(LinkHelper.TryParseInlineLink(ref text, out link, out title));
+            SourceSpan linkSpan;
+            SourceSpan titleSpan;
+            Assert.True(LinkHelper.TryParseInlineLink(ref text, out link, out title, out linkSpan, out titleSpan));
             Assert.AreEqual("http://google.com", link);
             Assert.AreEqual("this is a title", title);
+            Assert.AreEqual(new SourceSpan(1, 17), linkSpan);
+            Assert.AreEqual(new SourceSpan(19, 35), titleSpan);
             Assert.AreEqual('A', text.CurrentChar);
         }
 
         [Test]
         public void TestUrlAndTitleEmpty()
         {
+            //                           01234
             var text = new StringSlice(@"(<>)A");
             string link;
             string title;
-            Assert.True(LinkHelper.TryParseInlineLink(ref text, out link, out title));
+            SourceSpan linkSpan;
+            SourceSpan titleSpan;
+            Assert.True(LinkHelper.TryParseInlineLink(ref text, out link, out title, out linkSpan, out titleSpan));
             Assert.AreEqual(string.Empty, link);
             Assert.AreEqual(string.Empty, title);
+            Assert.AreEqual(new SourceSpan(1, 2), linkSpan);
+            Assert.AreEqual(SourceSpan.Empty, titleSpan);
             Assert.AreEqual('A', text.CurrentChar);
         }
 
         [Test]
         public void TestUrlAndTitleEmpty2()
         {
+            //                           012345
             var text = new StringSlice(@"( <> )A");
             string link;
             string title;
-            Assert.True(LinkHelper.TryParseInlineLink(ref text, out link, out title));
+            SourceSpan linkSpan;
+            SourceSpan titleSpan;
+            Assert.True(LinkHelper.TryParseInlineLink(ref text, out link, out title, out linkSpan, out titleSpan));
             Assert.AreEqual(string.Empty, link);
             Assert.AreEqual(string.Empty, title);
+            Assert.AreEqual(new SourceSpan(2, 3), linkSpan);
+            Assert.AreEqual(SourceSpan.Empty, titleSpan);
             Assert.AreEqual('A', text.CurrentChar);
         }
 
@@ -117,12 +133,18 @@ namespace Markdig.Tests
         [Test]
         public void TestUrlEmptyWithTitleWithMultipleSpaces()
         {
+            //                           0         1         2
+            //                           0123456789012345678901234567
             var text = new StringSlice(@"(   <>      'toto'       )A");
             string link;
             string title;
-            Assert.True(LinkHelper.TryParseInlineLink(ref text, out link, out title));
+            SourceSpan linkSpan;
+            SourceSpan titleSpan;
+            Assert.True(LinkHelper.TryParseInlineLink(ref text, out link, out title, out linkSpan, out titleSpan));
             Assert.AreEqual(string.Empty, link);
             Assert.AreEqual("toto", title);
+            Assert.AreEqual(new SourceSpan(4, 5), linkSpan);
+            Assert.AreEqual(new SourceSpan(12, 17), titleSpan);
             Assert.AreEqual('A', text.CurrentChar);
         }
 
@@ -132,50 +154,67 @@ namespace Markdig.Tests
             var text = new StringSlice(@"()A");
             string link;
             string title;
-            Assert.True(LinkHelper.TryParseInlineLink(ref text, out link, out title));
+            SourceSpan linkSpan;
+            SourceSpan titleSpan;
+            Assert.True(LinkHelper.TryParseInlineLink(ref text, out link, out title, out linkSpan, out titleSpan));
             Assert.AreEqual(string.Empty, link);
             Assert.AreEqual(string.Empty, title);
+            Assert.AreEqual(SourceSpan.Empty, linkSpan);
+            Assert.AreEqual(SourceSpan.Empty, titleSpan);
             Assert.AreEqual('A', text.CurrentChar);
         }
 
         [Test]
         public void TestMultipleLines()
         {
-            var text = new StringSlice(@"(
-                   <http://google.com>  
-                 'toto' )A");
+            //                          0          1         2          3
+            //                          01 2345678901234567890 1234567890123456789
+            var text = new StringSlice("(\n<http://google.com>\n    'toto' )A");
             string link;
             string title;
-            Assert.True(LinkHelper.TryParseInlineLink(ref text, out link, out title));
+            SourceSpan linkSpan;
+            SourceSpan titleSpan;
+            Assert.True(LinkHelper.TryParseInlineLink(ref text, out link, out title, out linkSpan, out titleSpan));
             Assert.AreEqual("http://google.com", link);
             Assert.AreEqual("toto", title);
+            Assert.AreEqual(new SourceSpan(2, 20), linkSpan);
+            Assert.AreEqual(new SourceSpan(26, 31), titleSpan);
             Assert.AreEqual('A', text.CurrentChar);
         }
 
         [Test]
         public void TestLabelSimple()
         {
+            //                          01234
             var text = new StringSlice("[foo]");
             string label;
-            Assert.True(LinkHelper.TryParseLabel(ref text, out label));
+            SourceSpan labelSpan;
+            Assert.True(LinkHelper.TryParseLabel(ref text, out label, out labelSpan));
+            Assert.AreEqual(new SourceSpan(1, 3), labelSpan);
             Assert.AreEqual("foo", label);
         }
 
         [Test]
         public void TestLabelEscape()
         {
+            //                           012345678
             var text = new StringSlice(@"[fo\[\]o]");
             string label;
-            Assert.True(LinkHelper.TryParseLabel(ref text, out label));
+            SourceSpan labelSpan;
+            Assert.True(LinkHelper.TryParseLabel(ref text, out label, out labelSpan));
+            Assert.AreEqual(new SourceSpan(1, 7), labelSpan);
             Assert.AreEqual(@"fo[]o", label);
         }
 
         [Test]
         public void TestLabelEscape2()
         {
+            //                           0123
             var text = new StringSlice(@"[\]]");
             string label;
-            Assert.True(LinkHelper.TryParseLabel(ref text, out label));
+            SourceSpan labelSpan;
+            Assert.True(LinkHelper.TryParseLabel(ref text, out label, out labelSpan));
+            Assert.AreEqual(new SourceSpan(1, 2), labelSpan);
             Assert.AreEqual(@"]", label);
         }
 
@@ -194,23 +233,36 @@ namespace Markdig.Tests
         [Test]
         public void TestLabelWhitespaceCollapsedAndTrim()
         {
+            //                           0         1         2         3
+            //                           0123456789012345678901234567890123456789
             var text = new StringSlice(@"[     fo    o    z     ]");
             string label;
-            Assert.True(LinkHelper.TryParseLabel(ref text, out label));
+            SourceSpan labelSpan;
+            Assert.True(LinkHelper.TryParseLabel(ref text, out label, out labelSpan));
+            Assert.AreEqual(new SourceSpan(6, 17), labelSpan);
             Assert.AreEqual(@"fo o z", label);
         }
 
         [Test]
         public void TestlLinkReferenceDefinitionSimple()
         {
+            //                           0         1         2         3
+            //                           0123456789012345678901234567890123456789
             var text = new StringSlice(@"[foo]: /toto 'title'");
             string label;
             string url;
             string title;
-            Assert.True(LinkHelper.TryParseLinkReferenceDefinition(ref text, out label, out url, out title));
+            SourceSpan labelSpan;
+            SourceSpan urlSpan;
+            SourceSpan titleSpan;
+            Assert.True(LinkHelper.TryParseLinkReferenceDefinition(ref text, out label, out url, out title, out labelSpan, out urlSpan, out titleSpan));
             Assert.AreEqual(@"foo", label);
             Assert.AreEqual(@"/toto", url);
             Assert.AreEqual(@"title", title);
+            Assert.AreEqual(new SourceSpan(1, 3), labelSpan);
+            Assert.AreEqual(new SourceSpan(7, 11), urlSpan);
+            Assert.AreEqual(new SourceSpan(13, 19), titleSpan);
+
         }
 
         [Test]
@@ -245,5 +297,102 @@ namespace Markdig.Tests
             Assert.False(LinkHelper.TryParseAutolink(new StringSlice(@"<ab"), out text, out isEmail));
             Assert.False(LinkHelper.TryParseAutolink(new StringSlice(@"<user@>"), out text, out isEmail));
         }
+
+        [TestCase("Header identifiers in HTML", "header-identifiers-in-html")]
+        [TestCase("* Dogs*?--in *my* house?", "dogs-in-my-house")] // Not Pandoc equivalent: dogs--in...
+        [TestCase("[HTML], [S5], or [RTF]?", "html-s5-or-rtf")]
+        [TestCase("3. Applications", "applications")]
+        [TestCase("33", "")]
+        public void TestUrilizeNonAscii_Pandoc(string input, string expectedResult)
+        {
+            Assert.AreEqual(expectedResult, LinkHelper.Urilize(input, false));
+        }
+
+        [TestCase("abc", "abc")]
+        [TestCase("a-c", "a-c")]
+        [TestCase("a c", "a-c")]
+        [TestCase("a_c", "a_c")]
+        [TestCase("a.c", "a.c")]
+        [TestCase("a,c", "ac")]
+        [TestCase("a--", "a")] // Not Pandoc-equivalent: a--
+        [TestCase("a__", "a")] // Not Pandoc-equivalent: a__
+        [TestCase("a..", "a")] // Not Pandoc-equivalent: a..
+        [TestCase("a??", "a")]
+        [TestCase("a  ", "a")]
+        [TestCase("a--d", "a-d")]
+        [TestCase("a__d", "a_d")]
+        [TestCase("a??d", "ad")]
+        [TestCase("a  d", "a-d")]
+        [TestCase("a..d", "a.d")]
+        [TestCase("-bc", "bc")]
+        [TestCase("_bc", "bc")]
+        [TestCase(" bc", "bc")]
+        [TestCase("?bc", "bc")]
+        [TestCase(".bc", "bc")]
+        [TestCase("a-.-", "a")] // Not Pandoc equivalent: a-.-
+        public void TestUrilizeOnlyAscii_Simple(string input, string expectedResult)
+        {
+            Assert.AreEqual(expectedResult, LinkHelper.Urilize(input, true));
+        }
+
+        [TestCase("bær", "br")]
+        [TestCase("bør", "br")]
+        [TestCase("bΘr", "br")]
+        [TestCase("四五", "")]
+        public void TestUrilizeOnlyAscii_NonAscii(string input, string expectedResult)
+        {
+            Assert.AreEqual(expectedResult, LinkHelper.Urilize(input, true));
+        }
+
+        [TestCase("bár", "bar")]
+        [TestCase("àrrivé", "arrive")]
+        public void TestUrilizeOnlyAscii_Normalization(string input, string expectedResult)
+        {
+            Assert.AreEqual(expectedResult, LinkHelper.Urilize(input, true));
+        }
+
+        [TestCase("123", "")]
+        [TestCase("1,-b", "b")]
+        [TestCase("b1,-", "b1")] // Not Pandoc equivalent: b1-
+        [TestCase("ab3", "ab3")]
+        [TestCase("ab3de", "ab3de")]
+        public void TestUrilizeOnlyAscii_Numeric(string input, string expectedResult)
+        {
+            Assert.AreEqual(expectedResult, LinkHelper.Urilize(input, true));
+        }
+
+        [TestCase("一二三四五", "一二三四五")]
+        [TestCase("一,-b", "一-b")]
+        public void TestUrilizeNonAscii_NonAsciiNumeric(string input, string expectedResult)
+        {
+            Assert.AreEqual(expectedResult, LinkHelper.Urilize(input, false));
+        }
+
+        [TestCase("bær", "bær")]
+        [TestCase("æ5el", "æ5el")]
+        [TestCase("-æ5el", "æ5el")]
+        [TestCase("-frø-", "frø")]
+        [TestCase("-fr-ø", "fr-ø")]
+        public void TestUrilizeNonAscii_Simple(string input, string expectedResult)
+        {
+            Assert.AreEqual(expectedResult, LinkHelper.Urilize(input, false));
+        }
+
+        // Just to be sure, test for characters expressly forbidden in URI fragments:
+        [TestCase("b#r", "br")]
+        [TestCase("b%r", "br")] // Invalid except as an escape character
+        [TestCase("b^r", "br")]
+        [TestCase("b[r", "br")]
+        [TestCase("b]r", "br")]
+        [TestCase("b{r", "br")]
+        [TestCase("b}r", "br")]
+        [TestCase("b<r", "br")]
+        [TestCase("b>r", "br")]
+        [TestCase(@"b\r", "br")]
+        [TestCase(@"b""r", "br")]
+        public void TestUrilizeNonAscii_NonValidCharactersForFragments(string input, string expectedResult)
+        {
+            Assert.AreEqual(expectedResult, LinkHelper.Urilize(input, false));
+        }
     }
 }

src/Markdig.Tests/TestParser.cs

@@ -14,10 +14,10 @@ namespace Markdig.Tests
         {
             foreach (var pipeline in GetPipeline(extensions))
             {
-                Console.WriteLine($"Pipeline configured with extensions: {extensions}");
+                Console.WriteLine($"Pipeline configured with extensions: {pipeline.Key}");
                 // Uncomment this line to get more debug information for process inlines.
                 //pipeline.DebugLog = Console.Out;
-                var result = Markdown.ToHtml(inputText, pipeline);
+                var result = Markdown.ToHtml(inputText, pipeline.Value);
 
                 result = Compact(result);
                 expectedOutputText = Compact(expectedOutputText);
@@ -34,23 +34,43 @@ namespace Markdig.Tests
             }
         }
 
-        private static IEnumerable<MarkdownPipeline> GetPipeline(string extensionsGroupText)
+        private static IEnumerable<KeyValuePair<string, MarkdownPipeline>> GetPipeline(string extensionsGroupText)
         {
+            // For the standard case, we make sure that both the CommmonMark core and Extra/Advanced are CommonMark compliant!
             if (string.IsNullOrEmpty(extensionsGroupText))
             {
-                yield return new MarkdownPipelineBuilder().Build();
+                yield return new KeyValuePair<string, MarkdownPipeline>("default", new MarkdownPipelineBuilder().Build());
+
+                yield return new KeyValuePair<string, MarkdownPipeline>("advanced", new MarkdownPipelineBuilder()  // Use similar to advanced extension without auto-identifier
+                 .UseAbbreviations()
+                //.UseAutoIdentifiers()
+                .UseCitations()
+                .UseCustomContainers()
+                .UseDefinitionLists()
+                .UseEmphasisExtras()
+                .UseFigures()
+                .UseFooters()
+                .UseFootnotes()
+                .UseGridTables()
+                .UseMathematics()
+                .UseMediaLinks()
+                .UsePipeTables()
+                .UseListExtras()
+                .UseGenericAttributes().Build());
+
                 yield break;
             }
 
             var extensionGroups = extensionsGroupText.Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
             foreach (var extensionsText in extensionGroups)
             {
-                var pipeline = new MarkdownPipelineBuilder().Configure(extensionsText);
-                yield return pipeline.Build();
+                var builder = new MarkdownPipelineBuilder();
+                var pipeline = extensionsText == "self" ? builder.UseSelfPipeline() : builder.Configure(extensionsText);
+                yield return new KeyValuePair<string, MarkdownPipeline>(extensionsText, pipeline.Build());
             }
         }
 
-        private static string DisplaySpaceAndTabs(string text)
+        public static string DisplaySpaceAndTabs(string text)
         {
             // Output special characters to check correctly the results
             return text.Replace('\t', '→').Replace(' ', '·');
@@ -59,7 +79,7 @@ namespace Markdig.Tests
         private static string Compact(string html)
         {
             // Normalize the output to make it compatible with CommonMark specs
-            html = html.Replace("\r", "").Trim();
+            html = html.Replace("\r\n", "\n").Replace(@"\r", @"\n").Trim();
             html = Regex.Replace(html, @"\s+</li>", "</li>");
             html = Regex.Replace(html, @"<li>\s+", "<li>");
             html = html.Normalize(NormalizationForm.FormKD);

src/Markdig.Tests/TestPlayParser.cs

@@ -21,12 +21,118 @@ Later in a text we are using HTML and it becomes an abbr tag HTML
             //> titi toto
             //");
 
-            //var result = Markdown.ToHtml(text, new MarkdownPipeline().UseFootnotes().UseEmphasisExtra());
-            var result = Markdown.ToHtml(text, new MarkdownPipelineBuilder().UseAbbreviation().Build());
+            //var result = Markdown.ToHtml(text, new MarkdownPipeline().UseFootnotes().UseEmphasisExtras());
+            var result = Markdown.ToHtml(text, new MarkdownPipelineBuilder().UseAbbreviations().Build());
             //File.WriteAllText("test.html", result, Encoding.UTF8);
             Console.WriteLine(result);
         }
 
+        [Test]
+        public void TestPipeTables()
+        {
+            TestParser.TestSpec(@"
+| abc | def | ghi |
+|:---:|-----|----:|
+|  1  | 2   | 3   |
+", @"
+<table>
+<thead>
+<tr>
+<th style=""text-align: center;"">abc</th>
+<th>def</th>
+<th style=""text-align: right;"">ghi</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td style=""text-align: center;"">1</td>
+<td>2</td>
+<td style=""text-align: right;"">3</td>
+</tr>
+</tbody>
+</table>
+", "advanced");
+        }
+
+        [Test]
+        public void TestSelfPipeline1()
+        {
+            var text = @" <!--markdig:pipetables-->
+
+a | b
+- | -
+0 | 1
+";
+            TestParser.TestSpec(text, @"<!--markdig:pipetables-->
+<table>
+<thead>
+<tr>
+<th>a</th>
+<th>b</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td>0</td>
+<td>1</td>
+</tr>
+</tbody>
+</table>
+", "self");
+        }
+
+        [Test]
+        public void TestListBug()
+        {
+            // TODO: Add this test back to the CommonMark specs
+            var text = @"- item1
+  - item2
+    - item3
+      - item4";
+            TestParser.TestSpec(text, @"<ul>
+<li>item1
+<ul>
+<li>item2
+<ul>
+<li>item3
+<ul>
+<li>item4</li>
+</ul></li>
+</ul></li>
+</ul></li>
+</ul>
+");
+        }
+
+
+        [Test]
+        public void TestHtmlBug()
+        {
+            TestParser.TestSpec(@" # header1
+
+<pre class='copy'>
+blabla
+</pre>
+
+# header2
+", @"<h1>header1</h1>
+<pre class='copy'>
+blabla
+</pre>
+<h1>header2</h1>");
+        }
+
+
+
+        [Test]
+        public void TestBugAdvancaed()
+        {
+            TestParser.TestSpec(@"`https://{domain}/callbacks`
+#### HEADING
+Paragraph
+", "<p><code>https://{domain}/callbacks</code></p>\n<h4 id=\"heading\">HEADING</h4>\n<p>Paragraph</p>", "advanced");
+        }
+
         [Test]
         public void TestSamePipelineAllExtensions()
         {

src/Markdig.Tests/TestPragmaLines.cs

@@ -0,0 +1,81 @@
+// 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;
+using NUnit.Framework;
+
+namespace Markdig.Tests
+{
+    [TestFixture]
+    public class TestPragmaLines
+    {
+        [Test]
+        public void TestFindClosest()
+        {
+            var doc = Markdown.Parse(
+"test1\n" +                      // 0
+"\n" +                           // 1
+"test2\n" +                      // 2
+"\n" +                           // 3
+"test3\n" +                      // 4
+"\n" +                           // 5
+"test4\n" +                      // 6
+"\n" +                           // 7
+"# Heading\n" +                  // 8
+"\n" +                           // 9
+"Long para\n" +                  // 10
+"on multiple\n" +                // 11
+"lines\n" +                      // 12
+"to check that\n" +              // 13
+"lines are\n" +                  // 14
+"correctly \n" +                 // 15
+"found\n" +                      // 16
+"\n" +                           // 17
+"- item1\n" +                    // 18
+"- item2\n" +                    // 19
+"- item3\n" +                    // 20
+"\n" +                           // 21
+"This is a last paragraph\n"     // 22
+                , new MarkdownPipelineBuilder().UsePragmaLines().Build());
+
+            foreach (var exact in new int[] {0, 2, 4, 6, 8, 10, 18, 19, 20, 22})
+            {
+                Assert.AreEqual(exact, doc.FindClosestLine(exact));
+            }
+
+            Assert.AreEqual(22, doc.FindClosestLine(23));
+
+            Assert.AreEqual(10, doc.FindClosestLine(11));
+            Assert.AreEqual(10, doc.FindClosestLine(12));
+            Assert.AreEqual(10, doc.FindClosestLine(13));
+            Assert.AreEqual(18, doc.FindClosestLine(14)); // > 50% of the paragraph, we switch to next
+            Assert.AreEqual(18, doc.FindClosestLine(15));
+            Assert.AreEqual(18, doc.FindClosestLine(16));
+        }
+
+        [Test]
+        public void TestFindClosest1()
+        {
+            var text = 
+"- item1\n" +                    // 0
+"  - item11\n" +                 // 1
+"  - item12\n" +                 // 2
+"    - item121\n" +              // 3
+"  - item13\n" +                 // 4
+"    - item131\n" +              // 5
+"      - item1311\n";            // 6
+
+            var pipeline = new MarkdownPipelineBuilder().UsePragmaLines().Build();
+            var doc = Markdown.Parse(text, pipeline);
+
+            for (int exact = 0; exact < 7; exact++)
+            {
+                Assert.AreEqual(exact, doc.FindClosestLine(exact));
+            }
+
+            Assert.AreEqual(6, doc.FindClosestLine(50));
+        }
+    }
+}

src/Markdig.Tests/TestSourcePosition.cs

@@ -0,0 +1,777 @@
+// 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 System.Text;
+using Markdig.Helpers;
+using Markdig.Renderers.Html;
+using Markdig.Syntax;
+using Markdig.Syntax.Inlines;
+using NUnit.Framework;
+
+namespace Markdig.Tests
+{
+    /// <summary>
+    /// Test the precise source location of all Markdown elements, including extensions
+    /// </summary>
+    [TestFixture]
+    public class TestSourcePosition
+    {
+        [Test]
+        public void TestParagraph()
+        {
+            Check("0123456789", @"
+paragraph    ( 0, 0)  0-9
+literal      ( 0, 0)  0-9
+");
+        }
+
+        [Test]
+        public void TestParagraphAndNewLine()
+        {
+            Check("0123456789\n0123456789", @"
+paragraph    ( 0, 0)  0-20
+literal      ( 0, 0)  0-9
+linebreak    ( 0,10) 10-10
+literal      ( 1, 0) 11-20
+");
+
+            Check("0123456789\r\n0123456789", @"
+paragraph    ( 0, 0)  0-21
+literal      ( 0, 0)  0-9
+linebreak    ( 0,10) 10-10
+literal      ( 1, 0) 12-21
+");
+        }
+
+        [Test]
+        public void TestParagraphNewLineAndSpaces()
+        {
+            //     0123 45678
+            Check("012\n  345", @"
+paragraph    ( 0, 0)  0-8
+literal      ( 0, 0)  0-2
+linebreak    ( 0, 3)  3-3
+literal      ( 1, 2)  6-8
+");
+        }
+
+        [Test]
+        public void TestParagraph2()
+        {
+            Check("0123456789\n\n0123456789", @"
+paragraph    ( 0, 0)  0-9
+literal      ( 0, 0)  0-9
+paragraph    ( 2, 0) 12-21
+literal      ( 2, 0) 12-21
+");
+        }
+
+        [Test]
+        public void TestEmphasis()
+        {
+            Check("012**3456789**", @"
+paragraph    ( 0, 0)  0-13
+literal      ( 0, 0)  0-2
+emphasis     ( 0, 3)  3-13
+literal      ( 0, 5)  5-11
+");
+        }
+
+        [Test]
+        public void TestEmphasis2()
+        {
+            //     01234567
+            Check("01*2**3*", @"
+paragraph    ( 0, 0)  0-7
+literal      ( 0, 0)  0-1
+emphasis     ( 0, 2)  2-7
+literal      ( 0, 3)  3-3
+literal      ( 0, 4)  4-5
+literal      ( 0, 6)  6-6
+");
+        }
+
+        [Test]
+        public void TestEmphasis3()
+        {
+            //     0123456789
+            Check("01**2***3*", @"
+paragraph    ( 0, 0)  0-9
+literal      ( 0, 0)  0-1
+emphasis     ( 0, 2)  2-6
+literal      ( 0, 4)  4-4
+emphasis     ( 0, 7)  7-9
+literal      ( 0, 8)  8-8
+");
+        }
+
+        [Test]
+        public void TestEmphasisFalse()
+        {
+            Check("0123456789**0123", @"
+paragraph    ( 0, 0)  0-15
+literal      ( 0, 0)  0-9
+literal      ( 0,10) 10-11
+literal      ( 0,12) 12-15
+");
+        }
+
+        [Test]
+        public void TestHeading()
+        {
+            //     012345
+            Check("# 2345", @"
+heading      ( 0, 0)  0-5
+literal      ( 0, 2)  2-5
+");
+        }
+
+        [Test]
+        public void TestHeadingWithEmphasis()
+        {
+            //     0123456789
+            Check("# 23**45**", @"
+heading      ( 0, 0)  0-9
+literal      ( 0, 2)  2-3
+emphasis     ( 0, 4)  4-9
+literal      ( 0, 6)  6-7
+");
+        }
+
+        [Test]
+        public void TestCodeSpan()
+        {
+            //     012345678
+            Check("0123`456`", @"
+paragraph    ( 0, 0)  0-8
+literal      ( 0, 0)  0-3
+code         ( 0, 4)  4-8
+");
+        }
+
+        [Test]
+        public void TestLink()
+        {
+            //     0123456789
+            Check("012[45](#)", @"
+paragraph    ( 0, 0)  0-9
+literal      ( 0, 0)  0-2
+link         ( 0, 3)  3-9
+literal      ( 0, 4)  4-5
+");
+        }
+
+        [Test]
+        public void TestLinkParts1()
+        {
+            //                         0           1
+            //                         01 2 3456789012345
+            var link = Markdown.Parse("0\n\n01 [234](/56)", new MarkdownPipelineBuilder().UsePreciseSourceLocation().Build()).Descendants().OfType<LinkInline>().FirstOrDefault();
+            Assert.NotNull(link);
+
+            Assert.AreEqual(new SourceSpan(7, 9), link.LabelSpan);
+            Assert.AreEqual(new SourceSpan(12, 14), link.UrlSpan);
+            Assert.AreEqual(SourceSpan.Empty, link.TitleSpan);
+        }
+
+        [Test]
+        public void TestLinkParts2()
+        {
+            //                         0           1
+            //                         01 2 34567890123456789
+            var link = Markdown.Parse("0\n\n01 [234](/56 'yo')", new MarkdownPipelineBuilder().UsePreciseSourceLocation().Build()).Descendants().OfType<LinkInline>().FirstOrDefault();
+            Assert.NotNull(link);
+
+            Assert.AreEqual(new SourceSpan(7, 9), link.LabelSpan);
+            Assert.AreEqual(new SourceSpan(12, 14), link.UrlSpan);
+            Assert.AreEqual(new SourceSpan(16, 19), link.TitleSpan);
+        }
+
+
+        [Test]
+        public void TestLinkParts3()
+        {
+            //                         0           1
+            //                         01 2 3456789012345
+            var link = Markdown.Parse("0\n\n01![234](/56)", new MarkdownPipelineBuilder().UsePreciseSourceLocation().Build()).Descendants().OfType<LinkInline>().FirstOrDefault();
+            Assert.NotNull(link);
+
+            Assert.AreEqual(new SourceSpan(5, 15), link.Span);
+            Assert.AreEqual(new SourceSpan(7, 9), link.LabelSpan);
+            Assert.AreEqual(new SourceSpan(12, 14), link.UrlSpan);
+            Assert.AreEqual(SourceSpan.Empty, link.TitleSpan);
+        }
+
+        [Test]
+        public void TestAutolinkInline()
+        {
+            //     0123456789ABCD
+            Check("01<http://yes>", @"
+paragraph    ( 0, 0)  0-13
+literal      ( 0, 0)  0-1
+autolink     ( 0, 2)  2-13
+");
+        }
+
+        [Test]
+        public void TestFencedCodeBlock()
+        {
+            //     012 3456 78 9ABC
+            Check("01\n```\n3\n```\n", @"
+paragraph    ( 0, 0)  0-1
+literal      ( 0, 0)  0-1
+fencedcode   ( 1, 0)  3-11
+");
+        }
+
+        [Test]
+        public void TestHtmlBlock()
+        {
+            //     012345 67 89ABCDE F 0
+            Check("<div>\n0\n</div>\n\n1", @"
+html         ( 0, 0)  0-13
+paragraph    ( 4, 0) 16-16
+literal      ( 4, 0) 16-16
+");
+        }
+
+        [Test]
+        public void TestHtmlBlock1()
+        {
+            //     0           1
+            //     01 2 345678901 23
+            Check("0\n\n<!--A-->\n1\n", @"
+paragraph    ( 0, 0)  0-0
+literal      ( 0, 0)  0-0
+html         ( 2, 0)  3-10
+paragraph    ( 3, 0) 12-12
+literal      ( 3, 0) 12-12
+");
+        }
+
+        [Test]
+        public void TestHtmlComment()
+        {
+            //     0         1          2
+            //     012345678901 234567890 1234
+            Check("# 012345678\n<!--0-->\n123\n", @"
+heading      ( 0, 0)  0-10
+literal      ( 0, 2)  2-10
+html         ( 1, 0) 12-19
+paragraph    ( 2, 0) 21-23
+literal      ( 2, 0) 21-23
+");
+        }
+
+        [Test]
+        public void TestHtmlInline()
+        {
+            //     0123456789
+            Check("01<b>4</b>", @"
+paragraph    ( 0, 0)  0-9
+literal      ( 0, 0)  0-1
+html         ( 0, 2)  2-4
+literal      ( 0, 5)  5-5
+html         ( 0, 6)  6-9
+");
+        }
+
+        [Test]
+        public void TestHtmlInline1()
+        {
+            //     0         
+            //     0123456789
+            Check("0<!--A-->1", @"
+paragraph    ( 0, 0)  0-9
+literal      ( 0, 0)  0-0
+html         ( 0, 1)  1-8
+literal      ( 0, 9)  9-9
+");
+        }
+
+        [Test]
+        public void TestThematicBreak()
+        {
+            //     0123 4567
+            Check("---\n---\n", @"
+thematicbreak ( 0, 0)  0-2
+thematicbreak ( 1, 0)  4-6
+");
+        }
+
+        [Test]
+        public void TestQuoteBlock()
+        {
+            //     0123456
+            Check("> 2345\n", @"
+quote        ( 0, 0)  0-5
+paragraph    ( 0, 2)  2-5
+literal      ( 0, 2)  2-5
+");
+        }
+
+        [Test]
+        public void TestQuoteBlockWithLines()
+        {
+            //     01234 56789A
+            Check("> 01\n>  23\n", @"
+quote        ( 0, 0)  0-9
+paragraph    ( 0, 2)  2-9
+literal      ( 0, 2)  2-3
+linebreak    ( 0, 4)  4-4
+literal      ( 1, 3)  8-9
+");
+        }
+
+        [Test]
+        public void TestQuoteBlockWithLazyContinuation()
+        {
+            //     01234 56
+            Check("> 01\n23\n", @"
+quote        ( 0, 0)  0-6
+paragraph    ( 0, 2)  2-6
+literal      ( 0, 2)  2-3
+linebreak    ( 0, 4)  4-4
+literal      ( 1, 0)  5-6
+");
+        }
+
+        [Test]
+        public void TestListBlock()
+        {
+            //     0123 4567
+            Check("- 0\n- 1\n", @"
+list         ( 0, 0)  0-6
+listitem     ( 0, 0)  0-2
+paragraph    ( 0, 2)  2-2
+literal      ( 0, 2)  2-2
+listitem     ( 1, 0)  4-6
+paragraph    ( 1, 2)  6-6
+literal      ( 1, 2)  6-6
+");
+        }
+
+        [Test]
+        public void TestEscapeInline()
+        {
+            //      0123
+            Check(@"\-\)", @"
+paragraph    ( 0, 0)  0-3
+literal      ( 0, 0)  0-1
+literal      ( 0, 2)  2-3
+");
+        }
+
+        [Test]
+        public void TestHtmlEntityInline()
+        {
+            //     01 23456789
+            Check("0\n&nbsp; 1", @"
+paragraph    ( 0, 0)  0-9
+literal      ( 0, 0)  0-0
+linebreak    ( 0, 1)  1-1
+htmlentity   ( 1, 0)  2-7
+literal      ( 1, 6)  8-9
+");
+        }
+
+        [Test]
+        public void TestAbbreviations()
+        {
+            Check("*[HTML]: Hypertext Markup Language\r\n\r\nLater in a text we are using HTML and it becomes an abbr tag HTML", @"
+paragraph    ( 2, 0) 38-102
+container    ( 2, 0) 38-102
+literal      ( 2, 0) 38-66
+abbreviation ( 2,29) 67-70
+literal      ( 2,33) 71-98
+abbreviation ( 2,61) 99-102
+", "abbreviations");
+        }
+
+        [Test]
+        public void TestCitation()
+        {
+            //     0123 4 567 8
+            Check("01 \"\"23\"\"", @"
+paragraph    ( 0, 0)  0-8
+literal      ( 0, 0)  0-2
+emphasis     ( 0, 3)  3-8
+literal      ( 0, 5)  5-6
+", "citations");
+        }
+
+        [Test]
+        public void TestCustomContainer()
+        {
+            //     01 2345 678 9ABC DEF
+            Check("0\n:::\n23\n:::\n45\n", @"
+paragraph    ( 0, 0)  0-0
+literal      ( 0, 0)  0-0
+customcontainer ( 1, 0)  2-11
+paragraph    ( 2, 0)  6-7
+literal      ( 2, 0)  6-7
+paragraph    ( 4, 0) 13-14
+literal      ( 4, 0) 13-14
+", "customcontainers");
+        }
+
+        [Test]
+        public void TestDefinitionList()
+        {
+            //     012 3456789A
+            Check("a0\n:   1234", @"
+definitionlist ( 0, 0)  0-10
+definitionitem ( 1, 0)  3-10
+definitionterm ( 0, 0)  0-1
+literal      ( 0, 0)  0-1
+paragraph    ( 1, 4)  7-10
+literal      ( 1, 4)  7-10
+", "definitionlists");
+        }
+
+        [Test]
+        public void TestDefinitionList2()
+        {
+            //     012 3456789AB CDEF01234
+            Check("a0\n:   1234\n:    5678", @"
+definitionlist ( 0, 0)  0-20
+definitionitem ( 1, 0)  3-10
+definitionterm ( 0, 0)  0-1
+literal      ( 0, 0)  0-1
+paragraph    ( 1, 4)  7-10
+literal      ( 1, 4)  7-10
+definitionitem ( 2, 4) 12-20
+paragraph    ( 2, 5) 17-20
+literal      ( 2, 5) 17-20
+", "definitionlists");
+        }
+
+        [Test]
+        public void TestEmoji()
+        {
+            //     01 2345
+            Check("0\n :)\n", @"
+paragraph    ( 0, 0)  0-4
+literal      ( 0, 0)  0-0
+linebreak    ( 0, 1)  1-1
+emoji        ( 1, 1)  3-4
+", "emojis");
+        }
+
+        [Test]
+        public void TestEmphasisExtra()
+        {
+            //     0123456
+            Check("0 ~~1~~", @"
+paragraph    ( 0, 0)  0-6
+literal      ( 0, 0)  0-1
+emphasis     ( 0, 2)  2-6
+literal      ( 0, 4)  4-4
+", "emphasisextras");
+        }
+
+        [Test]
+        public void TestFigures()
+        {
+            //     01 2345 67 89AB
+            Check("0\n^^^\n0\n^^^\n", @"
+paragraph    ( 0, 0)  0-0
+literal      ( 0, 0)  0-0
+figure       ( 1, 0)  2-10
+paragraph    ( 2, 0)  6-6
+literal      ( 2, 0)  6-6
+", "figures");
+        }
+
+        [Test]
+        public void TestFiguresCaption1()
+        {
+            //     01 234567 89 ABCD
+            Check("0\n^^^ab\n0\n^^^\n", @"
+paragraph    ( 0, 0)  0-0
+literal      ( 0, 0)  0-0
+figure       ( 1, 0)  2-12
+figurecaption ( 1, 3)  5-6
+literal      ( 1, 3)  5-6
+paragraph    ( 2, 0)  8-8
+literal      ( 2, 0)  8-8
+", "figures");
+        }
+
+        [Test]
+        public void TestFiguresCaption2()
+        {
+            //     01 2345 67 89ABCD
+            Check("0\n^^^\n0\n^^^ab\n", @"
+paragraph    ( 0, 0)  0-0
+literal      ( 0, 0)  0-0
+figure       ( 1, 0)  2-12
+paragraph    ( 2, 0)  6-6
+literal      ( 2, 0)  6-6
+figurecaption ( 3, 3) 11-12
+literal      ( 3, 3) 11-12
+", "figures");
+        }
+
+        [Test]
+        public void TestFooters()
+        {
+            //     01 234567 89ABCD
+            Check("0\n^^ 12\n^^ 34\n", @"
+paragraph    ( 0, 0)  0-0
+literal      ( 0, 0)  0-0
+footer       ( 1, 0)  2-12
+paragraph    ( 1, 3)  5-12
+literal      ( 1, 3)  5-6
+linebreak    ( 1, 5)  7-7
+literal      ( 2, 3) 11-12
+", "footers");
+        }
+
+
+        [Test]
+        public void TestAttributes()
+        {
+            //     0123456789
+            Check("0123{#456}", @"
+paragraph    ( 0, 0)  0-9
+attributes   ( 0, 4)  4-9
+literal      ( 0, 0)  0-3
+", "attributes");
+        }
+
+        [Test]
+        public void TestAttributesForHeading()
+        {
+            //     0123456789ABC
+            Check("# 01 {#456}", @"
+heading      ( 0, 0)  0-4
+attributes   ( 0, 5)  5-10
+literal      ( 0, 2)  2-3
+", "attributes");
+        }
+
+        [Test]
+        public void TestMathematicsInline()
+        {
+            //     01 23456789AB
+            Check("0\n012 $abcd$", @"
+paragraph    ( 0, 0)  0-11
+literal      ( 0, 0)  0-0
+linebreak    ( 0, 1)  1-1
+literal      ( 1, 0)  2-5
+math         ( 1, 4)  6-11
+attributes   ( 0, 0)  0--1
+", "mathematics");
+        }
+
+        [Test]
+        public void TestSmartyPants()
+        {
+            //        01234567
+            //     01 23456789
+            Check("0\n2 <<45>>", @"
+paragraph    ( 0, 0)  0-9
+literal      ( 0, 0)  0-0
+linebreak    ( 0, 1)  1-1
+literal      ( 1, 0)  2-3
+smartypant   ( 1, 2)  4-5
+literal      ( 1, 4)  6-7
+smartypant   ( 1, 6)  8-9
+", "smartypants");
+        }
+
+        [Test]
+        public void TestSmartyPantsUnbalanced()
+        {
+            //        012345
+            //     01 234567
+            Check("0\n2 <<45", @"
+paragraph    ( 0, 0)  0-7
+literal      ( 0, 0)  0-0
+linebreak    ( 0, 1)  1-1
+literal      ( 1, 0)  2-3
+literal      ( 1, 2)  4-5
+literal      ( 1, 4)  6-7
+", "smartypants");
+        }
+
+        [Test]
+        public void TestPipeTable()
+        {
+            //     0123 4567 89AB
+            Check("a|b\n-|-\n0|1\n", @"
+table        ( 0, 0)  0-10
+tablerow     ( 0, 0)  0-2
+tablecell    ( 0, 0)  0-0
+paragraph    ( 0, 0)  0-0
+literal      ( 0, 0)  0-0
+tablecell    ( 0, 2)  2-2
+paragraph    ( 0, 2)  2-2
+literal      ( 0, 2)  2-2
+tablerow     ( 2, 0)  8-10
+tablecell    ( 2, 0)  8-8
+paragraph    ( 2, 0)  8-8
+literal      ( 2, 0)  8-8
+tablecell    ( 2, 2) 10-10
+paragraph    ( 2, 2) 10-10
+literal      ( 2, 2) 10-10
+", "pipetables");
+        }
+
+        [Test]
+        public void TestPipeTable2()
+        {
+            //     01 2 3456 789A BCD
+            Check("0\n\na|b\n-|-\n0|1\n", @"
+paragraph    ( 0, 0)  0-0
+literal      ( 0, 0)  0-0
+table        ( 2, 0)  3-13
+tablerow     ( 2, 0)  3-5
+tablecell    ( 2, 0)  3-3
+paragraph    ( 2, 0)  3-3
+literal      ( 2, 0)  3-3
+tablecell    ( 2, 2)  5-5
+paragraph    ( 2, 2)  5-5
+literal      ( 2, 2)  5-5
+tablerow     ( 4, 0) 11-13
+tablecell    ( 4, 0) 11-11
+paragraph    ( 4, 0) 11-11
+literal      ( 4, 0) 11-11
+tablecell    ( 4, 2) 13-13
+paragraph    ( 4, 2) 13-13
+literal      ( 4, 2) 13-13
+", "pipetables");
+        }
+
+        [Test]
+        public void TestIndentedCode()
+        {
+            //     01 2 345678 9ABCDE
+            Check("0\n\n    0\n    1\n", @"
+paragraph    ( 0, 0)  0-0
+literal      ( 0, 0)  0-0
+code         ( 2, 0)  3-13
+");
+        }
+
+        [Test]
+        public void TestIndentedCodeWithTabs()
+        {
+            //     01 2 3 45 6 78
+            Check("0\n\n\t0\n\t1\n", @"
+paragraph    ( 0, 0)  0-0
+literal      ( 0, 0)  0-0
+code         ( 2, 0)  3-7
+");
+        }
+
+        [Test]
+        public void TestIndentedCodeWithMixedTabs()
+        {
+            //     01 2 34 56 78 9
+            Check("0\n\n \t0\n \t1\n", @"
+paragraph    ( 0, 0)  0-0
+literal      ( 0, 0)  0-0
+code         ( 2, 0)  3-9
+");
+        }
+
+        [Test]
+        public void TestTabsInList()
+        {
+            //     012 34 567 89
+            Check("- \t0\n- \t1\n", @"
+list         ( 0, 0)  0-8
+listitem     ( 0, 0)  0-3
+paragraph    ( 0, 4)  3-3
+literal      ( 0, 4)  3-3
+listitem     ( 1, 0)  5-8
+paragraph    ( 1, 4)  8-8
+literal      ( 1, 4)  8-8
+");
+        }
+
+        [Test]
+        public void TestDocument()
+        {
+            //     L0       L0           L1L2         L3         L4         L5L6                    L7L8         
+            //     0        10        20          30         40         50          60        70          80        90
+            //     012345678901234567890 1 2345678901 2345678901 2345678901 2 345678901234567890123 4 5678901234567890123
+            Check("# This is a document\n\n1) item 1\n2) item 2\n3) item 4\n\nWith an **emphasis**\n\n> and a blockquote\n", @"
+heading      ( 0, 0)  0-19
+literal      ( 0, 2)  2-19
+list         ( 2, 0) 22-51
+listitem     ( 2, 0) 22-30
+paragraph    ( 2, 3) 25-30
+literal      ( 2, 3) 25-30
+listitem     ( 3, 0) 32-40
+paragraph    ( 3, 3) 35-40
+literal      ( 3, 3) 35-40
+listitem     ( 4, 0) 42-51
+paragraph    ( 4, 3) 45-50
+literal      ( 4, 3) 45-50
+paragraph    ( 6, 0) 53-72
+literal      ( 6, 0) 53-60
+emphasis     ( 6, 8) 61-72
+literal      ( 6,10) 63-70
+quote        ( 8, 0) 75-92
+paragraph    ( 8, 2) 77-92
+literal      ( 8, 2) 77-92
+");
+        }
+
+        private static void Check(string text, string expectedResult, string extensions = null)
+        {
+            var pipelineBuilder = new MarkdownPipelineBuilder().UsePreciseSourceLocation();
+            if (extensions != null)
+            {
+                pipelineBuilder.Configure(extensions);
+            }
+            var pipeline = pipelineBuilder.Build();
+
+            var document = Markdown.Parse(text, pipeline);
+
+            var build = new StringBuilder();
+            foreach (var val in document.Descendants())
+            {
+                var name = GetTypeName(val.GetType());
+                build.Append($"{name,-12} ({val.Line,2},{val.Column,2}) {val.Span.Start,2}-{val.Span.End}\n");
+                var attributes = val.TryGetAttributes();
+                if (attributes != null)
+                {
+                    build.Append($"{"attributes",-12} ({attributes.Line,2},{attributes.Column,2}) {attributes.Span.Start,2}-{attributes.Span.End}\n");
+                }
+            }
+            var result = build.ToString().Trim();
+
+            expectedResult = expectedResult.Trim();
+            expectedResult = expectedResult.Replace("\r\n", "\n").Replace("\r", "\n");
+
+            if (expectedResult != result)
+            {
+                Console.WriteLine("```````````````````Source");
+                Console.WriteLine(TestParser.DisplaySpaceAndTabs(text));
+                Console.WriteLine("```````````````````Result");
+                Console.WriteLine(result);
+                Console.WriteLine("```````````````````Expected");
+                Console.WriteLine(expectedResult);
+                Console.WriteLine("```````````````````");
+                Console.WriteLine();
+            }
+
+            TextAssert.AreEqual(expectedResult, result);
+        }
+
+        private static string GetTypeName(Type type)
+        {
+            return type.Name.ToLowerInvariant()
+                .Replace("block", string.Empty)
+                .Replace("inline", string.Empty);
+        }
+    }
+}

src/Markdig.Tests/project.json

@@ -18,6 +18,7 @@
     }
   },
   "dependencies": {
-    "NUnit": "3.2.0"
+    "NUnit": "3.2.0",
+    "NUnit3TestAdapter": "3.2.0"
   }
 }

src/Markdig/Extensions/Abbreviations/Abbreviation.cs

@@ -33,5 +33,10 @@ namespace Markdig.Extensions.Abbreviations
         /// The text associated to this label.
         /// </summary>
         public StringSlice Text;
+
+        /// <summary>
+        /// The label span
+        /// </summary>
+        public SourceSpan LabelSpan;
     }
 }

src/Markdig/Extensions/Abbreviations/AbbreviationParser.cs

@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using Markdig.Helpers;
 using Markdig.Parsers;
+using Markdig.Syntax;
 using Markdig.Syntax.Inlines;
 
 namespace Markdig.Extensions.Abbreviations
@@ -31,14 +32,16 @@ namespace Markdig.Extensions.Abbreviations
 
             // A link must be of the form *[Some Text]: An abbreviation 
             var slice = processor.Line;
+            var startPosition = slice.Start;
             var c = slice.NextChar();
             if (c != '[')
             {
                 return BlockState.None;
             }
 
+            SourceSpan labelSpan;
             string label;
-            if (!LinkHelper.TryParseLabel(ref slice, out label))
+            if (!LinkHelper.TryParseLabel(ref slice, out label, out labelSpan))
             {
                 return BlockState.None;
             }
@@ -55,7 +58,11 @@ namespace Markdig.Extensions.Abbreviations
             var abbr = new Abbreviation(this)
             {
                 Label = label,
-                Text = slice, Line = processor.LineIndex, Column = processor.Column
+                Text = slice,
+                Span = new SourceSpan(startPosition, slice.End),
+                Line = processor.LineIndex,
+                Column = processor.Column,
+                LabelSpan = labelSpan,
             };
             if (!processor.Document.HasAbbreviations())
             {
@@ -84,6 +91,7 @@ namespace Markdig.Extensions.Abbreviations
             inlineProcessor.LiteralInlineParser.PostMatch += (InlineProcessor processor, ref StringSlice slice) =>
             {
                 var literal = (LiteralInline) processor.Inline;
+                var originalLiteral = literal;
 
                 ContainerInline container = null;
 
@@ -96,13 +104,13 @@ namespace Markdig.Extensions.Abbreviations
                     if (matcher.TryMatch(text, i, content.End - i + 1, out match))
                     {
                         // The word matched must be embraced by punctuation or whitespace or \0.
-                        var c = content.PeekCharExtra(i - 1);
+                        var c = content.PeekCharAbsolute(i - 1);
                         if (!(c == '\0' || c.IsAsciiPunctuation() || c.IsWhitespace()))
                         {
                             continue;
                         }
                         var indexAfterMatch = i + match.Length;
-                        c = content.PeekCharExtra(indexAfterMatch);
+                        c = content.PeekCharAbsolute(indexAfterMatch);
                         if (!(c == '\0' || c.IsAsciiPunctuation() || c.IsWhitespace()))
                         {
                             continue;
@@ -118,15 +126,33 @@ namespace Markdig.Extensions.Abbreviations
                         // If we don't have a container, create a new one
                         if (container == null)
                         {
-                            container = new ContainerInline();
+                            container = new ContainerInline()
+                            {
+                                Span = originalLiteral.Span,
+                                Line = originalLiteral.Line,
+                                Column = originalLiteral.Column,
+                            };
                         }
 
-                        var abbrInline = new AbbreviationInline(abbr);
+                        int line;
+                        int column;
+                        var abbrInline = new AbbreviationInline(abbr)
+                        {
+                            Span =
+                            {
+                                Start = processor.GetSourcePosition(i, out line, out column),
+                            },
+                            Line = line,
+                            Column = column
+                        };
+                        abbrInline.Span.End = abbrInline.Span.Start + match.Length - 1;
 
                         // Append the previous literal
                         if (i > content.Start)
                         {
                             container.AppendChild(literal);
+
+                            literal.Span.End = abbrInline.Span.Start - 1;
                             // Truncate it before the abbreviation
                             literal.Content.End = i - 1;
                         }
@@ -143,7 +169,12 @@ namespace Markdig.Extensions.Abbreviations
                         }
 
                         // Process the remaining literal
-                        literal = new LiteralInline();
+                        literal = new LiteralInline()
+                        {
+                            Span = new SourceSpan(abbrInline.Span.End + 1, literal.Span.End),
+                            Line = line,
+                            Column = column + match.Length,
+                        };
                         content.Start = indexAfterMatch;
                         literal.Content = content;
 
@@ -153,12 +184,11 @@ namespace Markdig.Extensions.Abbreviations
 
                 if (container != null)
                 {
-                    processor.Inline = container;
-                    // If we have a pending literal, we can add it
                     if (literal != null)
                     {
                         container.AppendChild(literal);
                     }
+                    processor.Inline = container;
                 }
             };
         }

src/Markdig/Extensions/AutoIdentifiers/AutoIdentifierExtension.cs

@@ -50,7 +50,7 @@ namespace Markdig.Extensions.AutoIdentifiers
                 headingBlockParser.Closed -= HeadingBlockParser_Closed;
                 headingBlockParser.Closed += HeadingBlockParser_Closed;
             }
-            var paragraphBlockParser = pipeline.BlockParsers.Find<ParagraphBlockParser>();
+            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
@@ -132,6 +132,13 @@ namespace Markdig.Extensions.AutoIdentifiers
                 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();
@@ -152,7 +159,7 @@ namespace Markdig.Extensions.AutoIdentifiers
                 headingBuffer.Length = 0;
             }
 
-            processor.Block.GetAttributes().Id = headingId;
+            attributes.Id = headingId;
         }
     }
 }

src/Markdig/Extensions/Citations/CitationExtension.cs

@@ -7,13 +7,13 @@ using Markdig.Renderers;
 using Markdig.Renderers.Html.Inlines;
 using Markdig.Syntax.Inlines;
 
-namespace Markdig.Extensions.Cites
+namespace Markdig.Extensions.Citations
 {
     /// <summary>
     /// Extension for cite ""...""
     /// </summary>
     /// <seealso cref="Markdig.IMarkdownExtension" />
-    public class CiteExtension : IMarkdownExtension
+    public class CitationExtension : IMarkdownExtension
     {
         public void Setup(MarkdownPipelineBuilder pipeline)
         {

src/Markdig/Extensions/DefinitionLists/DefinitionListParser.cs

@@ -30,6 +30,8 @@ namespace Markdig.Extensions.DefinitionLists
                 return BlockState.None;
             }
 
+            var startPosition = processor.Start;
+
             var column = processor.ColumnBeforeIndent;
             processor.NextChar();
             processor.ParseIndent();
@@ -62,16 +64,22 @@ namespace Markdig.Extensions.DefinitionLists
 
             if (currentDefinitionList == null)
             {
-                currentDefinitionList = new DefinitionList(this);
+                currentDefinitionList = new DefinitionList(this)
+                {
+                    Span = new SourceSpan(paragraphBlock.Span.Start, processor.Line.End),
+                    Column = paragraphBlock.Column,
+                    Line = paragraphBlock.Line,
+                };
                 previousParent.Add(currentDefinitionList);
             }
 
             var definitionItem = new DefinitionItem(this)
             {
-                Column =  processor.Column,
+                Line = processor.LineIndex,
+                Column = column,
+                Span = new SourceSpan(startPosition, processor.Line.End),
                 OpeningCharacter = processor.CurrentChar,
             };
-            currentDefinitionList.Add(definitionItem);
 
             for (int i = 0; i < paragraphBlock.Lines.Count; i++)
             {
@@ -80,14 +88,18 @@ namespace Markdig.Extensions.DefinitionLists
                 {
                     Column =  paragraphBlock.Column,
                     Line = line.Line,
+                    Span = new SourceSpan(paragraphBlock.Span.Start, paragraphBlock.Span.End),
                     IsOpen = false
                 };
-                term.AppendLine(ref line.Slice, line.Column, line.Line);
+                term.AppendLine(ref line.Slice, line.Column, line.Line, line.Position);
                 definitionItem.Add(term);
             }
-
+            currentDefinitionList.Add(definitionItem);
             processor.Open(definitionItem);
 
+            // Update the end position
+            currentDefinitionList.UpdateSpanEnd(processor.Line.End);
+
             return BlockState.Continue;
         }
 
@@ -100,11 +112,13 @@ namespace Markdig.Extensions.DefinitionLists
                 return BlockState.Continue;
             }
 
+            var list = (DefinitionList)definitionItem.Parent;
             var lastBlankLine = definitionItem.LastChild as BlankLineBlock;
 
             // Check if we have another definition list
             if (Array.IndexOf(OpeningCharacters, processor.CurrentChar) >= 0)
             {
+                var startPosition = processor.Start;
                 var column = processor.ColumnBeforeIndent;
                 processor.NextChar();
                 processor.ParseIndent();
@@ -118,6 +132,8 @@ namespace Markdig.Extensions.DefinitionLists
                     {
                         definitionItem.RemoveAt(definitionItem.Count - 1);
                     }
+
+                    list.Span.End = list.LastChild.Span.End;
                     return BlockState.None;
                 }
 
@@ -126,10 +142,11 @@ namespace Markdig.Extensions.DefinitionLists
                     processor.GoToColumn(column + 4);
                 }
 
-                var list = (DefinitionList) definitionItem.Parent;
                 processor.Close(definitionItem);
                 var nextDefinitionItem = new DefinitionItem(this)
                 {
+                    Span = new SourceSpan(startPosition, processor.Line.End),
+                    Line = processor.LineIndex,
                     Column = processor.Column,
                     OpeningCharacter = processor.CurrentChar,
                 };
@@ -161,6 +178,7 @@ namespace Markdig.Extensions.DefinitionLists
                 definitionItem.RemoveAt(definitionItem.Count - 1);
             }
 
+            list.Span.End = list.LastChild.Span.End;
             return BlockState.Break;
         }
     }

src/Markdig/Extensions/Diagrams/DiagramExtension.cs

@@ -0,0 +1,31 @@
+// 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.Renderers.Html;
+
+namespace Markdig.Extensions.Diagrams
+{
+    /// <summary>
+    /// Extension to allow diagrams.
+    /// </summary>
+    /// <seealso cref="Markdig.IMarkdownExtension" />
+    public class DiagramExtension : IMarkdownExtension
+    {
+        public void Setup(MarkdownPipelineBuilder pipeline)
+        {
+        }
+
+        public void Setup(IMarkdownRenderer renderer)
+        {
+            var htmlRenderer = renderer as HtmlRenderer;
+            if (htmlRenderer != null)
+            {
+                var codeRenderer = htmlRenderer.ObjectRenderers.FindExact<CodeBlockRenderer>();
+                // TODO: Add other well known diagram languages
+                codeRenderer.BlocksAsDiv.Add("mermaid");
+            }
+        }
+    }
+}

src/Markdig/Extensions/Emoji/EmojiParser.cs

@@ -67,17 +67,34 @@ namespace Markdig.Extensions.Emoji
         public override bool Match(InlineProcessor processor, ref StringSlice slice)
         {
             string match;
+
+            // Previous char must be a space
+            if (!slice.PeekCharExtra(-1).IsWhiteSpaceOrZero())
+            {
+                return false;
+            }
+
+            // Try to match an existing emoji
+            var startPosition = slice.Start;
             if (!textMatchHelper.TryMatch(slice.Text, slice.Start, slice.Length, out match))
             {
                 return false;
             }
 
+            // Following char must be a space
+            if (!slice.PeekCharExtra(match.Length).IsWhiteSpaceOrZero())
+            {
+                return false;
+            }
+
+            // If we have a smiley, we decode it to emoji
             string emoji;
             if (!SmileyToEmoji.TryGetValue(match, out emoji))
             {
                 emoji = match;
             }
 
+            // Decode the eomji to unicode
             string unicode;
             if (!EmojiToUnicode.TryGetValue(emoji, out unicode))
             {
@@ -89,7 +106,19 @@ namespace Markdig.Extensions.Emoji
             slice.Start += match.Length;
 
             // Push the EmojiInline
-            processor.Inline = new EmojiInline(unicode) {Match = match};
+            int line;
+            int column;
+            processor.Inline = new EmojiInline(unicode)
+            {
+                Span =
+                {
+                    Start = processor.GetSourcePosition(startPosition, out line, out column),
+                },
+                Line = line,
+                Column = column,
+                Match = match
+            };
+            processor.Inline.Span.End = processor.Inline.Span.Start + match.Length - 1;
 
             return true;
         }

src/Markdig/Extensions/EmphasisExtras/EmphasisExtraExtension.cs

@@ -7,7 +7,7 @@ using Markdig.Renderers;
 using Markdig.Renderers.Html.Inlines;
 using Markdig.Syntax.Inlines;
 
-namespace Markdig.Extensions.EmphasisExtra
+namespace Markdig.Extensions.EmphasisExtras
 {
     /// <summary>
     /// Extension for strikethrough, subscript, superscript, inserted and marked.

src/Markdig/Extensions/EmphasisExtras/EmphasisExtraOptions.cs

@@ -4,7 +4,7 @@
 
 using System;
 
-namespace Markdig.Extensions.EmphasisExtra
+namespace Markdig.Extensions.EmphasisExtras
 {
     /// <summary>
     /// Options for enabling support for extra emphasis.

src/Markdig/Extensions/Figures/FigureBlockParser.cs

@@ -30,7 +30,9 @@ namespace Markdig.Extensions.Figures
 
             // Match fenced char
             int count = 0;
+            var column = processor.Column;
             var line = processor.Line;
+            var startPosition = line.Start;
             char c = line.CurrentChar;
             var matchChar = c;
             while (c != '\0')
@@ -51,6 +53,8 @@ namespace Markdig.Extensions.Figures
 
             var figure = new Figure(this)
             {
+                Span = new SourceSpan(startPosition, line.End),
+                Line = processor.LineIndex,
                 Column = processor.Column,
                 OpeningCharacter = matchChar,
                 OpeningCharacterCount = count
@@ -59,8 +63,14 @@ namespace Markdig.Extensions.Figures
             line.TrimStart();
             if (!line.IsEmpty)
             {
-                var caption = new FigureCaption(this) {IsOpen = false};
-                caption.AppendLine(ref line, line.Start, processor.LineIndex);
+                var caption = new FigureCaption(this)
+                {
+                    Span = new SourceSpan(line.Start, line.End),
+                    Line = processor.LineIndex,
+                    Column = column + line.Start - startPosition,
+                    IsOpen = false
+                };
+                caption.AppendLine(ref line, caption.Column, processor.LineIndex, processor.CurrentLineStartPosition);
                 figure.Add(caption);
             }
             processor.NewBlocks.Push(figure);
@@ -76,8 +86,10 @@ namespace Markdig.Extensions.Figures
             var matchChar = figure.OpeningCharacter;
             var c = processor.CurrentChar;
 
+            var column = processor.Column;
             // Match if we have a closing fence
             var line = processor.Line;
+            var startPosition = line.Start;
             while (c == matchChar)
             {
                 c = line.NextChar();
@@ -91,11 +103,19 @@ namespace Markdig.Extensions.Figures
                 line.TrimStart();
                 if (!line.IsEmpty)
                 {
-                    var caption = new FigureCaption(this) {IsOpen = false};
-                    caption.AppendLine(ref line, line.Start, processor.LineIndex);
+                    var caption = new FigureCaption(this)
+                    {
+                        Span = new SourceSpan(line.Start, line.End),
+                        Line = processor.LineIndex,
+                        Column = column + line.Start - startPosition,
+                        IsOpen = false
+                    };
+                    caption.AppendLine(ref line, caption.Column, processor.LineIndex, processor.CurrentLineStartPosition);
                     figure.Add(caption);
                 }
 
+                figure.UpdateSpanEnd(line.End);
+
                 // Don't keep the last line
                 return BlockState.BreakDiscard;
             }
@@ -103,6 +123,8 @@ namespace Markdig.Extensions.Figures
             // Reset the indentation to the column before the indent
             processor.GoToColumn(processor.ColumnBeforeIndent);
 
+            figure.UpdateSpanEnd(line.End);
+
             return BlockState.Continue;
         }
     }

src/Markdig/Extensions/Figures/FigureExtension.cs

@@ -2,7 +2,6 @@
 // This file is licensed under the BSD-Clause 2 license. 
 // See the license.txt file in the project root for more information.
 
-using Markdig.Extensions.Cites;
 using Markdig.Extensions.Footers;
 using Markdig.Renderers;
 

src/Markdig/Extensions/Footers/FooterBlockParser.cs

@@ -30,6 +30,7 @@ namespace Markdig.Extensions.Footers
             }
 
             var column = processor.Column;
+            var startPosition = processor.Start;
 
             // A footer
             // A Footer marker consists of 0-3 spaces of initial indent, plus (a) the characters ^^ together with a following space, or (b) a double character ^^ not followed by a space.
@@ -44,7 +45,13 @@ namespace Markdig.Extensions.Footers
             {
                 processor.NextColumn();
             }
-            processor.NewBlocks.Push(new FooterBlock(this) { OpeningCharacter = openingChar, Column = column});
+            processor.NewBlocks.Push(new FooterBlock(this)
+            {
+                Span = new SourceSpan(startPosition, processor.Line.End),
+                OpeningCharacter = openingChar,
+                Column = column,
+                Line = processor.LineIndex,
+            });
             return BlockState.Continue;
         }
 
@@ -60,19 +67,22 @@ namespace Markdig.Extensions.Footers
             // A footer
             // A Footer marker consists of 0-3 spaces of initial indent, plus (a) the characters ^^ together with a following space, or (b) a double character ^^ not followed by a space.
             var c = processor.CurrentChar;
+            var result = BlockState.Continue;
             if (c != quote.OpeningCharacter || processor.PeekChar(1) != c)
             {
-                return processor.IsBlankLine ? BlockState.BreakDiscard : BlockState.None;
+                result = processor.IsBlankLine ? BlockState.BreakDiscard : BlockState.None;
             }
-
-            processor.NextChar(); // Skip ^^ char (1st)
-            c = processor.NextChar(); // Skip ^^ char (2nd)
-            if (c.IsSpace())
+            else
             {
-                processor.NextChar(); // Skip following space
+                processor.NextChar(); // Skip ^^ char (1st)
+                c = processor.NextChar(); // Skip ^^ char (2nd)
+                if (c.IsSpace())
+                {
+                    processor.NextChar(); // Skip following space
+                }
+                block.UpdateSpanEnd(processor.Line.End);
             }
-
-            return BlockState.Continue;
+            return result;
         }
     }
 }

src/Markdig/Extensions/Footnotes/Footnote.cs

@@ -34,6 +34,11 @@ namespace Markdig.Extensions.Footnotes
         /// </summary>
         public List<FootnoteLink> Links { get; private set; }
 
+        /// <summary>
+        /// The label span
+        /// </summary>
+        public SourceSpan LabelSpan;
+
         internal bool IsLastLineEmpty { get; set; }
     }
 }

src/Markdig/Extensions/Footnotes/FootnoteParser.cs

@@ -26,9 +26,14 @@ namespace Markdig.Extensions.Footnotes
         }
 
         public override BlockState TryOpen(BlockProcessor processor)
+        {
+            return TryOpen(processor, false);
+        }
+
+        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 || processor.CurrentContainer.GetType() != typeof(MarkdownDocument) )
+            if (processor.IsCodeIndent || (!isContinue && processor.CurrentContainer.GetType() != typeof(MarkdownDocument)) || (isContinue && !(processor.CurrentContainer is Footnote)))
             {
                 return BlockState.None;
             }
@@ -36,19 +41,24 @@ namespace Markdig.Extensions.Footnotes
             var saved = processor.Column;
             string label;
             int start = processor.Start;
-            if (!LinkHelper.TryParseLabel(ref processor.Line, false, out label) || !label.StartsWith("^") || processor.CurrentChar != ':')
+            SourceSpan labelSpan;
+            if (!LinkHelper.TryParseLabel(ref processor.Line, false, out label, out labelSpan) || !label.StartsWith("^") || processor.CurrentChar != ':')
             {
                 processor.GoToColumn(saved);
                 return BlockState.None;
             }
-           
+
             // Advance the column
             int deltaColumn = processor.Start - start;
             processor.Column = processor.Column + deltaColumn;
 
             processor.NextChar(); // Skip ':'
 
-            var footnote = new Footnote(this) {Label = label};
+            var footnote = new Footnote(this)
+            {
+                Label = label,
+                LabelSpan = labelSpan,
+            };
 
             // Maintain a list of all footnotes at document level
             var footnotes = processor.Document.GetData(DocumentKey) as FootnoteGroup;
@@ -83,9 +93,23 @@ namespace Markdig.Extensions.Footnotes
                     return BlockState.ContinueDiscard;
                 }
 
-                if (footnote.IsLastLineEmpty && processor.Start == 0)
+                if (processor.Column == 0)
                 {
-                    return BlockState.Break;
+                    if (footnote.IsLastLineEmpty)
+                    {
+                        // Close the current footnote
+                        processor.Close(footnote);
+
+                        // Parse any opening footnote
+                        return TryOpen(processor);
+                    }
+
+                    // Make sure that consecutive footnotes without a blanklines are parsed correctly
+                    if (TryOpen(processor, true) == BlockState.Continue)
+                    {
+                        processor.Close(footnote);
+                        return BlockState.Continue;
+                    }
                 }
             }
             footnote.IsLastLineEmpty = false;

src/Markdig/Extensions/GenericAttributes/GenericAttributesExtension.cs

@@ -46,17 +46,25 @@ namespace Markdig.Extensions.GenericAttributes
             // Try to find if there is any attributes { in the info string on the first line of a FencedCodeBlock
             if (line.Start < line.End)
             {
-                var indexOfAttributes = line.Text.LastIndexOf('{', line.End);
+                int indexOfAttributes = line.IndexOf('{');
                 if (indexOfAttributes >= 0)
                 {
                     // Work on a copy
                     var copy = line;
                     copy.Start = indexOfAttributes;
+                    var startOfAttributes = copy.Start;
                     HtmlAttributes attributes;
                     if (GenericAttributesParser.TryParse(ref copy, out attributes))
                     {
                         var htmlAttributes = block.GetAttributes();
                         attributes.CopyTo(htmlAttributes);
+
+                        // Update position for HtmlAttributes
+                        htmlAttributes.Line = processor.LineIndex;
+                        htmlAttributes.Column = startOfAttributes - processor.CurrentLineStartPosition; // This is not accurate with tabs!
+                        htmlAttributes.Span.Start = startOfAttributes;
+                        htmlAttributes.Span.End = copy.Start - 1;
+
                         line.End = indexOfAttributes - 1;
                         return true;
                     }

src/Markdig/Extensions/GenericAttributes/GenericAttributesParser.cs

@@ -28,6 +28,7 @@ namespace Markdig.Extensions.GenericAttributes
         public override bool Match(InlineProcessor processor, ref StringSlice slice)
         {
             HtmlAttributes attributes;
+            var startPosition = slice.Start;
             if (TryParse(ref slice, out attributes))
             {
                 var inline = processor.Inline;
@@ -63,7 +64,15 @@ namespace Markdig.Extensions.GenericAttributes
                 }
 
                 var currentHtmlAttributes = objectToAttach.GetAttributes();
-                attributes.CopyTo(currentHtmlAttributes);
+                attributes.CopyTo(currentHtmlAttributes, false, false);
+
+                // Update the position of the attributes
+                int line;
+                int column;
+                currentHtmlAttributes.Span.Start = processor.GetSourcePosition(startPosition, out line, out column);
+                currentHtmlAttributes.Line = line;
+                currentHtmlAttributes.Column = column;
+                currentHtmlAttributes.Span.End = currentHtmlAttributes.Span.Start + slice.Start - startPosition - 1;
 
                 // We don't set the processor.Inline as we don't want to add attach attributes to a particular entity
                 return true;

src/Markdig/Extensions/ListExtras/ListExtraExtension.cs

@@ -5,7 +5,7 @@
 using Markdig.Parsers;
 using Markdig.Renderers;
 
-namespace Markdig.Extensions.ListExtra
+namespace Markdig.Extensions.ListExtras
 {
     /// <summary>
     /// Extension for adding new type of list items (a., A., i., I.)

src/Markdig/Extensions/ListExtras/ListExtraItemParser.cs

@@ -5,7 +5,7 @@
 using Markdig.Helpers;
 using Markdig.Parsers;
 
-namespace Markdig.Extensions.ListExtra
+namespace Markdig.Extensions.ListExtras
 {
     /// <summary>
     /// Parser that adds supports for parsing alpha/roman list items (e.g: `a)` or `a.` or `ii.` or `II.`)

src/Markdig/Extensions/Mathematics/MathInlineParser.cs

@@ -5,6 +5,7 @@
 using Markdig.Helpers;
 using Markdig.Parsers;
 using Markdig.Renderers.Html;
+using Markdig.Syntax;
 
 namespace Markdig.Extensions.Mathematics
 {
@@ -12,7 +13,7 @@ namespace Markdig.Extensions.Mathematics
     /// An inline parser for <see cref="MathInline"/>.
     /// </summary>
     /// <seealso cref="Markdig.Parsers.InlineParser" />
-    /// <seealso cref="Markdig.Parsers.IDelimiterProcessor" />
+    /// <seealso cref="IPostInlineProcessor" />
     public class MathInlineParser : InlineParser
     {
         /// <summary>
@@ -38,6 +39,8 @@ namespace Markdig.Extensions.Mathematics
                 return false;
             }
 
+            var startPosition = slice.Start;
+
             // Match the opened $ or $$
             int openDollars = 1; // we have at least a $
             var c = slice.NextChar();
@@ -63,13 +66,6 @@ namespace Markdig.Extensions.Mathematics
             pc = match;
             while (c != '\0')
             {
-                // Count new '\n'
-                if (c == '\n')
-                {
-                    processor.LocalLineIndex++;
-                    processor.LineIndex++;
-                }
-
                 // Don't process sticks if we have a '\' as a previous char
                 if (pc != '\\' )
                 {
@@ -107,8 +103,13 @@ namespace Markdig.Extensions.Mathematics
                 }
 
                 // Create a new MathInline
+                int line;
+                int column;
                 var inline = new MathInline()
                 {
+                    Span = new SourceSpan(processor.GetSourcePosition(startPosition, out line, out column), processor.GetSourcePosition(slice.End)),
+                    Line = line,
+                    Column = column,
                     Delimiter = match,
                     DelimiterCount = openDollars,
                     Content = slice

src/Markdig/Extensions/MediaLinks/MediaLinkExtension.cs

@@ -1,25 +1,26 @@
 // 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 Markdig.Renderers;
 using Markdig.Renderers.Html;
 using Markdig.Renderers.Html.Inlines;
 using Markdig.Syntax.Inlines;
 
-namespace Markdig.Extensions.Medias
+namespace Markdig.Extensions.MediaLinks
 {
     /// <summary>
     /// Extension for extending image Markdown links in case a video or an audio file is linked and output proper link.
     /// </summary>
     /// <seealso cref="Markdig.IMarkdownExtension" />
-    public class MediaExtension : IMarkdownExtension
+    public class MediaLinkExtension : IMarkdownExtension
     {
-        public MediaExtension() : this(new MediaOptions())
+        public MediaLinkExtension() : this(new MediaOptions())
         {
         }
 
-        public MediaExtension(MediaOptions options)
+        public MediaLinkExtension(MediaOptions options)
         {
             Options = options ?? new MediaOptions();
         }
@@ -49,7 +50,8 @@ namespace Markdig.Extensions.Medias
             if (linkInline.IsImage && linkInline.Url != null)
             {
                 Uri uri;
-                if (Uri.TryCreate(linkInline.Url, UriKind.RelativeOrAbsolute, out uri))
+                // Only process absolute Uri
+                if (Uri.TryCreate(linkInline.Url, UriKind.RelativeOrAbsolute, out uri) && uri.IsAbsoluteUri)
                 {
                     var htmlAttributes = new HtmlAttributes();
                     var fromAttributes = linkInline.TryGetAttributes();

src/Markdig/Extensions/MediaLinks/MediaOptions.cs

@@ -1,13 +1,14 @@
 // 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;
 
-namespace Markdig.Extensions.Medias
+namespace Markdig.Extensions.MediaLinks
 {
     /// <summary>
-    /// Options for the <see cref="MediaExtension"/>.
+    /// Options for the <see cref="MediaLinkExtension"/>.
     /// </summary>
     public class MediaOptions
     {

src/Markdig/Extensions/NoRefLinks/NoFollowLinksExtension.cs

@@ -0,0 +1,34 @@
+// 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.Renderers.Html.Inlines;
+
+namespace Markdig.Extensions.NoRefLinks
+{
+    /// <summary>
+    /// Extension to automatically render rel=nofollow to all links in an HTML output.
+    /// </summary>
+    public class NoFollowLinksExtension : IMarkdownExtension
+    {
+        public void Setup(MarkdownPipelineBuilder pipeline)
+        {
+        }
+
+        public void Setup(IMarkdownRenderer renderer)
+        {
+            var linkRenderer = renderer.ObjectRenderers.Find<LinkInlineRenderer>();
+            if (linkRenderer != null)
+            {
+                linkRenderer.AutoRelNoFollow = true;
+            }
+
+            var autolinkRenderer = renderer.ObjectRenderers.Find<AutolinkInlineRenderer>();
+            if (autolinkRenderer != null)
+            {
+                autolinkRenderer.AutoRelNoFollow = true;
+            }
+        }
+    }
+}

src/Markdig/Extensions/PragmaLines/PragmaLineExtension.cs

@@ -0,0 +1,79 @@
+// 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 Markdig.Helpers;
+using Markdig.Renderers;
+using Markdig.Renderers.Html;
+using Markdig.Syntax;
+using Markdig.Syntax.Inlines;
+
+namespace Markdig.Extensions.PragmaLines
+{
+    /// <summary>
+    /// Extension to a span for each line containing the original line id (using id = pragma-line#line_number_zero_based)
+    /// </summary>
+    /// <seealso cref="Markdig.IMarkdownExtension" />
+    public class PragmaLineExtension : IMarkdownExtension
+    {
+        public void Setup(MarkdownPipelineBuilder pipeline)
+        {
+            pipeline.DocumentProcessed -= PipelineOnDocumentProcessed;
+            pipeline.DocumentProcessed += PipelineOnDocumentProcessed;
+        }
+
+        public void Setup(IMarkdownRenderer renderer)
+        {
+        }
+
+        private static void PipelineOnDocumentProcessed(MarkdownDocument document)
+        {
+            int index = 0;
+            AddPragmas(document, ref index);
+        }
+
+        private static void AddPragmas(Block block, ref int index)
+        {
+            var attribute = block.GetAttributes();
+            var pragmaId = GetPragmaId(block);
+            if ( attribute.Id == null)
+            {
+                attribute.Id = pragmaId;
+            }
+            else if (block.Parent != null)
+            {
+                var heading = block as HeadingBlock;
+
+                // If we have a heading, we will try to add the tag inside it
+                // otherwise we will add it just before
+                var tag = $"<a id=\"{pragmaId}\"></a>";
+                if (heading?.Inline?.FirstChild != null)
+                {
+                    heading.Inline.FirstChild.InsertBefore(new HtmlInline() { Tag = tag });
+
+                }
+                else
+                {
+                    block.Parent.Insert(index, new HtmlBlock(null) { Lines = new StringLineGroup(tag) });
+                    index++;
+                }
+            }
+
+            var container = block as ContainerBlock;
+            if (container != null)
+            {
+                for (int i = 0; i < container.Count; i++)
+                {
+                    var subBlock = container[i];
+                    AddPragmas(subBlock, ref i);
+                }
+            }
+        }
+
+        private static string GetPragmaId(Block block)
+        {
+            return $"pragma-line-{block.Line}";
+        }
+    }
+}

src/Markdig/Extensions/SelfPipeline/SelfPipelineExtension.cs

@@ -0,0 +1,99 @@
+// 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 Markdig.Renderers;
+
+namespace Markdig.Extensions.SelfPipeline
+{
+    /// <summary>
+    /// Extension to enable SelfPipeline, to configure a Markdown parsing/convertion to HTML automatically 
+    /// from an embedded special tag in the input text <code>&lt;!--markdig:extensions--&gt;</code> where extensions is a string
+    /// that specifies the extensions to use for the pipeline as exposed by <see cref="MarkdownExtensions.Configure"/> extension method
+    /// on the <see cref="MarkdownPipelineBuilder"/>. This extension will invalidate all other extensions and will override them.
+    /// </summary>
+    public sealed class SelfPipelineExtension : IMarkdownExtension
+    {
+        public const string DefaultTag = "markdig";
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SelfPipelineExtension"/> class.
+        /// </summary>
+        /// <param name="tag">The matching start tag.</param>
+        /// <param name="defaultExtensions">The default extensions.</param>
+        /// <exception cref="System.ArgumentException">Tag cannot contain `<`  or `>` characters</exception>
+        public SelfPipelineExtension(string tag = null, string defaultExtensions = null)
+        {
+            tag = tag?.Trim();
+            tag = string.IsNullOrEmpty(tag) ? DefaultTag : tag;
+            if (tag.IndexOfAny(new []{'<', '>'}) >= 0)
+            {
+                throw new ArgumentException("Tag cannot contain `<`  or `>` characters", nameof(tag));
+            }
+
+            if (defaultExtensions != null)
+            {
+                // Check that this default pipeline is supported
+                // Will throw an ArgumentInvalidException if not
+                new MarkdownPipelineBuilder().Configure(defaultExtensions);
+            }
+            DefaultExtensions = defaultExtensions;
+            SelfPipelineHintTagStart = "<!--" + tag + ":";
+        }
+
+        /// <summary>
+        /// Gets the default pipeline to configure if no tag was found in the input text. Default is <c>null</c> (core pipeline).
+        /// </summary>
+        public string DefaultExtensions { get; }
+
+        /// <summary>
+        /// Gets the self pipeline hint tag start that will be matched.
+        /// </summary>
+        public string SelfPipelineHintTagStart { get; }
+
+        public void Setup(MarkdownPipelineBuilder pipeline)
+        {
+            // Make sure that this pipeline has only one extension (itself)
+            if (pipeline.Extensions.Count > 1)
+            {
+                throw new InvalidOperationException(
+                    "The SelfPipeline extension cannot be configured with other extensions");
+            }
+        }
+
+        public void Setup(IMarkdownRenderer renderer)
+        {
+        }
+
+        /// <summary>
+        /// Creates a pipeline automatically configured from an input markdown based on the presence of the configuration tag.
+        /// </summary>
+        /// <param name="inputText">The input text.</param>
+        /// <returns>The pipeline configured from the input</returns>
+        /// <exception cref="System.ArgumentNullException"></exception>
+        public MarkdownPipeline CreatePipelineFromInput(string inputText)
+        {
+            if (inputText == null) throw new ArgumentNullException(nameof(inputText));
+
+            var builder = new MarkdownPipelineBuilder();
+            string defaultConfig = DefaultExtensions;
+            var indexOfSelfPipeline = inputText.IndexOf(SelfPipelineHintTagStart, StringComparison.OrdinalIgnoreCase);
+            if (indexOfSelfPipeline >= 0)
+            {
+                var optionStart = indexOfSelfPipeline + SelfPipelineHintTagStart.Length;
+                var endOfTag = inputText.IndexOf("-->", optionStart, StringComparison.OrdinalIgnoreCase);
+                if (endOfTag >= 0)
+                {
+                    defaultConfig = inputText.Substring(optionStart, endOfTag - optionStart).Trim();
+                }
+            }
+
+            if (!string.IsNullOrEmpty(defaultConfig))
+            {
+                builder.Configure(defaultConfig);
+            }
+            return builder.Build();
+        }
+    }
+}

src/Markdig/Extensions/SmartyPants/SmartyPantsExtension.cs

@@ -28,10 +28,10 @@ namespace Markdig.Extensions.SmartyPants
 
         public void Setup(MarkdownPipelineBuilder pipeline)
         {
-            if (!pipeline.InlineParsers.Contains<SmaryPantsInlineParser>())
+            if (!pipeline.InlineParsers.Contains<SmartyPantsInlineParser>())
             {
                 // Insert the parser after the code span parser
-                pipeline.InlineParsers.InsertAfter<CodeInlineParser>(new SmaryPantsInlineParser());
+                pipeline.InlineParsers.InsertAfter<CodeInlineParser>(new SmartyPantsInlineParser());
             }
         }
 

src/Markdig/Extensions/SmartyPants/SmartyPantsInlineParser.cs

@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using Markdig.Helpers;
 using Markdig.Parsers;
+using Markdig.Syntax;
 using Markdig.Syntax.Inlines;
 
 namespace Markdig.Extensions.SmartyPants
@@ -11,14 +12,14 @@ namespace Markdig.Extensions.SmartyPants
     /// <summary>
     /// The inline parser for SmartyPants.
     /// </summary>
-    public class SmaryPantsInlineParser : InlineParser
+    public class SmartyPantsInlineParser : InlineParser, IPostInlineProcessor
     {
         /// <summary>
-        /// Initializes a new instance of the <see cref="SmaryPantsInlineParser"/> class.
+        /// Initializes a new instance of the <see cref="SmartyPantsInlineParser"/> class.
         /// </summary>
-        public SmaryPantsInlineParser()
+        public SmartyPantsInlineParser()
         {
-            OpeningCharacters = new[] {'`', '\'', '"', '<', '>', '.', '-'};
+            OpeningCharacters = new[] {'\'', '"', '<', '>', '.', '-'};
         }
 
         public override bool Match(InlineProcessor processor, ref StringSlice slice)
@@ -30,6 +31,8 @@ namespace Markdig.Extensions.SmartyPants
             // " 	“ ” 	&ldquo; &rdquo; 	'left-double-quote', 'right-double-quote'
             // << >> 	« » 	&laquo; &raquo; 	'left-angle-quote', 'right-angle-quote'
             // ... 	… 	&hellip; 	'ellipsis'
+
+            // Special case: &ndash; and &mdash; are handle as a PostProcess step to avoid conflicts with pipetables header separator row
             // -- 	– 	&ndash; 	'ndash'
             // --- 	— 	&mdash; 	'mdash'
 
@@ -37,18 +40,13 @@ namespace Markdig.Extensions.SmartyPants
             var c = slice.CurrentChar;
             var openingChar = c;
 
+            var startingPosition = slice.Start;
+
             // undefined first
             var type = (SmartyPantType) 0;
 
             switch (c)
             {
-                case '`':
-                    if (slice.PeekChar(1) == '`')
-                    {
-                        slice.NextChar();
-                        type = SmartyPantType.DoubleQuote; // We will resolve them at the end of parsing all inlines
-                    }
-                    break;
                 case '\'':
                     type = SmartyPantType.Quote; // We will resolve them at the end of parsing all inlines
                     if (slice.PeekChar(1) == '\'')
@@ -81,12 +79,9 @@ namespace Markdig.Extensions.SmartyPants
                 case '-':
                     if (slice.NextChar() == '-')
                     {
-                        type = SmartyPantType.Dash2;
-                        if (slice.PeekChar(1) == '-')
-                        {
-                            slice.NextChar();
-                            type = SmartyPantType.Dash3;
-                        }
+                        var quotePants = GetOrCreateState(processor);
+                        quotePants.HasDash = true;
+                        return false;
                     }
                     break;
             }
@@ -161,20 +156,23 @@ namespace Markdig.Extensions.SmartyPants
             }
 
             // Create the SmartyPant inline
+            int line;
+            int column;
             var pant = new SmartyPant()
             {
+                Span = {Start = processor.GetSourcePosition(startingPosition, out line, out column)},
+                Line = line,
+                Column = column,
                 OpeningCharacter = openingChar,
                 Type = type
             };
+            pant.Span.End = pant.Span.Start + slice.Start - startingPosition - 1;
 
             // We will check in a post-process step for balanaced open/close quotes
             if (postProcess)
             {
-                var quotePants = processor.ParserStates[Index] as List<SmartyPant>;
-                if (quotePants == null)
-                {
-                    processor.ParserStates[Index] = quotePants = new List<SmartyPant>();
-                }
+                var quotePants = GetOrCreateState(processor);
+
                 // Register only if we don't have yet any quotes
                 if (quotePants.Count == 0)
                 {
@@ -187,11 +185,21 @@ namespace Markdig.Extensions.SmartyPants
             return true;
         }
 
+        private ListSmartyPants GetOrCreateState(InlineProcessor processor)
+        {
+            var quotePants = processor.ParserStates[Index] as ListSmartyPants;
+            if (quotePants == null)
+            {
+                processor.ParserStates[Index] = quotePants = new ListSmartyPants();
+            }
+            return quotePants;
+        }
+
         private void BlockOnProcessInlinesEnd(InlineProcessor processor, Inline inline)
         {
             processor.Block.ProcessInlinesEnd -= BlockOnProcessInlinesEnd;
 
-            var pants = (List<SmartyPant>) processor.ParserStates[Index];
+            var pants = (ListSmartyPants) processor.ParserStates[Index];
 
             // We only change quote into left or right quotes if we find proper balancing
             var previousIndices = new int[3] {-1, -1, -1};
@@ -241,14 +249,19 @@ namespace Markdig.Extensions.SmartyPants
                 {
                     if (quote.Type == expectedRightQuote)
                     {
-                        // Replace all intermediate unmatched left or right SmartyPants to there literal equivalent
+                        // Replace all intermediate unmatched left or right SmartyPants to their literal equivalent
                         pants.RemoveAt(i);
                         i--;
                         for (int j = i; j > previousIndex; j--)
                         {
                             var toReplace = pants[j];
                             pants.RemoveAt(j);
-                            toReplace.ReplaceBy(new LiteralInline(toReplace.ToString()));
+                            toReplace.ReplaceBy(new LiteralInline(toReplace.ToString())
+                            {
+                                Span = toReplace.Span,
+                                Line = toReplace.Line,
+                                Column = toReplace.Column,
+                            });
                             i--;
                         }
 
@@ -266,10 +279,102 @@ namespace Markdig.Extensions.SmartyPants
             // If we have any quotes lefts, replace them by there literal equivalent
             foreach (var quote in pants)
             {
-                quote.ReplaceBy(new LiteralInline(quote.ToString()));
+                quote.ReplaceBy(new LiteralInline(quote.ToString())
+                {
+                    Span = quote.Span,
+                    Line = quote.Line,
+                    Column = quote.Column,
+                });
             }
 
             pants.Clear();
         }
+
+        bool IPostInlineProcessor.PostProcess(InlineProcessor state, Inline root, Inline lastChild, int postInlineProcessorIndex,
+            bool isFinalProcessing)
+        {
+            // Don't try to process anything if there are no dash
+            var quotePants = state.ParserStates[Index] as ListSmartyPants;
+            if (quotePants == null || !quotePants.HasDash)
+            {
+                return true;
+            }
+
+            var child = root;
+            var pendingContainers = new Stack<Inline>();
+
+            while (true)
+            {
+                while (child != null)
+                {
+                    var next = child.NextSibling;
+
+                    if (child is LiteralInline)
+                    {
+                        var literal = (LiteralInline) child;
+
+                        var startIndex = 0;
+
+                        var indexOfDash = literal.Content.IndexOf("--", startIndex);
+                        if (indexOfDash >= 0)
+                        {
+                            var type = SmartyPantType.Dash2;
+                            if (literal.Content.PeekCharAbsolute(indexOfDash + 2) == '-')
+                            {
+                                type = SmartyPantType.Dash3;
+                            }
+                            var nextContent = literal.Content;
+                            var originalSpan = literal.Span;
+                            literal.Span.End -= literal.Content.End - indexOfDash + 1;
+                            literal.Content.End = indexOfDash - 1;
+                            nextContent.Start = indexOfDash + (type == SmartyPantType.Dash2 ? 2 : 3);
+
+                            var pant = new SmartyPant()
+                            {
+                                Span = new SourceSpan(literal.Content.End + 1, nextContent.Start - 1),
+                                Line = literal.Line,
+                                Column = literal.Column,
+                                OpeningCharacter = '-',
+                                Type = type
+                            };
+                            literal.InsertAfter(pant);
+
+                            var postLiteral = new LiteralInline()
+                            {
+                                Span = new SourceSpan(pant.Span.End + 1, originalSpan.End),
+                                Line = literal.Line,
+                                Column = literal.Column,
+                                Content = nextContent
+                            };
+                            pant.InsertAfter(postLiteral);
+
+                            // Use the pending literal to proceed further
+                            next = postLiteral;
+                        }
+                    }
+                    else if (child is ContainerInline)
+                    {
+                        pendingContainers.Push(((ContainerInline)child).FirstChild);
+                    }
+
+                    child = next;
+                }
+                if (pendingContainers.Count > 0)
+                {
+                    child = pendingContainers.Pop();
+                }
+                else
+                {
+                    break;
+                }
+            }
+            return true;
+        }
+
+
+        private class ListSmartyPants : List<SmartyPant>
+        {
+            public bool HasDash { get; set; }
+        }
     }
 }

src/Markdig/Extensions/Tables/GridTableParser.cs

@@ -29,6 +29,7 @@ namespace Markdig.Extensions.Tables
 
             GridTableState tableState = null;
             var c = line.CurrentChar;
+            var startPosition = processor.Start;
             while (true)
             {
                 if (c == '+')
@@ -51,11 +52,11 @@ namespace Markdig.Extensions.Tables
                         {
                             tableState = new GridTableState()
                             {
-                                Start = processor.Column,
+                                Start = processor.Start,
                                 ExpectRow = true,
                             };
                         }
-                        tableState.AddColumn(startCharacter, line.Start - 1, align);
+                        tableState.AddColumn(startCharacter - startPosition, line.Start - 1 - startPosition, align);
 
                         c = line.CurrentChar;
                         continue;
@@ -105,7 +106,7 @@ namespace Markdig.Extensions.Tables
             var tableState = (GridTableState)block.GetData(typeof(GridTableState));
 
             // We expect to start at the same 
-            if (processor.Start == tableState.Start)
+            //if (processor.Start == tableState.Start)
             {
                 var columns = tableState.ColumnSlices;
 
@@ -130,11 +131,12 @@ namespace Markdig.Extensions.Tables
                     // | ------------- | ------------ | ---------------------------------------- |
                     // Calculate the colspan for the new row
                     int columnIndex = -1;
-                    foreach (var columnSlice in columns)
+                    for (int i = 0; i < columns.Count; i++)
                     {
+                        var columnSlice = columns[i];
                         if (line.PeekCharExtra(columnSlice.Start) == '|')
                         {
-                            columnIndex++;
+                            columnIndex = i;
                         }
                         if (columnIndex >= 0)
                         {
@@ -172,10 +174,10 @@ namespace Markdig.Extensions.Tables
                         var nextColumn = nextColumnIndex < columns.Count ? columns[nextColumnIndex] : null;
 
                         var sliceForCell = line;
-                        sliceForCell.Start = column.Start + 1;
+                        sliceForCell.Start = line.Start + column.Start + 1;
                         if (nextColumn != null)
                         {
-                            sliceForCell.End = nextColumn.Start - 1;
+                            sliceForCell.End = line.Start + nextColumn.Start - 1;
                         }
                         else
                         {
@@ -184,7 +186,7 @@ namespace Markdig.Extensions.Tables
                             // otherwise we allow to have the last cell of a row to be open for longer cell content
                             if (line.PeekCharExtra(columnEnd + 1) == '|')
                             {
-                                sliceForCell.End = columnEnd;
+                                sliceForCell.End = line.Start + columnEnd;
                             }
                         }
                         sliceForCell.TrimEnd();
@@ -208,7 +210,7 @@ namespace Markdig.Extensions.Tables
             // with the 2 slices 
             if (gridTable.Count == 0)
             {
-                var parser = processor.Parsers.Find<ParagraphBlockParser>();
+                var parser = processor.Parsers.FindExact<ParagraphBlockParser>();
                 // Discard the grid table
                 var parent = gridTable.Parent;
                 processor.Discard(gridTable);
@@ -300,8 +302,9 @@ namespace Markdig.Extensions.Tables
         {
             var columns = tableState.ColumnSlices;
             TableRow currentRow = null;
-            foreach (var columnSlice in columns)
+            for (int i = 0; i < columns.Count; i++)
             {
+                var columnSlice = columns[i];
                 if (columnSlice.CurrentCell != null)
                 {
                     if (currentRow == null)
@@ -331,7 +334,8 @@ namespace Markdig.Extensions.Tables
                     // Else we can create a new cell
                     columnSlice.CurrentCell = new TableCell(this)
                     {
-                        ColumnSpan = columnSlice.CurrentColumnSpan
+                        ColumnSpan = columnSlice.CurrentColumnSpan,
+                        ColumnIndex = i
                     };
 
                     if (columnSlice.BlockProcessor == null)

src/Markdig/Extensions/Tables/HtmlTableRenderer.cs

@@ -3,6 +3,7 @@
 // See the license.txt file in the project root for more information.
 
 using System;
+using System.Globalization;
 using Markdig.Renderers;
 using Markdig.Renderers.Html;
 
@@ -38,7 +39,9 @@ namespace Markdig.Extensions.Tables
             {
                 foreach (var tableColumnDefinition in table.ColumnDefinitions)
                 {
-                    renderer.WriteLine($"<col style=\"width:{Math.Round(tableColumnDefinition.Width*100)/100}%\">");
+                    var width = Math.Round(tableColumnDefinition.Width*100)/100;
+                    var widthValue = string.Format(CultureInfo.InvariantCulture, "{0:0.##}", width);
+                    renderer.WriteLine($"<col style=\"width:{widthValue}%\">");
                 }
             }
 
@@ -78,10 +81,10 @@ namespace Markdig.Extensions.Tables
                     {
                         renderer.Write($" colspan=\"{cell.ColumnSpan}\"");
                     }
-
-                    if (table.ColumnDefinitions != null && i < table.ColumnDefinitions.Count)
+                    var columnIndex = cell.ColumnIndex == -1 ? i : cell.ColumnIndex;
+                    if (table.ColumnDefinitions != null && columnIndex < table.ColumnDefinitions.Count)
                     {
-                        switch (table.ColumnDefinitions[i].Alignment)
+                        switch (table.ColumnDefinitions[columnIndex].Alignment)
                         {
                             case TableColumnAlign.Center:
                                 renderer.Write(" style=\"text-align: center;\"");

src/Markdig/Extensions/Tables/PipeTableBlockParser.cs

@@ -0,0 +1,69 @@
+// 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.Helpers;
+using Markdig.Parsers;
+using Markdig.Syntax;
+
+namespace Markdig.Extensions.Tables
+{
+    /// <summary>
+    /// This block parsers for pipe tables is used to by-pass list items that could start by a single '-'
+    /// and would disallow to detect a pipe tables at inline parsing time, so we are basically forcing a line
+    /// that starts by a '-' and have at least a '|' (and have optional spaces) and is a continuation of a
+    /// paragraph.
+    /// </summary>
+    /// <seealso cref="Markdig.Parsers.BlockParser" />
+    public class PipeTableBlockParser : BlockParser
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="PipeTableBlockParser"/> class.
+        /// </summary>
+        public PipeTableBlockParser()
+        {
+            OpeningCharacters = new[] {'-'};
+        }
+
+        public override BlockState TryOpen(BlockProcessor processor)
+        {
+            // Only if we have already a paragraph
+            var paragraph = processor.CurrentBlock as ParagraphBlock;
+            if (processor.IsCodeIndent || paragraph  == null)
+            {
+                return BlockState.None;
+            }
+
+            // We require at least a pipe (and we allow only : - | and space characters)
+            var line = processor.Line;
+            var countPipe = 0;
+            while (true)
+            {
+                var c = line.NextChar();
+                if (c == '\0')
+                {
+                    if (countPipe > 0)
+                    {
+                        // Mark the paragraph as open (important, otherwise we would have an infinite loop)
+                        paragraph.AppendLine(ref processor.Line, processor.Column, processor.LineIndex, processor.Line.Start);
+                        paragraph.IsOpen = true;
+                        return BlockState.BreakDiscard;
+                    }
+
+                    return BlockState.None;
+                }
+                
+                if (c.IsSpace() || c == '-' || c == '|' || c == ':')
+                {
+                    if (c == '|')
+                    {
+                        countPipe++;
+                    }
+                    continue;
+                }
+
+                return BlockState.None;
+            }
+        }
+    }
+}

src/Markdig/Extensions/Tables/PipeTableExtension.cs

@@ -28,6 +28,12 @@ namespace Markdig.Extensions.Tables
 
         public void Setup(MarkdownPipelineBuilder pipeline)
         {
+            // Pipe tables require precise source location
+            pipeline.PreciseSourceLocation = true;
+            if (!pipeline.BlockParsers.Contains<PipeTableBlockParser>())
+            {
+                pipeline.BlockParsers.Insert(0, new PipeTableBlockParser());
+            }
             if (!pipeline.InlineParsers.Contains<PipeTableParser>())
             {
                 pipeline.InlineParsers.InsertBefore<EmphasisInlineParser>(new PipeTableParser(Options));

src/Markdig/Extensions/Tables/PipeTableParser.cs

@@ -15,8 +15,8 @@ namespace Markdig.Extensions.Tables
     /// The inline parser used to transform a <see cref="ParagraphBlock"/> into a <see cref="Table"/> at inline parsing time.
     /// </summary>
     /// <seealso cref="Markdig.Parsers.InlineParser" />
-    /// <seealso cref="Markdig.Parsers.IDelimiterProcessor" />
-    public class PipeTableParser : InlineParser, IDelimiterProcessor
+    /// <seealso cref="IPostInlineProcessor" />
+    public class PipeTableParser : InlineParser, IPostInlineProcessor
     {
         private LineBreakInlineParser lineBreakParser;
 
@@ -55,14 +55,22 @@ namespace Markdig.Extensions.Tables
             // tracking other delimiters on following lines
             var tableState = processor.ParserStates[Index] as TableState;
             bool isFirstLineEmpty = false;
+
+
+            int globalLineIndex;
+            int column;
+            var position = processor.GetSourcePosition(slice.Start, out globalLineIndex, out column);
+            var localLineIndex = globalLineIndex - processor.LineIndex;
+
             if (tableState == null)
             {
+
                 // A table could be preceded by an empty line or a line containing an inline
                 // that has not been added to the stack, so we consider this as a valid 
                 // start for a table. Typically, with this, we can have an attributes {...}
                 // starting on the first line of a pipe table, even if the first line
                 // doesn't have a pipe
-                if (processor.Inline != null &&(processor.LocalLineIndex > 0 || c == '\n'))
+                if (processor.Inline != null && (localLineIndex > 0 || c == '\n'))
                 {
                     return false;
                 }
@@ -92,14 +100,20 @@ namespace Markdig.Extensions.Tables
             }
             else
             {
-                processor.Inline = new PiprTableDelimiterInline(this) { LocalLineIndex = processor.LocalLineIndex };
-                var deltaLine = processor.LocalLineIndex - tableState.LineIndex;
+                processor.Inline = new PiprTableDelimiterInline(this)
+                {
+                    Span = new SourceSpan(position, position),
+                    Line = globalLineIndex,
+                    Column = column,
+                    LocalLineIndex = localLineIndex
+                };
+                var deltaLine = localLineIndex - tableState.LineIndex;
                 if (deltaLine > 0)
                 {
                     tableState.IsInvalidTable = true;
                 }
                 tableState.LineHasPipe = true;
-                tableState.LineIndex = processor.LocalLineIndex;
+                tableState.LineIndex = localLineIndex;
                 slice.NextChar(); // Skip the `|` character
 
                 tableState.ColumnAndLineDelimiters.Add(processor.Inline);
@@ -109,7 +123,7 @@ namespace Markdig.Extensions.Tables
             return true;
         }
 
-        public bool ProcessDelimiters(InlineProcessor state, Inline root, Inline lastChild, int delimiterProcessorIndex, bool isFinalProcessing)
+        public bool PostProcess(InlineProcessor state, Inline root, Inline lastChild, int postInlineProcessorIndex, bool isFinalProcessing)
         {
             var container = root as ContainerInline;
             var tableState = state.ParserStates[Index] as TableState;
@@ -185,7 +199,7 @@ namespace Markdig.Extensions.Tables
             }
 
             // Continue
-            if (tableState == null || container == null || tableState.IsInvalidTable || !tableState.LineHasPipe || tableState.LineIndex != state.LocalLineIndex)
+            if (tableState == null || container == null || tableState.IsInvalidTable || !tableState.LineHasPipe ) //|| tableState.LineIndex != state.LocalLineIndex)
             {
                 return true;
             }
@@ -220,6 +234,12 @@ namespace Markdig.Extensions.Tables
                 column = ((PiprTableDelimiterInline)column).FirstChild;
             }
 
+            // TODO: This is not accurate for the table
+            table.Span.Start = column.Span.Start;
+            table.Span.End = column.Span.End;
+            table.Line = column.Line;
+            table.Column = column.Column;
+            
             int lastIndex = 0;
             for (int i = 0; i < delimiters.Count; i++)
             {
@@ -229,8 +249,7 @@ namespace Markdig.Extensions.Tables
                     var beforeDelimiter = delimiter?.PreviousSibling;
                     var nextLineColumn = delimiter?.NextSibling;
 
-                    var row = new TableRow();
-                    table.Add(row);
+                    TableRow row = null;
 
                     for (int j = lastIndex; j <= i; j++)
                     {
@@ -254,20 +273,52 @@ namespace Markdig.Extensions.Tables
                             continue;
                         }
 
-                        var columnContainer = new ContainerInline();
+                        var cellContainer = new ContainerInline();
                         var item = column;
+                        var isFirstItem = true;
                         TrimStart(item);
                         while (item != null && !IsLine(item) && !(item is PiprTableDelimiterInline))
                         {
                             var nextSibling = item.NextSibling;
                             item.Remove();
-                            columnContainer.AppendChild(item);
+                            cellContainer.AppendChild(item);
+                            if (isFirstItem)
+                            {
+                                cellContainer.Line = item.Line;
+                                cellContainer.Column = item.Column;
+                                cellContainer.Span.Start = item.Span.Start;
+                                isFirstItem = false;
+                            }
+                            cellContainer.Span.End = item.Span.End;
                             item = nextSibling;
                         }
 
-                        var tableCell = new TableCell();
-                        var tableParagraph = new ParagraphBlock() {Inline = columnContainer};
+                        var tableParagraph = new ParagraphBlock()
+                        {
+                            Span = cellContainer.Span,
+                            Line = cellContainer.Line,
+                            Column = cellContainer.Column,
+                            Inline = cellContainer
+                        };
+
+                        var tableCell = new TableCell()
+                        {
+                            Span = cellContainer.Span,
+                            Line = cellContainer.Line,
+                            Column = cellContainer.Column,
+                        };
+
                         tableCell.Add(tableParagraph);
+
+                        if (row == null)
+                        {
+                            row = new TableRow()
+                            {
+                                Span = cellContainer.Span,
+                                Line = cellContainer.Line,
+                                Column = cellContainer.Column,
+                            };
+                        }
                         row.Add(tableCell);
                         cells.Add(tableCell);
 
@@ -291,6 +342,11 @@ namespace Markdig.Extensions.Tables
                         }
                     }
 
+                    if (row != null)
+                    {
+                        table.Add(row);
+                    }
+
                     TrimEnd(beforeDelimiter);
 
                     if (delimiter != null)
@@ -323,20 +379,12 @@ namespace Markdig.Extensions.Tables
             }
 
             // Perform delimiter processor that are coming after this processor
-            var delimiterProcessors = state.Parsers.DelimiterProcessors;
-            for (int i = 0; i < delimiterProcessors.Length; i++)
+            foreach (var cell in cells)
             {
-                if (delimiterProcessors[i] == this)
-                {
-                    foreach (var cell in cells)
-                    {
-                        var paragraph = (ParagraphBlock) cell[0];
-
-                        state.ProcessDelimiters(i + 1, paragraph.Inline, null, true);
-                    }
-                    break;
-                }
+                var paragraph = (ParagraphBlock) cell[0];
+                state.PostProcessInlines(postInlineProcessorIndex + 1, paragraph.Inline, null, true);
             }
+
             // Clear cells when we are done
             cells.Clear();
 
@@ -388,8 +436,8 @@ namespace Markdig.Extensions.Tables
                         }
 
                         // Check the left side of a `|` delimiter
-                        TableColumnAlign align;
-                        if (!ParseHeaderString(delimiter.PreviousSibling, out align))
+                        TableColumnAlign align = TableColumnAlign.Left;
+                        if (delimiter.PreviousSibling != null && !ParseHeaderString(delimiter.PreviousSibling, out align))
                         {
                             break;
                         }

src/Markdig/Extensions/Tables/TableCell.cs

@@ -27,8 +27,14 @@ namespace Markdig.Extensions.Tables
         public TableCell(BlockParser parser) : base(parser)
         {
             ColumnSpan = 1;
+            ColumnIndex = -1;
         }
 
+        /// <summary>
+        /// Gets or sets the index of the column to which this cell belongs.
+        /// </summary>
+        public int ColumnIndex { get; set; }
+
         /// <summary>
         /// Gets or sets the column span this cell is covering. Default is 1.
         /// </summary>

src/Markdig/Extensions/TaskLists/HtmlTaskListRenderer.cs

@@ -0,0 +1,35 @@
+// 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 Markdig.Renderers;
+using Markdig.Renderers.Html;
+
+namespace Markdig.Extensions.TaskLists
+{
+    /// <summary>
+    /// A HTML renderer for a <see cref="TaskList"/>.
+    /// </summary>
+    /// <seealso cref="Markdig.Renderers.Html.HtmlObjectRenderer{TaskList}" />
+    public class HtmlTaskListRenderer : HtmlObjectRenderer<TaskList>
+    {
+        protected override void Write(HtmlRenderer renderer, TaskList obj)
+        {
+            if (renderer.EnableHtmlForInline)
+            {
+                renderer.Write("<input").WriteAttributes(obj).Write(" disabled=\"disabled\" type=\"checkbox\"");
+                if (obj.Checked)
+                {
+                    renderer.Write(" checked=\"checked\"");
+                }
+                renderer.Write(" />");
+            }
+            else
+            {
+                renderer.Write('[');
+                renderer.Write(obj.Checked ? "x" : " ");
+                renderer.Write(']');
+            }
+        }
+    }
+}

src/Markdig/Extensions/TaskLists/TaskList.cs

@@ -0,0 +1,17 @@
+// 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.Diagnostics;
+using Markdig.Syntax.Inlines;
+
+namespace Markdig.Extensions.TaskLists
+{
+    /// <summary>
+    /// An inline for TaskList.
+    /// </summary>
+    [DebuggerDisplay("TaskList {Checked}")]
+    public class TaskList : LeafInline
+    {
+        public bool Checked { get; set; }
+    }
+}

src/Markdig/Extensions/TaskLists/TaskListExtension.cs

@@ -0,0 +1,33 @@
+// 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;
+
+namespace Markdig.Extensions.TaskLists
+{
+    /// <summary>
+    /// Extension to enable TaskList.
+    /// </summary>
+    public class TaskListExtension : IMarkdownExtension
+    {
+        public void Setup(MarkdownPipelineBuilder pipeline)
+        {
+            if (!pipeline.InlineParsers.Contains<TaskListInlineParser>())
+            {
+                // Insert the parser after the code span parser
+                pipeline.InlineParsers.InsertBefore<LinkInlineParser>(new TaskListInlineParser());
+            }
+        }
+
+        public void Setup(IMarkdownRenderer renderer)
+        {
+            var htmlRenderer = renderer as HtmlRenderer;
+            if (htmlRenderer != null)
+            {
+                htmlRenderer.ObjectRenderers.AddIfNotAlready<HtmlTaskListRenderer>();
+            }
+        }
+    }
+}

src/Markdig/Extensions/TaskLists/TaskListInlineParser.cs

@@ -0,0 +1,90 @@
+// 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.Helpers;
+using Markdig.Parsers;
+using Markdig.Renderers.Html;
+using Markdig.Syntax;
+
+namespace Markdig.Extensions.TaskLists
+{
+    /// <summary>
+    /// The inline parser for SmartyPants.
+    /// </summary>
+    public class TaskListInlineParser : InlineParser
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="TaskListInlineParser"/> class.
+        /// </summary>
+        public TaskListInlineParser()
+        {
+            OpeningCharacters = new[] {'['};
+            ListClass = "contains-task-list";
+            ListItemClass = "task-list-item";
+        }
+
+        /// <summary>
+        /// Gets or sets the list class used for a task list.
+        /// </summary>
+        public string ListClass { get; set; }
+
+        /// <summary>
+        /// Gets or sets the list item class used for a task list.
+        /// </summary>
+        public string ListItemClass { get; set; }
+
+        public override bool Match(InlineProcessor processor, ref StringSlice slice)
+        {
+            // A tasklist is either
+            // [ ]
+            // or [x] or [X]
+
+            var listItemBlock = processor.Block.Parent as ListItemBlock;
+
+            if (listItemBlock == null)
+            {
+                return false;
+            }
+
+            var startingPosition = slice.Start;
+            var c = slice.NextChar();
+            if (!c.IsSpace() && c != 'x' && c != 'X')
+            {
+                return false;
+            }
+            if (slice.NextChar() != ']')
+            {
+                return false;
+            }
+            // Skip last ]
+            slice.NextChar();
+
+            // Create the TaskList
+            int line;
+            int column;
+            var taskItem = new TaskList()
+            {
+                Span = { Start = processor.GetSourcePosition(startingPosition, out line, out column)},
+                Line = line,
+                Column = column,
+                Checked = !c.IsSpace()
+            };
+            taskItem.Span.End = taskItem.Span.Start + 2;
+            processor.Inline = taskItem;
+
+            // Add proper class for task list
+            if (!string.IsNullOrEmpty(ListItemClass))
+            {
+                listItemBlock.GetAttributes().AddClass(ListItemClass);
+            }
+
+            var listBlock = (ListBlock) listItemBlock.Parent;
+            if (!string.IsNullOrEmpty(ListClass))
+            {
+                listBlock.GetAttributes().AddClass(ListClass);
+            }
+
+            return true;
+        }
+    }
+}

src/Markdig/Helpers/LineReader.cs

@@ -0,0 +1,71 @@
+// 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.IO;
+using System.Text;
+
+namespace Markdig.Helpers
+{
+    /// <summary>
+    /// A line reader from a <see cref="TextReader"/> that can provide precise source position
+    /// </summary>
+    public struct LineReader
+    {
+        private readonly string text;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LineReader"/> class.
+        /// </summary>
+        /// <exception cref="System.ArgumentNullException"></exception>
+        /// <exception cref="System.ArgumentOutOfRangeException">bufferSize cannot be &lt;= 0</exception>
+        public LineReader(string text)
+        {
+            if (text == null) throw new ArgumentNullException(nameof(text));
+            this.text = text;
+            SourcePosition = 0;
+        }
+
+        /// <summary>
+        /// Gets the char position of the line. Valid for the next line before calling <see cref="ReadLine"/>.
+        /// </summary>
+        public int SourcePosition { get; private set; }
+
+        /// <summary>
+        /// Reads a new line from the underlying <see cref="TextReader"/> and update the <see cref="SourcePosition"/> for the next line.
+        /// </summary>
+        /// <returns>A new line or null if the end of <see cref="TextReader"/> has been reached</returns>
+        public StringSlice? ReadLine()
+        {
+            if (SourcePosition >= text.Length)
+            {
+                return null;
+            }
+
+            var startPosition = SourcePosition;
+            var position = SourcePosition;
+            var slice = new StringSlice(text, startPosition, startPosition);
+            for (;position < text.Length; position++)
+            {
+                var c = text[position];
+                if (c == '\r' || c == '\n')
+                {
+                    slice.End = position - 1;
+                    if (c == '\r' && position + 1 < text.Length && text[position + 1] == '\n')
+                    {
+                        position++;
+                    }
+                    position++;
+                    SourcePosition = position;
+                    return slice;
+                }
+            }
+
+            slice.End = position - 1;
+            SourcePosition = position;
+
+            return slice;
+        }
+   }
+}

src/Markdig/Helpers/LinkHelper.cs

@@ -61,6 +61,11 @@ namespace Markdig.Helpers
                         }
                         previousIsSpace = false;
                     }
+                    else if (c.IsDigit())
+                    {
+                        headingBuffer.Append(c);
+                        previousIsSpace = false;
+                    }
                     else if (!previousIsSpace && c.IsWhitespace())
                     {
                         var pc = headingBuffer[headingBuffer.Length - 1];
@@ -297,10 +302,24 @@ namespace Markdig.Helpers
 
         public static bool TryParseInlineLink(StringSlice text, out string link, out string title)
         {
-            return TryParseInlineLink(ref text, out link, out title);
+            SourceSpan linkSpan;
+            SourceSpan titleSpan;
+            return TryParseInlineLink(ref text, out link, out title, out linkSpan, out titleSpan);
+        }
+
+        public static bool TryParseInlineLink(StringSlice text, out string link, out string title, out SourceSpan linkSpan, out SourceSpan titleSpan)
+        {
+            return TryParseInlineLink(ref text, out link, out title, out linkSpan, out titleSpan);
         }
 
         public static bool TryParseInlineLink(ref StringSlice text, out string link, out string title)
+        {
+            SourceSpan linkSpan;
+            SourceSpan titleSpan;
+            return TryParseInlineLink(ref text, out link, out title, out linkSpan, out titleSpan);
+        }
+
+        public static bool TryParseInlineLink(ref StringSlice text, out string link, out string title, out SourceSpan linkSpan, out SourceSpan titleSpan)
         {
             // 1. An inline link consists of a link text followed immediately by a left parenthesis (, 
             // 2. optional whitespace,  TODO: specs: is it whitespace or multiple whitespaces?
@@ -313,14 +332,25 @@ namespace Markdig.Helpers
             link = null;
             title = null;
 
+            linkSpan = SourceSpan.Empty;
+            titleSpan = SourceSpan.Empty;
+
             // 1. An inline link consists of a link text followed immediately by a left parenthesis (, 
             if (c == '(')
             {
                 text.NextChar();
                 text.TrimStart();
 
+                var pos = text.Start;
                 if (TryParseUrl(ref text, out link))
                 {
+                    linkSpan.Start = pos;
+                    linkSpan.End = text.Start - 1;
+                    if (linkSpan.End < linkSpan.Start)
+                    {
+                        linkSpan = SourceSpan.Empty;
+                    }
+
                     int spaceCount;
                     text.TrimStart(out spaceCount);
                     var hasWhiteSpaces = spaceCount > 0;
@@ -333,12 +363,19 @@ namespace Markdig.Helpers
                     else if (hasWhiteSpaces)
                     {
                         c = text.CurrentChar;
+                        pos = text.Start;
                         if (c == ')')
                         {
                             isValid = true;
                         }
                         else if (TryParseTitle(ref text, out title))
                         {
+                            titleSpan.Start = pos;
+                            titleSpan.End = text.Start - 1;
+                            if (titleSpan.End < titleSpan.Start)
+                            {
+                                titleSpan = SourceSpan.Empty;
+                            }
                             text.TrimStart();
                             c = text.CurrentChar;
 
@@ -582,12 +619,25 @@ namespace Markdig.Helpers
             return TryParseLinkReferenceDefinition(ref text, out label, out url, out title);
         }
 
-        public static bool TryParseLinkReferenceDefinition<T>(ref T text, out string label, out string url, 
-            out string title) where T : ICharIterator
+        public static bool TryParseLinkReferenceDefinition<T>(ref T text, out string label, out string url, out string title)
+            where T : ICharIterator
+        {
+            SourceSpan labelSpan;
+            SourceSpan urlSpan;
+            SourceSpan titleSpan;
+            return TryParseLinkReferenceDefinition(ref text, out label, out url, out title, out labelSpan, out urlSpan,
+                out titleSpan);
+        }
+
+        public static bool TryParseLinkReferenceDefinition<T>(ref T text, out string label, out string url, out string title, out SourceSpan labelSpan, out SourceSpan urlSpan, out SourceSpan titleSpan) where T : ICharIterator
         {
             url = null;
             title = null;
-            if (!TryParseLabel(ref text, out label))
+
+            urlSpan = SourceSpan.Empty;
+            titleSpan = SourceSpan.Empty;
+
+            if (!TryParseLabel(ref text, out label, out labelSpan))
             {
                 return false;
             }
@@ -601,10 +651,13 @@ namespace Markdig.Helpers
 
             // Skip any whitespaces before the url
             text.TrimStart();
+
+            urlSpan.Start = text.Start;
             if (!TryParseUrl(ref text, out url) || string.IsNullOrEmpty(url))
             {
                 return false;
             }
+            urlSpan.End = text.Start - 1;
 
             var saved = text;
             int newLineCount;
@@ -612,8 +665,10 @@ namespace Markdig.Helpers
             var c = text.CurrentChar;
             if (c == '\'' || c == '"' || c == '(')
             {
+                titleSpan.Start = text.Start;
                 if (TryParseTitle(ref text, out title))
                 {
+                    titleSpan.End = text.Start - 1;
                     // If we have a title, it requires a whitespace after the url
                     if (!hasWhiteSpaces)
                     {
@@ -662,24 +717,41 @@ namespace Markdig.Helpers
 
         public static bool TryParseLabel<T>(T lines, out string label) where T : ICharIterator
         {
-            return TryParseLabel(ref lines, false, out label);
+            SourceSpan labelSpan;
+            return TryParseLabel(ref lines, false, out label, out labelSpan);
+        }
+
+        public static bool TryParseLabel<T>(T lines, out string label, out SourceSpan labelSpan) where T : ICharIterator
+        {
+            return TryParseLabel(ref lines, false, out label, out labelSpan);
         }
 
         public static bool TryParseLabel<T>(ref T lines, out string label) where T : ICharIterator
         {
-            return TryParseLabel(ref lines, false, out label);
+            SourceSpan labelSpan;
+            return TryParseLabel(ref lines, false, out label, out labelSpan);
         }
 
-        public static bool TryParseLabel<T>(ref T lines, bool allowEmpty, out string label) where T : ICharIterator
+
+        public static bool TryParseLabel<T>(ref T lines, out string label, out SourceSpan labelSpan) where T : ICharIterator
+        {
+            return TryParseLabel(ref lines, false, out label, out labelSpan);
+        }
+
+        public static bool TryParseLabel<T>(ref T lines, bool allowEmpty, out string label, out SourceSpan labelSpan) where T : ICharIterator
         {
             label = null;
             char c = lines.CurrentChar;
+            labelSpan = SourceSpan.Empty;
             if (c != '[')
             {
                 return false;
             }
             var buffer = StringBuilderCache.Local();
 
+            var startLabel = -1;
+            var endLabel = -1;
+
             bool hasEscape = false;
             bool previousWhitespace = true;
             bool hasNonWhiteSpace = false;
@@ -719,11 +791,19 @@ namespace Markdig.Helpers
                                     break;
                                 }
                                 buffer.Length = i;
+                                endLabel--;
                             }
 
                             // Only valid if buffer is less than 1000 characters
                             if (buffer.Length <= 999)
                             {
+                                labelSpan.Start = startLabel;
+                                labelSpan.End = endLabel;
+                                if (labelSpan.Start > labelSpan.End)
+                                {
+                                    labelSpan = SourceSpan.Empty;
+                                }
+
                                 label = buffer.ToString();
                                 isValid = true;
                             }
@@ -741,6 +821,10 @@ namespace Markdig.Helpers
 
                 if (!hasEscape && c == '\\')
                 {
+                    if (startLabel < 0)
+                    {
+                        startLabel = lines.Start;
+                    }
                     hasEscape = true;
                 }
                 else
@@ -749,6 +833,11 @@ namespace Markdig.Helpers
 
                     if (!previousWhitespace || !isWhitespace)
                     {
+                        if (startLabel < 0)
+                        {
+                            startLabel = lines.Start;
+                        }
+                        endLabel = lines.Start;
                         buffer.Append(c);
                         if (!isWhitespace)
                         {

src/Markdig/Helpers/OrderedList.cs

@@ -101,19 +101,5 @@ namespace Markdig.Helpers
             }
             return false;
         }
-
-        public bool ReplacyBy<TElement>(T element) where TElement : T
-        {
-            if (element == null) throw new ArgumentNullException(nameof(element));
-            for (int i = 0; i < Count; i++)
-            {
-                if (this[i] is TElement)
-                {
-                    this[i] = element;
-                    return true;
-                }
-            }
-            return false;
-        }
     }
 }

src/Markdig/Helpers/StringLine.cs

@@ -23,11 +23,12 @@ namespace Markdig.Helpers
         /// <param name="slice">The slice.</param>
         /// <param name="line">The line.</param>
         /// <param name="column">The column.</param>
-        public StringLine(StringSlice slice, int line, int column)
+        public StringLine(StringSlice slice, int line, int column, int position)
         {
             Slice = slice;
             Line = line;
             Column = column;
+            Position = position;
         }
 
         /// <summary>
@@ -36,11 +37,12 @@ namespace Markdig.Helpers
         /// <param name="slice">The slice.</param>
         /// <param name="line">The line.</param>
         /// <param name="column">The column.</param>
-        public StringLine(ref StringSlice slice, int line, int column)
+        public StringLine(ref StringSlice slice, int line, int column, int position)
         {
             Slice = slice;
             Line = line;
             Column = column;
+            Position = position;
         }
 
         /// <summary>
@@ -53,6 +55,11 @@ namespace Markdig.Helpers
         /// </summary>
         public int Line;
 
+        /// <summary>
+        /// The position of the start of this line within the original source code
+        /// </summary>
+        public int Position;
+
         /// <summary>
         /// The column position.
         /// </summary>

src/Markdig/Helpers/StringLineGroup.cs

@@ -5,7 +5,9 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Runtime.CompilerServices;
+using Markdig.Extensions.Tables;
 
 namespace Markdig.Helpers
 {
@@ -108,15 +110,11 @@ namespace Markdig.Helpers
         /// </summary>
         /// <param name="lineOffsets">The position of the `\n` line offsets from the beginning of the returned slice.</param>
         /// <returns>A single slice concatenating the lines of this instance</returns>
-        public StringSlice ToSlice(List<int> lineOffsets = null)
+        public StringSlice ToSlice(List<LineOffset> lineOffsets = null)
         {
             // Optimization case when no lines
             if (Count == 0)
             {
-                if (lineOffsets != null)
-                {
-                    lineOffsets.Add(1);
-                }
                 return new StringSlice(string.Empty);
             }
 
@@ -125,22 +123,24 @@ namespace Markdig.Helpers
             {
                 if (lineOffsets != null)
                 {
-                    lineOffsets.Add(Lines[0].Slice.End + 1);
+                    lineOffsets.Add(new LineOffset(Lines[0].Position, Lines[0].Column, Lines[0].Slice.Start - Lines[0].Position, Lines[0].Slice.Start, Lines[0].Slice.End + 1));
                 }
                 return Lines[0];
             }
 
             // Else use a builder
             var builder = StringBuilderCache.Local();
+            int previousStartOfLine = 0;
             for (int i = 0; i < Count; i++)
             {
                 if (i > 0)
                 {
                     if (lineOffsets != null)
                     {
-                        lineOffsets.Add(builder.Length + 1); // Add 1 for \n and 1 for next line
+                        lineOffsets.Add(new LineOffset(Lines[i - 1].Position, Lines[i - 1].Column, Lines[i - 1].Slice.Start - Lines[i - 1].Position, previousStartOfLine, builder.Length));
                     }
                     builder.Append('\n');
+                    previousStartOfLine = builder.Length;
                 }
                 if (!Lines[i].Slice.IsEmpty)
                 {
@@ -149,7 +149,7 @@ namespace Markdig.Helpers
             }
             if (lineOffsets != null)
             {
-                lineOffsets.Add(builder.Length); // Add 1 for \0
+                lineOffsets.Add(new LineOffset(Lines[Count - 1].Position, Lines[Count - 1].Column, Lines[Count - 1].Slice.Start - Lines[Count - 1].Position, previousStartOfLine, builder.Length));
             }
             var str = builder.ToString();
             builder.Length = 0;
@@ -265,5 +265,27 @@ namespace Markdig.Helpers
                 return hasSpaces;
             }
         }
+
+        public struct LineOffset
+        {
+            public LineOffset(int linePosition, int column, int offset, int start, int end)
+            {
+                LinePosition = linePosition;
+                Column = column;
+                Offset = offset;
+                Start = start;
+                End = end;
+            }
+
+            public readonly int LinePosition;
+
+            public readonly int Column;
+
+            public readonly int Offset;
+
+            public readonly int Start;
+
+            public readonly int End;
+        }
     }
 }

src/Markdig/Helpers/StringSlice.cs

@@ -112,6 +112,16 @@ namespace Markdig.Helpers
             return index >= Start && index <= End ? Text[index] : (char) 0;
         }
 
+        /// <summary>
+        /// Peeks a character at the specified offset from the current beginning of the string, without taking into account <see cref="Start"/> and <see cref="End"/>
+        /// </summary>
+        /// <returns>The character at offset, returns `\0` if none.</returns>
+        [MethodImpl(MethodImplOptionPortable.AggressiveInlining)]
+        public char PeekCharAbsolute(int index)
+        {
+            return index >= 0 && index < Text.Length ? Text[index] : (char)0;
+        }
+
         /// <summary>
         /// Peeks a character at the specified offset from the current begining of the slice
         /// without using the range <see cref="Start"/> or <see cref="End"/>, returns `\0` if outside the <see cref="Text"/>.
@@ -185,37 +195,48 @@ namespace Markdig.Helpers
         /// </summary>
         /// <param name="text">The text.</param>
         /// <param name="offset">The offset.</param>
+        /// <param name="ignoreCase">true if ignore case</param>
         /// <returns><c>true</c> if the text was found; <c>false</c> otherwise</returns>
-        public bool Search(string text, int offset = 0)
+        public int IndexOf(string text, int offset = 0, bool ignoreCase = false)
         {
             var end = End - text.Length + 1;
-            for (int i = Start; i <= end; i++)
+            if (ignoreCase)
             {
-                if (Match(text, End, i))
+                for (int i = Start + offset; i <= end; i++)
                 {
-                    return true;
+                    if (MatchLowercase(text, End, i - Start))
+                    {
+                        return i; ;
+                    }
                 }
             }
-            return false;
+            else
+            {
+                for (int i = Start + offset; i <= end; i++)
+                {
+                    if (Match(text, End, i - Start))
+                    {
+                        return i; ;
+                    }
+                }
+            }
+            return -1;
         }
 
         /// <summary>
-        /// Searches the specified text within this slice (matching lowercase).
+        /// Searches for the specified character within this slice.
         /// </summary>
-        /// <param name="text">The text.</param>
-        /// <param name="offset">The offset.</param>
-        /// <returns><c>true</c> if the text was found; <c>false</c> otherwise</returns>
-        public bool SearchLowercase(string text, int offset = 0)
+        /// <returns>A value >= 0 if the character was found, otherwise &lt; 0</returns>
+        public int IndexOf(char c)
         {
-            var end = End - text.Length + 1;
-            for (int i = Start; i <= end; i++)
+            for (int i = Start; i <= End; i++)
             {
-                if (MatchLowercase(text, End, i))
+                if (Text[i] == c)
                 {
-                    return true;
+                    return i;
                 }
             }
-            return false;
+            return -1;
         }
 
         /// <summary>

src/Markdig/Markdown.cs

@@ -3,6 +3,7 @@
 // See the license.txt file in the project root for more information.
 using System;
 using System.IO;
+using Markdig.Extensions.SelfPipeline;
 using Markdig.Parsers;
 using Markdig.Renderers;
 using Markdig.Syntax;
@@ -24,61 +25,52 @@ namespace Markdig
         public static string ToHtml(string markdown, MarkdownPipeline pipeline = null)
         {
             if (markdown == null) throw new ArgumentNullException(nameof(markdown));
-            var reader = new StringReader(markdown);
-            return ToHtml(reader, pipeline) ?? string.Empty;
-        }
-
-        /// <summary>
-        /// Converts a Markdown string to HTML.
-        /// </summary>
-        /// <param name="reader">A Markdown text from a <see cref="TextReader"/>.</param>
-        /// <param name="pipeline">The pipeline used for the conversion.</param>
-        /// <returns>The result of the conversion</returns>
-        /// <exception cref="System.ArgumentNullException">if markdown variable is null</exception>
-        public static string ToHtml(TextReader reader, MarkdownPipeline pipeline = null)
-        {
-            if (reader == null) throw new ArgumentNullException(nameof(reader));
             var writer = new StringWriter();
-            ToHtml(reader, writer, pipeline);
+            ToHtml(markdown, writer, pipeline);
             return writer.ToString();
         }
 
         /// <summary>
-        /// Converts a Markdown string to HTML.
+        /// Converts a Markdown string to HTML and output to the specified writer.
         /// </summary>
-        /// <param name="reader">A Markdown text from a <see cref="TextReader"/>.</param>
+        /// <param name="markdown">A Markdown text.</param>
         /// <param name="writer">The destination <see cref="TextWriter"/> that will receive the result of the conversion.</param>
         /// <param name="pipeline">The pipeline used for the conversion.</param>
+        /// <returns>The Markdown document that has been parsed</returns>
         /// <exception cref="System.ArgumentNullException">if reader or writer variable are null</exception>
-        public static void ToHtml(TextReader reader, TextWriter writer, MarkdownPipeline pipeline = null)
+        public static MarkdownDocument ToHtml(string markdown, TextWriter writer, MarkdownPipeline pipeline = null)
         {
-            if (reader == null) throw new ArgumentNullException(nameof(reader));
+            if (markdown == null) throw new ArgumentNullException(nameof(markdown));
             if (writer == null) throw new ArgumentNullException(nameof(writer));
             pipeline = pipeline ?? new MarkdownPipelineBuilder().Build();
+            pipeline = CheckForSelfPipeline(pipeline, markdown);
 
             // We override the renderer with our own writer
             var renderer = new HtmlRenderer(writer);
             pipeline.Setup(renderer);
 
-            var document = Parse(reader, pipeline);
+            var document = Parse(markdown, pipeline);
             renderer.Render(document);
             writer.Flush();
+
+            return document;
         }
 
         /// <summary>
         /// Converts a Markdown string using a custom <see cref="IMarkdownRenderer"/>.
         /// </summary>
-        /// <param name="reader">A Markdown text from a <see cref="TextReader"/>.</param>
+        /// <param name="markdown">A Markdown text.</param>
         /// <param name="renderer">The renderer to convert Markdown to.</param>
         /// <param name="pipeline">The pipeline used for the conversion.</param>
-        /// <exception cref="System.ArgumentNullException">if reader or writer variable are null</exception>
-        public static object Convert(TextReader reader, IMarkdownRenderer renderer, MarkdownPipeline pipeline = null)
+        /// <exception cref="System.ArgumentNullException">if markdown or writer variable are null</exception>
+        public static object Convert(string markdown, IMarkdownRenderer renderer, MarkdownPipeline pipeline = null)
         {
-            if (reader == null) throw new ArgumentNullException(nameof(reader));
+            if (markdown == null) throw new ArgumentNullException(nameof(markdown));
             if (renderer == null) throw new ArgumentNullException(nameof(renderer));
             pipeline = pipeline ?? new MarkdownPipelineBuilder().Build();
 
-            var document = Parse(reader, pipeline);
+            pipeline = CheckForSelfPipeline(pipeline, markdown);
+            var document = Parse(markdown, pipeline);
             pipeline.Setup(renderer);
             return renderer.Render(document);
         }
@@ -92,22 +84,33 @@ namespace Markdig
         public static MarkdownDocument Parse(string markdown)
         {
             if (markdown == null) throw new ArgumentNullException(nameof(markdown));
-            return Parse(new StringReader(markdown));
+            return Parse(markdown, null);
         }
 
         /// <summary>
         /// Parses the specified markdown into an AST <see cref="MarkdownDocument"/>
         /// </summary>
-        /// <param name="reader">A Markdown text from a <see cref="TextReader"/>.</param>
+        /// <param name="markdown">The markdown text.</param>
         /// <param name="pipeline">The pipeline used for the parsing.</param>
         /// <returns>An AST Markdown document</returns>
-        /// <exception cref="System.ArgumentNullException">if reader variable is null</exception>
-        public static MarkdownDocument Parse(TextReader reader, MarkdownPipeline pipeline = null)
+        /// <exception cref="System.ArgumentNullException">if markdown variable is null</exception>
+        public static MarkdownDocument Parse(string markdown, MarkdownPipeline pipeline)
         {
-            if (reader == null) throw new ArgumentNullException(nameof(reader));
+            if (markdown == null) throw new ArgumentNullException(nameof(markdown));
             pipeline = pipeline ?? new MarkdownPipelineBuilder().Build();
 
-            return MarkdownParser.Parse(reader, pipeline);
+            pipeline = CheckForSelfPipeline(pipeline, markdown);
+            return MarkdownParser.Parse(markdown, pipeline);
+        }
+
+        private static MarkdownPipeline CheckForSelfPipeline(MarkdownPipeline pipeline, string markdown)
+        {
+            var selfPipeline = pipeline.Extensions.Find<SelfPipelineExtension>();
+            if (selfPipeline != null)
+            {
+                return selfPipeline.CreatePipelineFromInput(markdown);
+            }
+            return pipeline;
         }
     }
 }

src/Markdig/MarkdownExtensions.cs

@@ -6,21 +6,26 @@ using System;
 using Markdig.Extensions.Abbreviations;
 using Markdig.Extensions.AutoIdentifiers;
 using Markdig.Extensions.Bootstrap;
-using Markdig.Extensions.Cites;
+using Markdig.Extensions.Citations;
 using Markdig.Extensions.CustomContainers;
 using Markdig.Extensions.DefinitionLists;
+using Markdig.Extensions.Diagrams;
 using Markdig.Extensions.Emoji;
-using Markdig.Extensions.EmphasisExtra;
+using Markdig.Extensions.EmphasisExtras;
 using Markdig.Extensions.Figures;
 using Markdig.Extensions.Footers;
 using Markdig.Extensions.Footnotes;
 using Markdig.Extensions.GenericAttributes;
 using Markdig.Extensions.Hardlines;
-using Markdig.Extensions.ListExtra;
+using Markdig.Extensions.ListExtras;
 using Markdig.Extensions.Mathematics;
-using Markdig.Extensions.Medias;
+using Markdig.Extensions.MediaLinks;
+using Markdig.Extensions.NoRefLinks;
+using Markdig.Extensions.PragmaLines;
+using Markdig.Extensions.SelfPipeline;
 using Markdig.Extensions.SmartyPants;
 using Markdig.Extensions.Tables;
+using Markdig.Extensions.TaskLists;
 using Markdig.Parsers;
 using Markdig.Parsers.Inlines;
 
@@ -32,36 +37,100 @@ namespace Markdig
     public static class MarkdownExtensions
     {
         /// <summary>
-        /// Uses all extensions except the Emoji, SmartyPants and soft line as hard line breaks.
+        /// Uses all extensions except the BootStrap, Emoji, SmartyPants and soft line as hard line breaks extensions.
         /// </summary>
         /// <param name="pipeline">The pipeline.</param>
         /// <returns>The modified pipeline</returns>
         public static MarkdownPipelineBuilder UseAdvancedExtensions(this MarkdownPipelineBuilder pipeline)
         {
             return pipeline
-                .UseAbbreviation()
-                .UseAutoIdentifier()
-                .UseBootstrap()
-                .UseCite()
-                .UseCustomContainer()
-                .UseDefinitionList()
-                .UseEmphasisExtra()
-                .UseFigure()
-                .UseFooter()
+                .UseAbbreviations()
+                .UseAutoIdentifiers()
+                .UseCitations()
+                .UseCustomContainers()
+                .UseDefinitionLists()
+                .UseEmphasisExtras()
+                .UseFigures()
+                .UseFooters()
                 .UseFootnotes()
-                .UseGridTable()
-                .UseMath()
-                .UseMedia()
-                .UsePipeTable()
+                .UseGridTables()
+                .UseMathematics()
+                .UseMediaLinks()
+                .UsePipeTables()
+                .UseListExtras()
+                .UseTaskLists()
+                .UseDiagrams()
                 .UseGenericAttributes(); // Must be last as it is one parser that is modifying other parsers
         }
 
+        /// <summary>
+        /// Uses the self pipeline extension that will detect the pipeline to use from the markdown input that contains a special tag. See <see cref="SelfPipelineExtension"/>
+        /// </summary>
+        /// <param name="pipeline">The pipeline.</param>
+        /// <param name="defaultTag">The default tag to use to match the self pipeline configuration. By default, <see cref="SelfPipelineExtension.DefaultTag"/>, meaning that the HTML tag will be &lt;--markdig:extensions--&gt;</param>
+        /// <param name="defaultExtensions">The default extensions to configure if no pipeline setup was found from the Markdown document</param>
+        /// <returns>The modified pipeline</returns>
+        public static MarkdownPipelineBuilder UseSelfPipeline(this MarkdownPipelineBuilder pipeline, string defaultTag = SelfPipelineExtension.DefaultTag, string defaultExtensions = null)
+        {
+            if (pipeline.Extensions.Count != 0)
+            {
+                throw new InvalidOperationException("The SelfPipeline extension cannot be used with other extensions");
+            }
+
+            pipeline.Extensions.Add(new SelfPipelineExtension(defaultTag, defaultExtensions));
+            return pipeline;
+        }
+
+        /// <summary>
+        /// Uses pragma lines to output span with an id containing the line number (pragma-line#line_number_zero_based`)
+        /// </summary>
+        /// <param name="pipeline">The pipeline.</param>
+        /// <returns>The modified pipeline</returns>
+        public static MarkdownPipelineBuilder UsePragmaLines(this MarkdownPipelineBuilder pipeline)
+        {
+            pipeline.Extensions.AddIfNotAlready<PragmaLineExtension>();
+            return pipeline;
+        }
+
+        /// <summary>
+        /// Uses the diagrams extension
+        /// </summary>
+        /// <param name="pipeline">The pipeline.</param>
+        /// <returns>The modified pipeline</returns>
+        public static MarkdownPipelineBuilder UseDiagrams(this MarkdownPipelineBuilder pipeline)
+        {
+            pipeline.Extensions.AddIfNotAlready<DiagramExtension>();
+            return pipeline;
+        }
+
+        /// <summary>
+        /// Uses precise source code location (useful for syntax highlighting).
+        /// </summary>
+        /// <param name="pipeline">The pipeline.</param>
+        /// <returns>The modified pipeline</returns>
+        public static MarkdownPipelineBuilder UsePreciseSourceLocation(this MarkdownPipelineBuilder pipeline)
+        {
+            pipeline.PreciseSourceLocation = true;
+            return pipeline;
+        }
+
+        /// <summary>
+        /// Uses the task list extension.
+        /// </summary>
+        /// <param name="pipeline">The pipeline.</param>
+        /// <returns>The modified pipeline</returns>
+        public static MarkdownPipelineBuilder UseTaskLists(this MarkdownPipelineBuilder pipeline)
+        {
+            pipeline.Extensions.AddIfNotAlready<TaskListExtension>();
+            return pipeline;
+        }
+
         /// <summary>
         /// Uses the custom container extension.
         /// </summary>
         /// <param name="pipeline">The pipeline.</param>
         /// <returns>The modified pipeline</returns>
-        public static MarkdownPipelineBuilder UseCustomContainer(this MarkdownPipelineBuilder pipeline)
+        public static MarkdownPipelineBuilder UseCustomContainers(this MarkdownPipelineBuilder pipeline)
         {
             pipeline.Extensions.AddIfNotAlready<CustomContainerExtension>();
             return pipeline;
@@ -75,11 +144,11 @@ namespace Markdig
         /// <returns>
         /// The modified pipeline
         /// </returns>
-        public static MarkdownPipelineBuilder UseMedia(this MarkdownPipelineBuilder pipeline, MediaOptions options = null)
+        public static MarkdownPipelineBuilder UseMediaLinks(this MarkdownPipelineBuilder pipeline, MediaOptions options = null)
         {
-            if (!pipeline.Extensions.Contains<MediaExtension>())
+            if (!pipeline.Extensions.Contains<MediaLinkExtension>())
             {
-                pipeline.Extensions.Add(new MediaExtension(options));
+                pipeline.Extensions.Add(new MediaLinkExtension(options));
             }
             return pipeline;
         }
@@ -92,7 +161,7 @@ namespace Markdig
         /// <returns>
         /// The modified pipeline
         /// </returns>
-        public static MarkdownPipelineBuilder UseAutoIdentifier(this MarkdownPipelineBuilder pipeline, AutoIdentifierOptions options = AutoIdentifierOptions.Default)
+        public static MarkdownPipelineBuilder UseAutoIdentifiers(this MarkdownPipelineBuilder pipeline, AutoIdentifierOptions options = AutoIdentifierOptions.Default)
         {
             if (!pipeline.Extensions.Contains<AutoIdentifierExtension>())
             {
@@ -119,7 +188,7 @@ namespace Markdig
         }
 
         /// <summary>
-        /// Uses the boostrap extension.
+        /// Uses the bootstrap extension.
         /// </summary>
         /// <param name="pipeline">The pipeline.</param>
         /// <returns>The modified pipeline</returns>
@@ -134,7 +203,7 @@ namespace Markdig
         /// </summary>
         /// <param name="pipeline">The pipeline.</param>
         /// <returns>The modified pipeline</returns>
-        public static MarkdownPipelineBuilder UseMath(this MarkdownPipelineBuilder pipeline)
+        public static MarkdownPipelineBuilder UseMathematics(this MarkdownPipelineBuilder pipeline)
         {
             pipeline.Extensions.AddIfNotAlready<MathExtension>();
             return pipeline;
@@ -145,7 +214,7 @@ namespace Markdig
         /// </summary>
         /// <param name="pipeline">The pipeline.</param>
         /// <returns>The modified pipeline</returns>
-        public static MarkdownPipelineBuilder UseFigure(this MarkdownPipelineBuilder pipeline)
+        public static MarkdownPipelineBuilder UseFigures(this MarkdownPipelineBuilder pipeline)
         {
             pipeline.Extensions.AddIfNotAlready<FigureExtension>();
             return pipeline;
@@ -156,7 +225,7 @@ namespace Markdig
         /// </summary>
         /// <param name="pipeline">The pipeline.</param>
         /// <returns>The modified pipeline</returns>
-        public static MarkdownPipelineBuilder UseAbbreviation(this MarkdownPipelineBuilder pipeline)
+        public static MarkdownPipelineBuilder UseAbbreviations(this MarkdownPipelineBuilder pipeline)
         {
             pipeline.Extensions.AddIfNotAlready<AbbreviationExtension>();
             return pipeline;
@@ -167,7 +236,7 @@ namespace Markdig
         /// </summary>
         /// <param name="pipeline">The pipeline.</param>
         /// <returns>The modified pipeline</returns>
-        public static MarkdownPipelineBuilder UseDefinitionList(this MarkdownPipelineBuilder pipeline)
+        public static MarkdownPipelineBuilder UseDefinitionLists(this MarkdownPipelineBuilder pipeline)
         {
             pipeline.Extensions.AddIfNotAlready<DefinitionListExtension>();
             return pipeline;
@@ -181,7 +250,7 @@ namespace Markdig
         /// <returns>
         /// The modified pipeline
         /// </returns>
-        public static MarkdownPipelineBuilder UsePipeTable(this MarkdownPipelineBuilder pipeline, PipeTableOptions options = null)
+        public static MarkdownPipelineBuilder UsePipeTables(this MarkdownPipelineBuilder pipeline, PipeTableOptions options = null)
         {
             if (!pipeline.Extensions.Contains<PipeTableExtension>())
             {
@@ -195,7 +264,7 @@ namespace Markdig
         /// </summary>
         /// <param name="pipeline">The pipeline.</param>
         /// <returns>The modified pipeline</returns>
-        public static MarkdownPipelineBuilder UseGridTable(this MarkdownPipelineBuilder pipeline)
+        public static MarkdownPipelineBuilder UseGridTables(this MarkdownPipelineBuilder pipeline)
         {
             pipeline.Extensions.AddIfNotAlready<GridTableExtension>();
             return pipeline;
@@ -207,9 +276,9 @@ namespace Markdig
         /// </summary>
         /// <param name="pipeline">The pipeline.</param>
         /// <returns>The modified pipeline</returns>
-        public static MarkdownPipelineBuilder UseCite(this MarkdownPipelineBuilder pipeline)
+        public static MarkdownPipelineBuilder UseCitations(this MarkdownPipelineBuilder pipeline)
         {
-            pipeline.Extensions.AddIfNotAlready<CiteExtension>();
+            pipeline.Extensions.AddIfNotAlready<CitationExtension>();
             return pipeline;
         }
 
@@ -218,7 +287,7 @@ namespace Markdig
         /// </summary>
         /// <param name="pipeline">The pipeline.</param>
         /// <returns>The modified pipeline</returns>
-        public static MarkdownPipelineBuilder UseFooter(this MarkdownPipelineBuilder pipeline)
+        public static MarkdownPipelineBuilder UseFooters(this MarkdownPipelineBuilder pipeline)
         {
             pipeline.Extensions.AddIfNotAlready<FooterExtension>();
             return pipeline;
@@ -254,7 +323,7 @@ namespace Markdig
         /// <returns>
         /// The modified pipeline
         /// </returns>
-        public static MarkdownPipelineBuilder UseEmphasisExtra(this MarkdownPipelineBuilder pipeline, EmphasisExtraOptions options = EmphasisExtraOptions.Default)
+        public static MarkdownPipelineBuilder UseEmphasisExtras(this MarkdownPipelineBuilder pipeline, EmphasisExtraOptions options = EmphasisExtraOptions.Default)
         {
             if (!pipeline.Extensions.Contains<EmphasisExtraExtension>())
             {
@@ -270,7 +339,7 @@ namespace Markdig
         /// <returns>
         /// The modified pipeline
         /// </returns>
-        public static MarkdownPipelineBuilder UseListExtra(this MarkdownPipelineBuilder pipeline)
+        public static MarkdownPipelineBuilder UseListExtras(this MarkdownPipelineBuilder pipeline)
         {
             pipeline.Extensions.AddIfNotAlready<ListExtraExtension>();
             return pipeline;
@@ -298,6 +367,17 @@ namespace Markdig
             return pipeline;
         }
 
+        /// <summary>
+        /// Add rel=nofollow to all links rendered to HTML.
+        /// </summary>
+        /// <param name="pipeline"></param>
+        /// <returns></returns>
+        public static MarkdownPipelineBuilder UseNoFollowLinks(this MarkdownPipelineBuilder pipeline)
+        {
+            pipeline.Extensions.AddIfNotAlready<NoFollowLinksExtension>();
+            return pipeline;
+        }
+
         /// <summary>
         /// This will disable the HTML support in the markdown processor (for constraint/safe parsing).
         /// </summary>
@@ -322,7 +402,7 @@ namespace Markdig
         /// <summary>
         /// Configures the pipeline using a string that defines the extensions to activate.
         /// </summary>
-        /// <param name="pipeline">The pipeline (e.g: advanced for <see cref="UseAdvancedExtensions"/>, pipetables+gridtables for <see cref="UsePipeTable"/> and <see cref="UseGridTable"/></param>
+        /// <param name="pipeline">The pipeline (e.g: advanced for <see cref="UseAdvancedExtensions"/>, pipetables+gridtables for <see cref="UsePipeTables"/> and <see cref="UseGridTables"/></param>
         /// <param name="extensions">The extensions to activate as a string</param>
         /// <returns>The modified pipeline</returns>
         public static MarkdownPipelineBuilder Configure(this MarkdownPipelineBuilder pipeline, string extensions)
@@ -336,17 +416,19 @@ namespace Markdig
             {
                 switch (extension.ToLowerInvariant())
                 {
+                    case "common":
+                        break;
                     case "advanced":
                         pipeline.UseAdvancedExtensions();
                         break;
                     case "pipetables":
-                        pipeline.UsePipeTable();
+                        pipeline.UsePipeTables();
                         break;
-                    case "emphasisextra":
-                        pipeline.UseEmphasisExtra();
+                    case "emphasisextras":
+                        pipeline.UseEmphasisExtras();
                         break;
-                    case "listextra":
-                        pipeline.UseListExtra();
+                    case "listextras":
+                        pipeline.UseListExtras();
                         break;
                     case "hardlinebreak":
                         pipeline.UseSoftlineBreakAsHardlineBreak();
@@ -355,52 +437,61 @@ namespace Markdig
                         pipeline.UseFootnotes();
                         break;
                     case "footers":
-                        pipeline.UseFooter();
+                        pipeline.UseFooters();
                         break;
-                    case "cites":
-                        pipeline.UseCite();
+                    case "citations":
+                        pipeline.UseCitations();
                         break;
                     case "attributes":
                         pipeline.UseGenericAttributes();
                         break;
                     case "gridtables":
-                        pipeline.UseGridTable();
+                        pipeline.UseGridTables();
                         break;
                     case "abbreviations":
-                        pipeline.UseAbbreviation();
+                        pipeline.UseAbbreviations();
                         break;
                     case "emojis":
                         pipeline.UseEmojiAndSmiley();
                         break;
                     case "definitionlists":
-                        pipeline.UseDefinitionList();
+                        pipeline.UseDefinitionLists();
                         break;
                     case "customcontainers":
-                        pipeline.UseCustomContainer();
+                        pipeline.UseCustomContainers();
                         break;
                     case "figures":
-                        pipeline.UseFigure();
+                        pipeline.UseFigures();
                         break;
-                    case "math":
-                        pipeline.UseMath();
+                    case "mathematics":
+                        pipeline.UseMathematics();
                         break;
                     case "bootstrap":
                         pipeline.UseBootstrap();
                         break;
-                    case "medias":
-                        pipeline.UseMedia();
+                    case "medialinks":
+                        pipeline.UseMediaLinks();
                         break;
                     case "smartypants":
                         pipeline.UseSmartyPants();
                         break;
                     case "autoidentifiers":
-                        pipeline.UseAutoIdentifier();
+                        pipeline.UseAutoIdentifiers();
+                        break;
+                    case "tasklists":
+                        pipeline.UseTaskLists();
+                        break;
+                    case "diagrams":
+                        pipeline.UseDiagrams();
+                        break;
+                    case "nofollowlinks":
+                        pipeline.UseNoFollowLinks();
                         break;
                     default:
-                        throw new ArgumentException($"unknown extension {extension}");
+                        throw new ArgumentException($"Invalid extension `{extension}` from `{extensions}`", nameof(extensions));
                 }
             }
             return pipeline;
         }
     }
-}
+}

src/Markdig/MarkdownPipeline.cs

@@ -31,6 +31,9 @@ namespace Markdig
             DebugLog = debugLog;
             DocumentProcessed = documentProcessed;
         }
+
+        internal bool PreciseSourceLocation { get; set; }
+
         internal OrderedList<IMarkdownExtension> Extensions { get; }
 
         internal BlockParserList BlockParsers { get; }
@@ -44,7 +47,11 @@ namespace Markdig
 
         internal ProcessDocumentDelegate DocumentProcessed;
 
-        internal void Setup(IMarkdownRenderer renderer)
+        /// <summary>
+        /// Allows to setup a <see cref="IMarkdownRenderer"/>.
+        /// </summary>
+        /// <param name="renderer">The markdown renderer to setup</param>
+        public void Setup(IMarkdownRenderer renderer)
         {
             if (renderer == null) throw new ArgumentNullException(nameof(renderer));
             foreach (var extension in Extensions)

src/Markdig/MarkdownPipelineBuilder.cs

@@ -73,6 +73,11 @@ namespace Markdig
         /// </summary>
         public StringBuilderCache StringBuilderCache { get; set; }
 
+        /// <summary>
+        /// Gets or sets a value indicating whether to enable precise source location (slower parsing but accurate position for block and inline elements)
+        /// </summary>
+        public bool PreciseSourceLocation { get; set; }
+
         /// <summary>
         /// Gets or sets the debug log.
         /// </summary>
@@ -111,7 +116,9 @@ namespace Markdig
                 extension.Setup(this);
             }
 
-            pipeline = new MarkdownPipeline(new OrderedList<IMarkdownExtension>(Extensions), new BlockParserList(BlockParsers), new InlineParserList(InlineParsers), StringBuilderCache, DebugLog, GetDocumentProcessed);
+            pipeline = new MarkdownPipeline(new OrderedList<IMarkdownExtension>(Extensions),
+                new BlockParserList(BlockParsers), new InlineParserList(InlineParsers), StringBuilderCache, DebugLog,
+                GetDocumentProcessed) {PreciseSourceLocation = PreciseSourceLocation};
             return pipeline;
         }
     }

src/Markdig/Parsers/BlockProcessor.cs

@@ -98,6 +98,11 @@ namespace Markdig.Parsers
         /// </summary>
         public StringSlice Line;
 
+        /// <summary>
+        /// Gets or sets the current line start position.
+        /// </summary>
+        public int CurrentLineStartPosition { get; private set; }
+
         /// <summary>
         /// Gets the index of the line in the source text.
         /// </summary>
@@ -260,12 +265,10 @@ namespace Markdig.Parsers
         public void GoToColumn(int newColumn)
         {
             // Optimized path when we are moving above the previous start of indent
-            if (newColumn > ColumnBeforeIndent)
+            if (newColumn >= ColumnBeforeIndent)
             {
                 Line.Start = StartBeforeIndent;
                 Column = ColumnBeforeIndent;
-                ColumnBeforeIndent = 0;
-                StartBeforeIndent = 0;
             }
             else
             {
@@ -367,6 +370,8 @@ namespace Markdig.Parsers
         /// <param name="newLine">The new line.</param>
         public void ProcessLine(StringSlice newLine)
         {
+            CurrentLineStartPosition = newLine.Start;
+
             ContinueProcessingLine = true;
 
             ResetLine(newLine);
@@ -548,7 +553,7 @@ namespace Markdig.Parsers
                     ContinueProcessingLine = false;
                     if (!result.IsDiscard())
                     {
-                        leaf.AppendLine(ref Line, Column, LineIndex);
+                        leaf.AppendLine(ref Line, Column, LineIndex, CurrentLineStartPosition);
                     }
 
                     if (NewBlocks.Count > 0)
@@ -585,8 +590,16 @@ namespace Markdig.Parsers
         /// </summary>
         private void TryOpenBlocks()
         {
+            int previousStart = -1;
             while (ContinueProcessingLine)
             {
+                // Security check so that the parser can't go into a crazy infinite loop if one extension is messing
+                if (previousStart == Start)
+                {
+                    throw new InvalidOperationException($"The parser is in an invalid infinite loop while trying to parse blocks at line [{LineIndex}] with line [{Line}]");
+                }
+                previousStart = Start;
+
                 // Eat indent spaces before checking the character
                 ParseIndent();
 
@@ -671,7 +684,7 @@ namespace Markdig.Parsers
 
                     if (!result.IsDiscard())
                     {
-                        paragraph.AppendLine(ref Line, Column, LineIndex);
+                        paragraph.AppendLine(ref Line, Column, LineIndex, CurrentLineStartPosition);
                     }
 
                     // We have just found a lazy continuation for a paragraph, early exit
@@ -724,7 +737,7 @@ namespace Markdig.Parsers
                 {
                     if (!result.IsDiscard())
                     {
-                        leaf.AppendLine(ref Line, Column, LineIndex);
+                        leaf.AppendLine(ref Line, Column, LineIndex, CurrentLineStartPosition);
                     }
 
                     if (newBlocks.Count > 0)

src/Markdig/Parsers/FencedBlockParserBase.cs

@@ -128,6 +128,8 @@ namespace Markdig.Parsers
                 return BlockState.None;
             }
 
+            var startPosition = processor.Start;
+
             // Match fenced char
             int count = 0;
             var line = processor.Line;
@@ -157,6 +159,8 @@ namespace Markdig.Parsers
                 fenced.Column = processor.Column;
                 fenced.FencedChar = matchChar;
                 fenced.FencedCharCount = count;
+                fenced.Span.Start = startPosition;
+                fenced.Span.End = line.Start;
             };
 
             // Try to parse any attached attributes
@@ -212,6 +216,8 @@ namespace Markdig.Parsers
             // The line must contain only fence opening character followed only by whitespaces.
             if (count <=0 && !processor.IsCodeIndent && (c == '\0' || c.IsWhitespace()) && line.TrimEnd())
             {
+                block.UpdateSpanEnd(line.Start - 1);
+
                 // Don't keep the last line
                 return BlockState.BreakDiscard;
             }

src/Markdig/Parsers/FencedCodeBlockParser.cs

@@ -12,13 +12,15 @@ namespace Markdig.Parsers
     /// <seealso cref="Markdig.Parsers.BlockParser" />
     public class FencedCodeBlockParser : FencedBlockParserBase<FencedCodeBlock>
     {
+        public const string DefaultInfoPrefix = "language-";
+
         /// <summary>
         /// Initializes a new instance of the <see cref="FencedCodeBlockParser"/> class.
         /// </summary>
         public FencedCodeBlockParser()
         {
             OpeningCharacters = new[] {'`', '~'};
-            InfoPrefix = "language-";
+            InfoPrefix = DefaultInfoPrefix;
         }
 
         protected override FencedCodeBlock CreateFencedBlock(BlockProcessor processor)

src/Markdig/Parsers/HeadingBlockParser.cs

@@ -46,6 +46,7 @@ namespace Markdig.Parsers
             // opening sequence.
             var column = processor.Column;
             var line = processor.Line;
+            var sourcePosition = line.Start;
             var c = line.CurrentChar;
             var matchingChar = c;
 
@@ -61,17 +62,18 @@ namespace Markdig.Parsers
             }
 
             // A space is required after leading #
-            if (leadingCount > 0 && leadingCount <= 6 && (c.IsSpace() || c == '\0'))
+            if (leadingCount > 0 && leadingCount <= 6 && (c.IsSpaceOrTab() || c == '\0'))
             {
                 // Move to the content
-                processor.Line.Start = line.Start + 1;
                 var headingBlock = new HeadingBlock(this)
                 {
                     HeaderChar = matchingChar,
                     Level = leadingCount,
-                    Column = column
+                    Column = column,
+                    Span = { Start =  sourcePosition }
                 };
                 processor.NewBlocks.Push(headingBlock);
+                processor.GoToColumn(column + leadingCount + 1);
 
                 // Gives a chance to parse attributes
                 if (TryParseAttributes != null)
@@ -87,7 +89,7 @@ namespace Markdig.Parsers
                     c = processor.Line.Text[i];
                     if (endState == 0)
                     {
-                        if (c.IsSpace()) // TODO: Not clear if it is a space or space+tab in the specs
+                        if (c.IsSpaceOrTab())
                         {
                             continue;
                         }
@@ -103,7 +105,7 @@ namespace Markdig.Parsers
 
                         if (countClosingTags > 0)
                         {
-                            if (c.IsSpace())
+                            if (c.IsSpaceOrTab())
                             {
                                 processor.Line.End = i - 1;
                             }
@@ -116,6 +118,9 @@ namespace Markdig.Parsers
                     }
                 }
 
+                // Setup the source end position of this element
+                headingBlock.Span.End = processor.Line.End;
+
                 // We expect a single line, so don't continue
                 return BlockState.Break;
             }

src/Markdig/Parsers/HtmlBlockParser.cs

@@ -47,18 +47,19 @@ namespace Markdig.Parsers
             }
 
             var line = state.Line;
+            var startPosition = line.Start;
             line.NextChar();
-            var result = TryParseTagType16(state, line, state.ColumnBeforeIndent);
+            var result = TryParseTagType16(state, line, state.ColumnBeforeIndent, startPosition);
 
             // HTML blocks of type 7 cannot interrupt a paragraph:
             if (result == BlockState.None && !(state.CurrentBlock is ParagraphBlock))
             {
-                result = TryParseTagType7(state, line, state.ColumnBeforeIndent);
+                result = TryParseTagType7(state, line, state.ColumnBeforeIndent, startPosition);
             }
             return result;
         }
 
-        private BlockState TryParseTagType7(BlockProcessor state, StringSlice line, int startColumn)
+        private BlockState TryParseTagType7(BlockProcessor state, StringSlice line, int startColumn, int startPosition)
         {
             var builder = StringBuilderCache.Local();
             var c = line.CurrentChar;
@@ -84,7 +85,7 @@ namespace Markdig.Parsers
 
                 if (hasOnlySpaces)
                 {
-                    result = CreateHtmlBlock(state, HtmlBlockType.NonInterruptingBlock, startColumn);
+                    result = CreateHtmlBlock(state, HtmlBlockType.NonInterruptingBlock, startColumn, startPosition);
                 }
             }
 
@@ -92,7 +93,7 @@ namespace Markdig.Parsers
             return result;
         }
 
-        private BlockState TryParseTagType16(BlockProcessor state, StringSlice line, int startColumn)
+        private BlockState TryParseTagType16(BlockProcessor state, StringSlice line, int startColumn, int startPosition)
         {
             char c;
             c = line.CurrentChar;
@@ -101,15 +102,15 @@ namespace Markdig.Parsers
                 c = line.NextChar();
                 if (c == '-' && line.PeekChar(1) == '-')
                 {
-                    return CreateHtmlBlock(state, HtmlBlockType.Comment, startColumn); // group 2
+                    return CreateHtmlBlock(state, HtmlBlockType.Comment, startColumn, startPosition); // group 2
                 }
                 if (c.IsAlphaUpper())
                 {
-                    return CreateHtmlBlock(state, HtmlBlockType.DocumentType, startColumn); // group 4
+                    return CreateHtmlBlock(state, HtmlBlockType.DocumentType, startColumn, startPosition); // group 4
                 }
                 if (c == '[' && line.Match("CDATA[", 1))
                 {
-                    return CreateHtmlBlock(state, HtmlBlockType.CData, startColumn); // group 5
+                    return CreateHtmlBlock(state, HtmlBlockType.CData, startColumn, startPosition); // group 5
                 }
 
                 return BlockState.None;
@@ -117,7 +118,7 @@ namespace Markdig.Parsers
 
             if (c == '?')
             {
-                return CreateHtmlBlock(state, HtmlBlockType.ProcessingInstruction, startColumn); // group 3
+                return CreateHtmlBlock(state, HtmlBlockType.ProcessingInstruction, startColumn, startPosition); // group 3
             }
 
             var hasLeadingClose = c == '/';
@@ -164,71 +165,117 @@ namespace Markdig.Parsers
                 {
                     return BlockState.None;
                 }
-                return CreateHtmlBlock(state, HtmlBlockType.ScriptPreOrStyle, startColumn);
+                return CreateHtmlBlock(state, HtmlBlockType.ScriptPreOrStyle, startColumn, startPosition);
             }
 
-            return CreateHtmlBlock(state, HtmlBlockType.InterruptingBlock, startColumn);
+            return CreateHtmlBlock(state, HtmlBlockType.InterruptingBlock, startColumn, startPosition);
         }
 
+        private const string EndOfComment = "-->";
+        private const string EndOfCDATA = "]]>";
+        private const string EndOfProcessingInstruction = "?>";
+
+
         private BlockState MatchEnd(BlockProcessor state, HtmlBlock htmlBlock)
         {
             state.GoToColumn(state.ColumnBeforeIndent);
 
             // Early exit if it is not starting by an HTML tag
             var line = state.Line;
-            var c = line.CurrentChar;
+            var result = BlockState.Continue;
+            int index;
             switch (htmlBlock.Type)
             {
                 case HtmlBlockType.Comment:
-                    if (line.Search("-->"))
+                    index = line.IndexOf(EndOfComment);
+                    if (index >= 0)
                     {
-                        return BlockState.Break;
+                        htmlBlock.UpdateSpanEnd(index + EndOfComment.Length);
+                        result = BlockState.Break;
                     }
                     break;
                 case HtmlBlockType.CData:
-                    if (line.Search("]]>"))
+                    index = line.IndexOf(EndOfCDATA);
+                    if (index >= 0)
                     {
-                        return BlockState.Break;
+                        htmlBlock.UpdateSpanEnd(index + EndOfCDATA.Length);
+                        result = BlockState.Break;
                     }
                     break;
                 case HtmlBlockType.ProcessingInstruction:
-                    if (line.Search("?>"))
+                    index = line.IndexOf(EndOfProcessingInstruction);
+                    if (index >= 0)
                     {
-                        return BlockState.Break;
+                        htmlBlock.UpdateSpanEnd(index + EndOfProcessingInstruction.Length);
+                        result = BlockState.Break;
                     }
                     break;
                 case HtmlBlockType.DocumentType:
-                    if (line.Search(">"))
+                    index = line.IndexOf('>');
+                    if (index >= 0)
                     {
-                        return BlockState.Break;
+                        htmlBlock.UpdateSpanEnd(index + 1);
+                        result = BlockState.Break;
                     }
                     break;
                 case HtmlBlockType.ScriptPreOrStyle:
-                    if (line.SearchLowercase("</script>") || line.SearchLowercase("</pre>") || line.SearchLowercase("</style>"))
+                    index = line.IndexOf("</script>", 0, true);
+                    if (index >= 0)
                     {
-                        return BlockState.Break;
+                        htmlBlock.UpdateSpanEnd(index + "</script>".Length);
+                        result = BlockState.Break;
+                    }
+                    else
+                    {
+                        index = line.IndexOf("</pre>", 0, true);
+                        if (index >= 0)
+                        {
+                            htmlBlock.UpdateSpanEnd(index + "</pre>".Length);
+                            result = BlockState.Break;
+                        }
+                        else
+                        {
+                            index = line.IndexOf("</style>", 0, true);
+                            if (index >= 0)
+                            {
+                                htmlBlock.UpdateSpanEnd(index + "</style>".Length);
+                                result = BlockState.Break;
+                            }
+                        }
                     }
                     break;
                 case HtmlBlockType.InterruptingBlock:
                     if (state.IsBlankLine)
                     {
-                        return BlockState.BreakDiscard;
+                        result = BlockState.BreakDiscard;
                     }
                     break;
                 case HtmlBlockType.NonInterruptingBlock:
                     if (state.IsBlankLine)
                     {
-                        return BlockState.BreakDiscard;
+                        result = BlockState.BreakDiscard;
                     }
                     break;
             }
 
-            return BlockState.Continue;
+            // Update only if we don't have a break discard
+            if (result != BlockState.BreakDiscard)
+            {
+                htmlBlock.Span.End = line.End;
+            }
+
+            return result;
         }
 
-        private BlockState CreateHtmlBlock(BlockProcessor state, HtmlBlockType type, int startColumn)
+        private BlockState CreateHtmlBlock(BlockProcessor state, HtmlBlockType type, int startColumn, int startPosition)
         {
-            state.NewBlocks.Push(new HtmlBlock(this) {Column = startColumn, Type = type});
+            state.NewBlocks.Push(new HtmlBlock(this)
+            {
+                Column = startColumn,
+                Type = type,
+                // By default, setup to the end of line
+                Span = new SourceSpan(startPosition, startPosition + state.Line.End)
+            });
             return BlockState.Continue;
         }
 

src/Markdig/Parsers/IPostInlineProcessor.cs

@@ -6,9 +6,9 @@ using Markdig.Syntax.Inlines;
 namespace Markdig.Parsers
 {
     /// <summary>
-    /// A procesor used for <see cref="DelimiterInline"/>.
+    /// A procesor called at the end of processing all inlines.
     /// </summary>
-    public interface IDelimiterProcessor
+    public interface IPostInlineProcessor
     {
         /// <summary>
         /// Processes the delimiters.
@@ -16,10 +16,10 @@ namespace Markdig.Parsers
         /// <param name="state">The parser state.</param>
         /// <param name="root">The root inline.</param>
         /// <param name="lastChild">The last child.</param>
-        /// <param name="delimiterProcessorIndex">Index of this delimiter processor.</param>
+        /// <param name="postInlineProcessorIndex">Index of this delimiter processor.</param>
         /// <param name="isFinalProcessing"></param>
         /// <returns><c>true</c> to continue to the next delimiter processor; 
         /// <c>false</c> to stop the process (in case a processor is perfoming sub-sequent processor itself)</returns>
-        bool ProcessDelimiters(InlineProcessor state, Inline root, Inline lastChild, int delimiterProcessorIndex, bool isFinalProcessing);
+        bool PostProcess(InlineProcessor state, Inline root, Inline lastChild, int postInlineProcessorIndex, bool isFinalProcessing);
     }
 }

src/Markdig/Parsers/IndentedCodeBlockParser.cs

@@ -18,10 +18,16 @@ namespace Markdig.Parsers
 
         public override BlockState TryOpen(BlockProcessor processor)
         {
+            var startColumn = processor.ColumnBeforeIndent;
+            var startPosition = processor.StartBeforeIndent;
             var result = TryContinue(processor, null);
             if (result == BlockState.Continue)
             {
-                processor.NewBlocks.Push(new CodeBlock(this) { Column = processor.Column });
+                processor.NewBlocks.Push(new CodeBlock(this)
+                {
+                    Column = startColumn,
+                    Span = new SourceSpan(startPosition, processor.Line.End)
+                });
             }
             return result;
         }
@@ -37,10 +43,14 @@ namespace Markdig.Parsers
             }
 
             // If we don't have a blank line, we reset to the indent
-            if (processor.Indent >= 4)
+            if (processor.Indent > 4)
             {
                 processor.GoToCodeIndent();
             }
+            if (block != null)
+            {
+                block.UpdateSpanEnd(processor.Line.End);
+            }
             return BlockState.Continue;
         }
 

src/Markdig/Parsers/InlineParserList.cs

@@ -20,23 +20,23 @@ namespace Markdig.Parsers
         }
 
         /// <summary>
-        /// Gets the registered delimiter processors.
+        /// Gets the registered post inline processors.
         /// </summary>
-        public IDelimiterProcessor[] DelimiterProcessors { get; private set; }
+        public IPostInlineProcessor[] PostInlineProcessors { get; private set; }
 
         public override void Initialize(InlineProcessor initState)
         {
-            // Prepare the list of delimiter processors
-            var delimiterProcessors = new List<IDelimiterProcessor>();
+            // Prepare the list of post inline processors
+            var postInlineProcessors = new List<IPostInlineProcessor>();
             foreach (var parser in this)
             {
-                var delimProcessor = parser as IDelimiterProcessor;
+                var delimProcessor = parser as IPostInlineProcessor;
                 if (delimProcessor != null)
                 {
-                    delimiterProcessors.Add(delimProcessor);
+                    postInlineProcessors.Add(delimProcessor);
                 }
             }
-            DelimiterProcessors = delimiterProcessors.ToArray();
+            PostInlineProcessors = postInlineProcessors.ToArray();
 
             base.Initialize(initState);
         }

src/Markdig/Parsers/InlineProcessor.cs

@@ -23,7 +23,9 @@ namespace Markdig.Parsers
     /// </summary>
     public class InlineProcessor
     {
-        private readonly List<int> lineOffsets;
+        private readonly List<StringLineGroup.LineOffset> lineOffsets;
+        private int previousSliceOffset;
+        private int previousLineIndexForSliceOffset;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="InlineProcessor" /> class.
@@ -34,7 +36,7 @@ namespace Markdig.Parsers
         /// <param name="inlineCreated">The inline created event.</param>
         /// <exception cref="System.ArgumentNullException">
         /// </exception>
-        public InlineProcessor(StringBuilderCache stringBuilders, MarkdownDocument document, InlineParserList parsers)
+        public InlineProcessor(StringBuilderCache stringBuilders, MarkdownDocument document, InlineParserList parsers, bool preciseSourcelocation)
         {
             if (stringBuilders == null) throw new ArgumentNullException(nameof(stringBuilders));
             if (document == null) throw new ArgumentNullException(nameof(document));
@@ -42,7 +44,8 @@ namespace Markdig.Parsers
             StringBuilders = stringBuilders;
             Document = document;
             Parsers = parsers;
-            lineOffsets = new List<int>();
+            PreciseSourceLocation = preciseSourcelocation;
+            lineOffsets = new List<StringLineGroup.LineOffset>();
             Parsers.Initialize(this);
             ParserStates = new object[Parsers.Count];
             LiteralInlineParser = new LiteralInlineParser();
@@ -53,6 +56,11 @@ namespace Markdig.Parsers
         /// </summary>
         public LeafBlock Block { get; private set; }
 
+        /// <summary>
+        /// Gets a value indicating whether to provide precise source location.
+        /// </summary>
+        public bool PreciseSourceLocation { get; }
+
         /// <summary>
         /// Gets or sets the new block to replace the block being processed.
         /// </summary>
@@ -86,12 +94,7 @@ namespace Markdig.Parsers
         /// <summary>
         /// Gets or sets the index of the line from the begining of the document being processed.
         /// </summary>
-        public int LineIndex { get; set; }
-
-        /// <summary>
-        /// Gets or sets the index of the local line from the beginning of the block being processed.
-        /// </summary>
-        public int LocalLineIndex { get; set; }
+        public int LineIndex { get; private set; }
 
         /// <summary>
         /// Gets the parser states that can be used by <see cref="InlineParser"/> using their <see cref="InlineParser.Index"/> property.
@@ -108,12 +111,68 @@ namespace Markdig.Parsers
         /// </summary>
         public LiteralInlineParser LiteralInlineParser { get; }
 
+
+        public int GetSourcePosition(int sliceOffset)
+        {
+            int column;
+            int lineIndex;
+            return GetSourcePosition(sliceOffset, out lineIndex, out column);
+        }
+
+        public SourceSpan GetSourcePositionFromLocalSpan(SourceSpan span)
+        {
+            if (span.IsEmpty)
+            {
+                return SourceSpan.Empty;
+            }
+
+            int column;
+            int lineIndex;
+            return new SourceSpan(GetSourcePosition(span.Start, out lineIndex, out column), GetSourcePosition(span.End, out lineIndex, out column));
+        }
+
+        /// <summary>
+        /// Gets the source position for the specified offset within the current slice.
+        /// </summary>
+        /// <param name="sliceOffset">The slice offset.</param>
+        /// <returns>The source position</returns>
+        public int GetSourcePosition(int sliceOffset, out int lineIndex, out int column)
+        {
+            column = 0;            
+            lineIndex = sliceOffset >= previousSliceOffset ? previousLineIndexForSliceOffset : 0;
+            int position = 0;
+            if (PreciseSourceLocation)
+            {
+                for (; lineIndex < lineOffsets.Count; lineIndex++)
+                {
+                    var lineOffset = lineOffsets[lineIndex];
+                    if (sliceOffset <= lineOffset.End)
+                    {
+                        // Use the beginning of the line as a previous slice offset 
+                        // (since it is on the same line)
+                        previousSliceOffset = lineOffsets[lineIndex].Start;
+                        var delta = sliceOffset - previousSliceOffset;
+                        column = lineOffsets[lineIndex].Column + delta;
+                        position = lineOffset.LinePosition + delta + lineOffsets[lineIndex].Offset;
+                        previousLineIndexForSliceOffset = lineIndex;
+
+                        // Return an absolute line index
+                        lineIndex = lineIndex + LineIndex;
+                        break;
+                    }
+                }
+            }
+            return position;
+        }
+
         /// <summary>
         /// Processes the inline of the specified <see cref="LeafBlock"/>.
         /// </summary>
         /// <param name="leafBlock">The leaf block.</param>
         public void ProcessInlineLeaf(LeafBlock leafBlock)
         {
+            if (leafBlock == null) throw new ArgumentNullException(nameof(leafBlock));
+
             // clear parser states
             Array.Clear(ParserStates, 0, ParserStates.Length);
 
@@ -124,21 +183,24 @@ namespace Markdig.Parsers
             BlockNew = null;
             LineIndex = leafBlock.Line;
 
+            previousSliceOffset = 0;
+            previousLineIndexForSliceOffset = 0;
             lineOffsets.Clear();
-            LocalLineIndex = 0;
             var text = leafBlock.Lines.ToSlice(lineOffsets);
             leafBlock.Lines = new StringLineGroup();
 
+            int previousStart = -1;
+
             while (!text.IsEmpty)
             {
-                var c = text.CurrentChar;
-
-                // Update line index
-                if (text.Start >= lineOffsets[LocalLineIndex])
+                // Security check so that the parser can't go into a crazy infinite loop if one extension is messing
+                if (previousStart == text.Start)
                 {
-                    LineIndex++;
-                    LocalLineIndex++;
+                    throw new InvalidOperationException($"The parser is in an invalid infinite loop while trying to parse inlines for block [{leafBlock.GetType().Name}] at position ({leafBlock.ToPositionText()}");
                 }
+                previousStart = text.Start;
+
+                var c = text.CurrentChar;
 
                 var textSaved = text;
                 var parsers = Parsers.GetParsersForOpeningCharacter(c);
@@ -206,8 +268,8 @@ namespace Markdig.Parsers
                 leafBlock.Inline.DumpTo(DebugLog);
             }
 
-            // Process all delimiters
-            ProcessDelimiters(0, Root, null, true);
+            // PostProcess all inlines
+            PostProcessInlines(0, Root, null, true);
 
             //TransformDelimitersToLiterals();
 
@@ -219,12 +281,12 @@ namespace Markdig.Parsers
             }
         }
 
-        public void ProcessDelimiters(int startingIndex, Inline root, Inline lastChild, bool isFinalProcessing)
+        public void PostProcessInlines(int startingIndex, Inline root, Inline lastChild, bool isFinalProcessing)
         {
-            for (int i = startingIndex; i < Parsers.DelimiterProcessors.Length; i++)
+            for (int i = startingIndex; i < Parsers.PostInlineProcessors.Length; i++)
             {
-                var delimiterProcessor = Parsers.DelimiterProcessors[i];
-                if (!delimiterProcessor.ProcessDelimiters(this, root, lastChild, i, isFinalProcessing))
+                var postInlineProcessor = Parsers.PostInlineProcessors[i];
+                if (!postInlineProcessor.PostProcess(this, root, lastChild, i, isFinalProcessing))
                 {
                     break;
                 }

src/Markdig/Parsers/Inlines/AutolineInlineParser.cs

@@ -2,6 +2,7 @@
 // This file is licensed under the BSD-Clause 2 license. 
 // See the license.txt file in the project root for more information.
 using Markdig.Helpers;
+using Markdig.Syntax;
 using Markdig.Syntax.Inlines;
 
 namespace Markdig.Parsers.Inlines
@@ -31,9 +32,18 @@ namespace Markdig.Parsers.Inlines
             string link;
             bool isEmail;
             var saved = slice;
+            int line;
+            int column;
             if (LinkHelper.TryParseAutolink(ref slice, out link, out isEmail))
             {
-                processor.Inline = new AutolinkInline() {IsEmail = isEmail, Url = link};
+                processor.Inline = new AutolinkInline()
+                {
+                    IsEmail = isEmail,
+                    Url = link,
+                    Span = new SourceSpan(processor.GetSourcePosition(saved.Start, out line, out column), processor.GetSourcePosition(slice.Start - 1)),
+                    Line = line,
+                    Column = column
+                };
             }
             else if (EnableHtmlParsing)
             {
@@ -44,7 +54,13 @@ namespace Markdig.Parsers.Inlines
                     return false;
                 }
 
-                processor.Inline = new HtmlInline() { Tag = htmlTag };
+                processor.Inline = new HtmlInline()
+                {
+                    Tag = htmlTag,
+                    Span = new SourceSpan(processor.GetSourcePosition(saved.Start, out line, out column), processor.GetSourcePosition(slice.Start - 1)),
+                    Line = line,
+                    Column = column
+                };
             }
 
             return true;

src/Markdig/Parsers/Inlines/CodeInlineParser.cs

@@ -2,6 +2,7 @@
 // This file is licensed under the BSD-Clause 2 license. 
 // See the license.txt file in the project root for more information.
 using Markdig.Helpers;
+using Markdig.Syntax;
 using Markdig.Syntax.Inlines;
 
 namespace Markdig.Parsers.Inlines
@@ -29,6 +30,8 @@ namespace Markdig.Parsers.Inlines
                 return false;
             }
 
+            var startPosition = slice.Start;
+
             // Match the opened sticks
             var c = slice.CurrentChar;
             while (c == match)
@@ -98,15 +101,17 @@ namespace Markdig.Parsers.Inlines
                         builder.Length--;
                     }
                 }
+                int line;
+                int column;
                 processor.Inline = new CodeInline()
                 {
                     Delimiter = match,
-                    Content = builder.ToString()
+                    Content = builder.ToString(),
+                    Span = new SourceSpan(processor.GetSourcePosition(startPosition, out line, out column), processor.GetSourcePosition(slice.Start - 1)),
+                    Line = line,
+                    Column = column
                 };
                 isMatching = true;
-
-                processor.LocalLineIndex += newLinesFound;
-                processor.LineIndex += newLinesFound;
             }
 
             // Release the builder if not used

src/Markdig/Parsers/Inlines/EmphasisInlineParser.cs

@@ -15,8 +15,8 @@ namespace Markdig.Parsers.Inlines
     /// An inline parser for <see cref="EmphasisInline"/>.
     /// </summary>
     /// <seealso cref="Markdig.Parsers.InlineParser" />
-    /// <seealso cref="Markdig.Parsers.IDelimiterProcessor" />
-    public class EmphasisInlineParser : InlineParser, IDelimiterProcessor
+    /// <seealso cref="IPostInlineProcessor" />
+    public class EmphasisInlineParser : InlineParser, IPostInlineProcessor
     {
         private CharacterMap<EmphasisDescriptor> emphasisMap;
         private readonly DelimitersObjectCache inlinesCache;
@@ -85,7 +85,7 @@ namespace Markdig.Parsers.Inlines
             emphasisMap = new CharacterMap<EmphasisDescriptor>(tempMap);
         }
 
-        public bool ProcessDelimiters(InlineProcessor state, Inline root, Inline lastChild, int delimiterProcessorIndex, bool isFinalProcessing)
+        public bool PostProcess(InlineProcessor state, Inline root, Inline lastChild, int postInlineProcessorIndex, bool isFinalProcessing)
         {
             var container = root as ContainerInline;
             if (container == null)
@@ -144,6 +144,8 @@ namespace Markdig.Parsers.Inlines
                 return false;
             }
 
+            var startPosition = slice.Start;
+
             int delimiterCount = 0;
             char c;
             do
@@ -177,10 +179,15 @@ namespace Markdig.Parsers.Inlines
                     delimiterType |= DelimiterType.Close;
                 }
 
+                int line;
+                int column;
                 var delimiter = new EmphasisDelimiterInline(this, emphasisDesc)
                 {
                     DelimiterCount = delimiterCount,
                     Type = delimiterType,
+                    Span = new SourceSpan(processor.GetSourcePosition(startPosition, out line, out column), processor.GetSourcePosition(slice.Start - 1)),
+                    Column = column,
+                    Line = line,
                 };
 
                 processor.Inline = delimiter;
@@ -218,9 +225,15 @@ namespace Markdig.Parsers.Inlines
                         for (int j = i - 1; j >= 0; j--)
                         {
                             var previousOpenDelimiter = delimiters[j];
+
+                            var isOddMatch = ((closeDelimiter.Type & DelimiterType.Open) != 0 ||
+                                             (previousOpenDelimiter.Type & DelimiterType.Close) != 0) &&
+                                             previousOpenDelimiter.DelimiterCount != closeDelimiter.DelimiterCount &&
+                                             (previousOpenDelimiter.DelimiterCount + closeDelimiter.DelimiterCount) % 3 == 0;
+
                             if (previousOpenDelimiter.DelimiterChar == closeDelimiter.DelimiterChar &&
                                 (previousOpenDelimiter.Type & DelimiterType.Open) != 0 &&
-                                previousOpenDelimiter.DelimiterCount > 0)
+                                previousOpenDelimiter.DelimiterCount > 0 && !isOddMatch)
                             {
                                 openDelimiter = previousOpenDelimiter;
                                 openDelimiterIndex = j;
@@ -241,6 +254,24 @@ namespace Markdig.Parsers.Inlines
                                     IsDouble = isStrong
                                 };
 
+                            // Update position for emphasis
+                            var openDelimitercount = openDelimiter.DelimiterCount;
+                            var closeDelimitercount = closeDelimiter.DelimiterCount;
+                            var delimiterDelta = isStrong ? 2 : 1;
+
+                            emphasis.Span.Start = openDelimiter.Span.Start;
+                            emphasis.Line = openDelimiter.Line;
+                            emphasis.Column = openDelimiter.Column;
+                            emphasis.Span.End = closeDelimiter.Span.End - closeDelimitercount + delimiterDelta;
+
+                            openDelimiter.Span.Start += delimiterDelta;
+                            openDelimiter.Column += delimiterDelta;
+                            closeDelimiter.Span.Start += delimiterDelta;
+                            closeDelimiter.Column += delimiterDelta;
+
+                            openDelimiter.DelimiterCount -= delimiterDelta;
+                            closeDelimiter.DelimiterCount -= delimiterDelta;
+
                             var embracer = (ContainerInline)openDelimiter;
 
                             // Go down to the first emphasis with a lower level
@@ -267,9 +298,6 @@ namespace Markdig.Parsers.Inlines
                             // Embrace all delimiters
                             embracer.EmbraceChildrenBy(emphasis);
 
-                            openDelimiter.DelimiterCount -= isStrong ? 2 : 1;
-                            closeDelimiter.DelimiterCount -= isStrong ? 2 : 1;
-
                             // Remove any intermediate emphasis
                             for (int k = i - 1; k >= openDelimiterIndex + 1; k--)
                             {
@@ -277,7 +305,10 @@ namespace Markdig.Parsers.Inlines
                                 var literal = new LiteralInline()
                                 {
                                     Content = new StringSlice(literalDelimiter.ToLiteral()),
-                                    IsClosed = true
+                                    IsClosed = true,
+                                    Span = literalDelimiter.Span,
+                                    Line = literalDelimiter.Line,
+                                    Column = literalDelimiter.Column
                                 };
 
                                 literalDelimiter.ReplaceBy(literal);
@@ -327,7 +358,10 @@ namespace Markdig.Parsers.Inlines
                             var literal = new LiteralInline()
                             {
                                 Content = new StringSlice(closeDelimiter.ToLiteral()),
-                                IsClosed = true
+                                IsClosed = true,
+                                Span = closeDelimiter.Span,
+                                Line = closeDelimiter.Line,
+                                Column = closeDelimiter.Column
                             };
 
                             closeDelimiter.ReplaceBy(literal);
@@ -351,7 +385,10 @@ namespace Markdig.Parsers.Inlines
                 var literal = new LiteralInline()
                 {
                     Content = new StringSlice(delimiter.ToLiteral()),
-                    IsClosed = true
+                    IsClosed = true,
+                    Span = delimiter.Span,
+                    Line = delimiter.Line,
+                    Column = delimiter.Column
                 };
 
                 delimiter.ReplaceBy(literal);

src/Markdig/Parsers/Inlines/EscapeInlineParser.cs

@@ -19,11 +19,21 @@ namespace Markdig.Parsers.Inlines
 
         public override bool Match(InlineProcessor processor, ref StringSlice slice)
         {
+            var startPosition = slice.Start;
             // Go to escape character
             var c = slice.NextChar();
+            int line;
+            int column;
             if (c.IsAsciiPunctuation())
             {
-                processor.Inline = new LiteralInline() {Content = new StringSlice(new string(c, 1))};
+                processor.Inline = new LiteralInline()
+                {
+                    Content = new StringSlice(new string(c, 1)),
+                    Span = { Start = processor.GetSourcePosition(startPosition, out line, out column) },
+                    Line = line,
+                    Column = column
+                };
+                processor.Inline.Span.End = processor.Inline.Span.Start + 1;
                 slice.NextChar();
                 return true;
             }
@@ -31,7 +41,14 @@ namespace Markdig.Parsers.Inlines
             // A backslash at the end of the line is a [hard line break]:
             if (c == '\n')
             {
-                processor.Inline = new HardlineBreakInline();
+                processor.Inline = new LineBreakInline()
+                {
+                    IsHard = true,
+                    Span = { Start = processor.GetSourcePosition(startPosition, out line, out column) },
+                    Line = line,
+                    Column = column
+                };
+                processor.Inline.Span.End = processor.Inline.Span.Start + 1;
                 slice.NextChar();
                 return true;
             }

src/Markdig/Parsers/Inlines/HtmlEntityParser.cs

@@ -2,6 +2,7 @@
 // This file is licensed under the BSD-Clause 2 license. 
 // See the license.txt file in the project root for more information.
 using Markdig.Helpers;
+using Markdig.Syntax;
 using Markdig.Syntax.Inlines;
 
 namespace Markdig.Parsers.Inlines
@@ -24,6 +25,7 @@ namespace Markdig.Parsers.Inlines
         {
             string entityName;
             int entityValue;
+            var startPosition = slice.Start;
             int match = HtmlHelper.ScanEntity(slice.Text, slice.Start, slice.Length, out entityName, out entityValue);
             if (match == 0)
             {
@@ -43,11 +45,16 @@ namespace Markdig.Parsers.Inlines
             if (literal != null)
             {
                 var matched = slice;
-                matched.End = match - 1;
+                matched.End = slice.Start + match - 1;
+                int line;
+                int column;
                 processor.Inline = new HtmlEntityInline()
                 {
                     Original = matched,
-                    Transcoded = new StringSlice(literal)
+                    Transcoded = new StringSlice(literal),
+                    Span = new SourceSpan(processor.GetSourcePosition(startPosition, out line, out column), processor.GetSourcePosition(matched.End)),
+                    Line = line,
+                    Column = column
                 };
                 slice.Start = slice.Start + match;
                 return true;

src/Markdig/Parsers/Inlines/LineBreakInlineParser.cs

@@ -8,7 +8,7 @@ using Markdig.Syntax.Inlines;
 namespace Markdig.Parsers.Inlines
 {
     /// <summary>
-    /// An inline parser for <see cref="SoftlineBreakInline"/> and <see cref="HardlineBreakInline"/>.
+    /// An inline parser for <see cref="LineBreakInline"/>.
     /// </summary>
     /// <seealso cref="Markdig.Parsers.InlineParser" />
     public class LineBreakInlineParser : InlineParser
@@ -34,10 +34,20 @@ namespace Markdig.Parsers.Inlines
                 return false;
             }
 
+            var startPosition = slice.Start;
             var hasDoubleSpacesBefore = slice.PeekCharExtra(-1).IsSpace() && slice.PeekCharExtra(-2).IsSpace();
             slice.NextChar(); // Skip \n
 
-            processor.Inline = !EnableSoftAsHard && (slice.Start == 0 || !hasDoubleSpacesBefore) ? (Inline)new SoftlineBreakInline() : new HardlineBreakInline();
+            int line;
+            int column;
+            processor.Inline = new LineBreakInline
+            {
+                Span = { Start = processor.GetSourcePosition(startPosition, out line, out column)},
+                IsHard = EnableSoftAsHard || (slice.Start != 0 && hasDoubleSpacesBefore),
+                Line = line,
+                Column = column
+            };
+            processor.Inline.Span.End = processor.Inline.Span.Start;
             return true;
         }
     }

src/Markdig/Parsers/Inlines/LinkInlineParser.cs

@@ -28,6 +28,10 @@ namespace Markdig.Parsers.Inlines
 
             var c = slice.CurrentChar;
 
+            int line;
+            int column;
+            var startPosition = processor.GetSourcePosition(slice.Start, out line, out column);
+
             bool isImage = false;
             if (c == '!')
             {
@@ -47,8 +51,9 @@ namespace Markdig.Parsers.Inlines
                     var saved = slice;
                     string label;
 
+                    SourceSpan labelSpan;
                     // If the label is followed by either a ( or a [, this is not a shortcut
-                    if (LinkHelper.TryParseLabel(ref slice, out label))
+                    if (LinkHelper.TryParseLabel(ref slice, out label, out labelSpan))
                     {
                         if (!processor.Document.ContainsLinkReferenceDefinition(label))
                         {
@@ -63,7 +68,11 @@ namespace Markdig.Parsers.Inlines
                     {
                         Type = DelimiterType.Open,
                         Label = label,
-                        IsImage = isImage
+                        LabelSpan = processor.GetSourcePositionFromLocalSpan(labelSpan),
+                        IsImage = isImage,
+                        Span = new SourceSpan(startPosition, processor.GetSourcePosition(slice.Start - 1)),
+                        Line = line,
+                        Column = column
                     };
                     return true;
 
@@ -86,7 +95,7 @@ namespace Markdig.Parsers.Inlines
             return false;
         }
 
-        private bool ProcessLinkReference(InlineProcessor state, string label, bool isImage, Inline child = null)
+        private bool ProcessLinkReference(InlineProcessor state, string label, SourceSpan labelSpan, LinkDelimiterInline parent, int endPosition)
         {
             bool isValidLink = false;
             LinkReferenceDefinition linkRef;
@@ -96,7 +105,7 @@ namespace Markdig.Parsers.Inlines
                 // Try to use a callback directly defined on the LinkReferenceDefinition
                 if (linkRef.CreateLinkInline != null)
                 {
-                    link = linkRef.CreateLinkInline(state, linkRef, child);
+                    link = linkRef.CreateLinkInline(state, linkRef, parent.FirstChild);
                 }
 
                 // Create a default link if the callback was not found
@@ -107,19 +116,30 @@ namespace Markdig.Parsers.Inlines
                     {
                         Url = HtmlHelper.Unescape(linkRef.Url),
                         Title = HtmlHelper.Unescape(linkRef.Title),
-                        IsImage = isImage,
+                        Label = label,
+                        LabelSpan = labelSpan,
+                        IsImage = parent.IsImage,
+                        Reference = linkRef,
+                        Span = new SourceSpan(parent.Span.Start, endPosition),
+                        Line = parent.Line,
+                        Column = parent.Column,
                     };
                 }
 
                 var containerLink = link as ContainerInline;
                 if (containerLink != null)
                 {
+                    var child = parent.FirstChild;
                     if (child == null)
                     {
                         child = new LiteralInline()
                         {
                             Content = new StringSlice(label),
-                            IsClosed = true
+                            IsClosed = true,
+                            // Not exact but we leave it like this
+                            Span = parent.Span,
+                            Line = parent.Line,
+                            Column = parent.Column,
                         };
                         containerLink.AppendChild(child);
                     }
@@ -139,7 +159,7 @@ namespace Markdig.Parsers.Inlines
                 link.IsClosed = true;
 
                 // Process emphasis delimiters
-                state.ProcessDelimiters(0, link, null, false);
+                state.PostProcessInlines(0, link, null, false);
 
                 state.Inline = link;
                 isValidLink = true;
@@ -175,7 +195,10 @@ namespace Markdig.Parsers.Inlines
                 {
                     inlineState.Inline = new LiteralInline()
                     {
-                        Content = new StringSlice("[")
+                        Content = new StringSlice("["),
+                        Span = openParent.Span,
+                        Line = openParent.Line,
+                        Column = openParent.Column,
                     };
                     openParent.ReplaceBy(inlineState.Inline);
                     return false;
@@ -192,7 +215,9 @@ namespace Markdig.Parsers.Inlines
                     case '(':
                         string url;
                         string title;
-                        if (LinkHelper.TryParseInlineLink(ref text, out url, out title))
+                        SourceSpan linkSpan;
+                        SourceSpan titleSpan;
+                        if (LinkHelper.TryParseInlineLink(ref text, out url, out title, out linkSpan, out titleSpan))
                         {
                             // Inline Link
                             var link = new LinkInline()
@@ -200,6 +225,12 @@ namespace Markdig.Parsers.Inlines
                                 Url = HtmlHelper.Unescape(url),
                                 Title = HtmlHelper.Unescape(title),
                                 IsImage = openParent.IsImage,
+                                LabelSpan = openParent.LabelSpan,
+                                UrlSpan = inlineState.GetSourcePositionFromLocalSpan(linkSpan),
+                                TitleSpan = inlineState.GetSourcePositionFromLocalSpan(titleSpan),
+                                Span = new SourceSpan(openParent.Span.Start, inlineState.GetSourcePosition(text.Start -1)),
+                                Line = openParent.Line,
+                                Column = openParent.Column,
                             };
 
                             openParent.ReplaceBy(link);
@@ -207,7 +238,7 @@ namespace Markdig.Parsers.Inlines
                             inlineState.Inline = link;
 
                             // Process emphasis delimiters
-                            inlineState.ProcessDelimiters(0, link, null, false);
+                            inlineState.PostProcessInlines(0, link, null, false);
 
                             // If we have a link (and not an image), 
                             // we also set all [ delimiters before the opening delimiter to inactive. 
@@ -224,13 +255,17 @@ namespace Markdig.Parsers.Inlines
                         break;
                     default:
 
+                        var labelSpan = SourceSpan.Empty;
                         string label = null;
+                        bool isLabelSpanLocal = true;
                         // Handle Collapsed links
                         if (text.CurrentChar == '[')
                         {
                             if (text.PeekChar(1) == ']')
                             {
                                 label = openParent.Label;
+                                labelSpan = openParent.LabelSpan;
+                                isLabelSpanLocal = false;
                                 text.NextChar(); // Skip [
                                 text.NextChar(); // Skip ]
                             }
@@ -240,10 +275,14 @@ namespace Markdig.Parsers.Inlines
                             label = openParent.Label;
                         }
 
-                        if (label != null || LinkHelper.TryParseLabel(ref text, true, out label))
+                        if (label != null || LinkHelper.TryParseLabel(ref text, true, out label, out labelSpan))
                         {
-                            if (ProcessLinkReference(inlineState, label, openParent.IsImage,
-                                openParent.FirstChild))
+                            if (isLabelSpanLocal)
+                            {
+                                labelSpan = inlineState.GetSourcePositionFromLocalSpan(labelSpan);
+                            }
+
+                            if (ProcessLinkReference(inlineState, label, labelSpan, openParent, inlineState.GetSourcePosition(text.Start - 1)))
                             {
                                 // Remove the open parent
                                 openParent.Remove();
@@ -267,6 +306,7 @@ namespace Markdig.Parsers.Inlines
 
                 var literal = new LiteralInline()
                 {
+                    Span = openParent.Span,
                     Content = new StringSlice(openParent.IsImage ? "![" : "[")
                 };
 

src/Markdig/Parsers/Inlines/LiteralInlineParser.cs

@@ -3,6 +3,7 @@
 // See the license.txt file in the project root for more information.
 
 using Markdig.Helpers;
+using Markdig.Syntax;
 using Markdig.Syntax.Inlines;
 
 namespace Markdig.Parsers.Inlines
@@ -33,6 +34,10 @@ namespace Markdig.Parsers.Inlines
         {
             var text = slice.Text;
 
+            int line;
+            int column;
+            var startPosition = processor.GetSourcePosition(slice.Start, out line, out column);
+
             // Sligthly faster to perform our own search for opening characters
             var nextStart = processor.Parsers.IndexOfOpeningCharacter(text, slice.Start + 1, slice.End);
             //var nextStart = str.IndexOfAny(processor.SpecialCharacters, slice.Start + 1, slice.Length - 1);
@@ -59,7 +64,26 @@ namespace Markdig.Parsers.Inlines
             }
 
             // The LiteralInlineParser is always matching (at least an empty string)
-            processor.Inline = length > 0 ? new LiteralInline {Content = new StringSlice(slice.Text, slice.Start, slice.Start + length - 1)} : new LiteralInline();
+            var endPosition = slice.Start + length - 1;
+
+            var previousInline = processor.Inline as LiteralInline;
+            if (previousInline != null && ReferenceEquals(previousInline.Content.Text, slice.Text) &&
+                previousInline.Content.End + 1 == slice.Start)
+            {
+                previousInline.Content.End = endPosition;
+                previousInline.Span.End = processor.GetSourcePosition(endPosition);
+            }
+            else
+            {
+                processor.Inline = new LiteralInline()
+                {
+                    Content = length > 0 ? new StringSlice(slice.Text, slice.Start, endPosition) : StringSlice.Empty,
+                    Span = new SourceSpan(startPosition, processor.GetSourcePosition(endPosition)),
+                    Line = line,
+                    Column = column,
+                };
+            }
+
             slice.Start = nextStart;
 
             // Call only PostMatch if necessary

src/Markdig/Parsers/ListBlockParser.cs

@@ -138,11 +138,6 @@ namespace Markdig.Parsers
                     list.CountBlankLinesReset++;
                 }
 
-                if (list.CountBlankLinesReset > 1)
-                {
-                    return BlockState.BreakDiscard;
-                }
-
                 if (list.CountBlankLinesReset == 1 && listItem.ColumnWidth < 0)
                 {
                     state.Close(listItem);
@@ -152,6 +147,9 @@ namespace Markdig.Parsers
                     return BlockState.Continue;
                 }
 
+                // Update list-item source end position
+                listItem.UpdateSpanEnd(state.Line.End);
+                
                 return BlockState.Continue;
             }
 
@@ -167,9 +165,12 @@ namespace Markdig.Parsers
             {
                 if (state.Indent > columWidth && state.IsCodeIndent)
                 {
-                    state.GoToColumn(columWidth);
+                    state.GoToColumn(state.ColumnBeforeIndent + columWidth);
                 }
 
+                // Update list-item source end position
+                listItem.UpdateSpanEnd(state.Line.End);
+
                 return BlockState.Continue;
             }
 
@@ -189,6 +190,8 @@ namespace Markdig.Parsers
 
             var initColumnBeforeIndent = state.ColumnBeforeIndent;
             var initColumn = state.Column;
+            var sourcePosition = state.Start;
+            var sourceEndPosition = state.Line.End;
 
             var c = state.CurrentChar;
             var itemParser = mapItemParsers[c];
@@ -246,10 +249,21 @@ namespace Markdig.Parsers
                 columnWidth = (state.IsBlankLine ? columnBeforeIndent : state.Column) - initColumnBeforeIndent;
             }
 
+            // Starts/continue the list unless:
+            // - an empty list item follows a paragraph
+            // - an ordered list is not starting by '1'
+            var isPreviousParagraph = (block ?? state.LastBlock) is ParagraphBlock;
+            if (isPreviousParagraph && (state.IsBlankLine || (listInfo.BulletType == '1' && listInfo.OrderedStart != "1")))
+            {
+                state.GoToColumn(initColumn);
+                return BlockState.None;
+            }
+
             var newListItem = new ListItemBlock(this)
             {
                 Column = initColumn,
-                ColumnWidth = columnWidth
+                ColumnWidth = columnWidth,
+                Span = new SourceSpan(sourcePosition, sourceEndPosition)
             };
             state.NewBlocks.Push(newListItem);
 
@@ -276,6 +290,7 @@ namespace Markdig.Parsers
                 var newList = new ListBlock(this)
                 {
                     Column = initColumn,
+                    Span = new SourceSpan(sourcePosition, sourceEndPosition),
                     IsOrdered = isOrdered,
                     BulletType = listInfo.BulletType,
                     OrderedDelimiter = listInfo.OrderedDelimiter,
@@ -342,6 +357,12 @@ namespace Markdig.Parsers
                 isLastListItem = false;
             }
 
+            //// Update end-position for the list
+            //if (listBlock.Count > 0)
+            //{
+            //    listBlock.Span.End = listBlock[listBlock.Count - 1].Span.End;
+            //}
+
             return true;
         }
     }

src/Markdig/Parsers/MarkdownParser.cs

@@ -26,19 +26,24 @@ namespace Markdig.Parsers
         private readonly InlineProcessor inlineProcessor;
         private readonly MarkdownDocument document;
         private readonly ProcessDocumentDelegate documentProcessed;
+        private readonly bool preciseSourceLocation;
+
+        private LineReader lineReader;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="MarkdownParser" /> class.
         /// </summary>
-        /// <param name="reader">The reader.</param>
+        /// <param name="text">The reader.</param>
         /// <param name="pipeline">The pipeline.</param>
         /// <exception cref="System.ArgumentNullException">
         /// </exception>
-        private MarkdownParser(TextReader reader, MarkdownPipeline pipeline)
+        private MarkdownParser(string text, MarkdownPipeline pipeline)
         {
-            if (reader == null) throw new ArgumentNullException(nameof(reader));
+            if (text == null) throw new ArgumentNullException(nameof(text));
             if (pipeline == null) throw new ArgumentNullException(nameof(pipeline));
-            Reader = reader;
+            text = FixupZero(text);
+            lineReader = new LineReader(text);
+            preciseSourceLocation = pipeline.PreciseSourceLocation;
 
             // Initialize the pipeline
             var stringBuilderCache = pipeline.StringBuilderCache ?? new StringBuilderCache();
@@ -53,7 +58,7 @@ namespace Markdig.Parsers
             // Initialize the inline parsers
             var inlineParserList = new InlineParserList();
             inlineParserList.AddRange(pipeline.InlineParsers);
-            inlineProcessor = new InlineProcessor(stringBuilderCache, document, inlineParserList)
+            inlineProcessor = new InlineProcessor(stringBuilderCache, document, inlineParserList, pipeline.PreciseSourceLocation)
             {
                 DebugLog = pipeline.DebugLog
             };
@@ -64,25 +69,20 @@ namespace Markdig.Parsers
         /// <summary>
         /// Parses the specified markdown into an AST <see cref="MarkdownDocument"/>
         /// </summary>
-        /// <param name="reader">A Markdown text from a <see cref="TextReader"/>.</param>
+        /// <param name="text">A Markdown text</param>
         /// <param name="pipeline">The pipeline used for the parsing.</param>
         /// <returns>An AST Markdown document</returns>
         /// <exception cref="System.ArgumentNullException">if reader variable is null</exception>
-        public static MarkdownDocument Parse(TextReader reader, MarkdownPipeline pipeline = null)
+        public static MarkdownDocument Parse(string text, MarkdownPipeline pipeline = null)
         {
-            if (reader == null) throw new ArgumentNullException(nameof(reader));
+            if (text == null) throw new ArgumentNullException(nameof(text));
             pipeline = pipeline ?? new MarkdownPipelineBuilder().Build();
 
             // Perform the parsing
-            var markdownParser = new MarkdownParser(reader, pipeline);
+            var markdownParser = new MarkdownParser(text, pipeline);
             return markdownParser.Parse();
         }
 
-        /// <summary>
-        /// Gets the text reader used.
-        /// </summary>
-        private TextReader Reader { get; }
-
         /// <summary>
         /// Parses the current <see cref="Reader"/> into a Markdown <see cref="MarkdownDocument"/>.
         /// </summary>
@@ -101,17 +101,15 @@ namespace Markdig.Parsers
         {
             while (true)
             {
-                // TODO: A TextReader doesn't allow to precisely track position in file due to line endings
-                var lineText = Reader.ReadLine();
-
+                // Get the precise position of the begining of the line
+                var lineText = lineReader.ReadLine();
+                
                 // If this is the end of file and the last line is empty
                 if (lineText == null)
                 {
                     break;
                 }
-                lineText = FixupZero(lineText);
-
-                blockProcessor.ProcessLine(new StringSlice(lineText));
+                blockProcessor.ProcessLine(lineText.Value);
             }
             blockProcessor.CloseAll(true);
         }
@@ -122,29 +120,7 @@ namespace Markdig.Parsers
         /// <param name="text">The text to secure.</param>
         private string FixupZero(string text)
         {
-            int startPos = 0;
-            int nextZero;
-            StringBuilder newLine = null;
-            while ((nextZero = text.IndexOf('\0', startPos)) >= 0)
-            {
-                if (newLine == null)
-                {
-                    newLine = StringBuilderCache.Local();
-                }
-                newLine.Append(text, startPos, nextZero - startPos);
-                newLine.Append(CharHelper.ZeroSafeChar);
-                startPos = nextZero + 1;
-            }
-
-            if (newLine == null)
-            {
-                return text;
-            }
-            newLine.Append(text, startPos, text.Length - startPos);
-
-            var result = newLine.ToString();
-            newLine.Length = 0;
-            return result;
+            return text.Replace('\0', CharHelper.ZeroSafeChar);
         }
 
         private class ContainerItemCache : DefaultObjectCache<ContainerItem>

src/Markdig/Parsers/ParagraphBlockParser.cs

@@ -20,7 +20,11 @@ namespace Markdig.Parsers
             }
 
             // We continue trying to match by default
-            processor.NewBlocks.Push(new ParagraphBlock(this) {Column = processor.Column});
+            processor.NewBlocks.Push(new ParagraphBlock(this)
+            {
+                Column = processor.Column,
+                Span = new SourceSpan(processor.Line.Start, processor.Line.End)
+            });
             return BlockState.Continue;
         }
 
@@ -35,6 +39,8 @@ namespace Markdig.Parsers
             {
                 return TryParseSetexHeading(processor, block);
             }
+
+            block.UpdateSpanEnd(processor.Line.End);
             return BlockState.Continue;
         }
 
@@ -121,6 +127,7 @@ namespace Markdig.Parsers
                     var heading = new HeadingBlock(this)
                     {
                         Column = paragraph.Column,
+                        Span = new SourceSpan(paragraph.Span.Start, line.Start),
                         Level = level,
                         Lines = paragraph.Lines,
                     };
@@ -132,6 +139,8 @@ namespace Markdig.Parsers
                 return BlockState.BreakDiscard;
             }
 
+            block.UpdateSpanEnd(state.Line.End);
+
             return BlockState.Continue;
         }
 

src/Markdig/Parsers/QuoteBlockParser.cs

@@ -28,6 +28,7 @@ namespace Markdig.Parsers
             }
 
             var column = processor.Column;
+            var sourcePosition = processor.Start;
 
             // 5.1 Block quotes 
             // A block quote marker consists of 0-3 spaces of initial indent, plus (a) the character > together with a following space, or (b) a single character > not followed by a space.
@@ -37,7 +38,12 @@ namespace Markdig.Parsers
             {
                 processor.NextColumn();
             }
-            processor.NewBlocks.Push(new QuoteBlock(this) {QuoteChar = quoteChar, Column = column});
+            processor.NewBlocks.Push(new QuoteBlock(this)
+            {
+                QuoteChar = quoteChar,
+                Column = column,
+                Span = new SourceSpan(sourcePosition, processor.Line.End),
+            });
             return BlockState.Continue;
         }
 
@@ -64,6 +70,7 @@ namespace Markdig.Parsers
                 processor.NextChar(); // Skip following space
             }
 
+            block.UpdateSpanEnd(processor.Line.End);
             return BlockState.Continue;
         }
     }

src/Markdig/Parsers/ThematicBreakParser.cs

@@ -32,6 +32,8 @@ namespace Markdig.Parsers
                 return BlockState.None;
             }
 
+            var startPosition = processor.Start;
+
             var line = processor.Line;
 
             // 4.1 Thematic breaks 
@@ -52,7 +54,7 @@ namespace Markdig.Parsers
 
                     breakCharCount++;
                 }
-                else if (c.IsSpace())
+                else if (c.IsSpaceOrTab())
                 {
                     hasSpacesSinceLastMatch = true;
                 }
@@ -83,7 +85,11 @@ namespace Markdig.Parsers
             }
 
             // Push a new block
-            processor.NewBlocks.Push(new ThematicBreakBlock(this) { Column = processor.Column });
+            processor.NewBlocks.Push(new ThematicBreakBlock(this)
+            {
+                Column = processor.Column,
+                Span = new SourceSpan(startPosition, line.End)
+            });
             return BlockState.BreakDiscard;
         }
     }

src/Markdig/Properties/AssemblyInfo.cs

@@ -25,6 +25,6 @@ namespace Markdig
 {
     public static partial class Markdown
     {
-        public const string Version = "0.3.0";
+        public const string Version = "0.7.2";
     }
 }

src/Markdig/Renderers/Html/CodeBlockRenderer.cs

@@ -1,6 +1,10 @@
 // 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 Markdig.Parsers;
 using Markdig.Syntax;
 
 namespace Markdig.Renderers.Html
@@ -11,24 +15,57 @@ namespace Markdig.Renderers.Html
     /// <seealso cref="Markdig.Renderers.Html.HtmlObjectRenderer{Markdig.Syntax.CodeBlock}" />
     public class CodeBlockRenderer : HtmlObjectRenderer<CodeBlock>
     {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CodeBlockRenderer"/> class.
+        /// </summary>
+        public CodeBlockRenderer()
+        {
+            BlocksAsDiv = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+        }
+
         public bool OutputAttributesOnPre { get; set; }
 
+        /// <summary>
+        /// Gets a map of fenced code block infos that should be rendered as div blocks instead of pre/code blocks.
+        /// </summary>
+        public HashSet<string> BlocksAsDiv { get; }
+
         protected override void Write(HtmlRenderer renderer, CodeBlock obj)
         {
             renderer.EnsureLine();
-            renderer.Write("<pre");
-            if (OutputAttributesOnPre)
+
+            var fencedCodeBlock = obj as FencedCodeBlock;
+            if (fencedCodeBlock?.Info != null && BlocksAsDiv.Contains(fencedCodeBlock.Info))
             {
-                renderer.WriteAttributes(obj);
+                var infoPrefix = (obj.Parser as FencedCodeBlockParser)?.InfoPrefix ??
+                                 FencedCodeBlockParser.DefaultInfoPrefix;
+
+                // We are replacing the HTML attribute `language-mylang` by `mylang` only for a div block
+                // NOTE that we are allocating a closure here
+                renderer.Write("<div")
+                    .WriteAttributes(obj.TryGetAttributes(),
+                        cls => cls.StartsWith(infoPrefix) ? cls.Substring(infoPrefix.Length) : cls)
+                    .Write(">");
+                renderer.WriteLeafRawLines(obj, true, true, true);
+                renderer.WriteLine("</div>");
+
             }
-            renderer.Write("><code");
-            if (!OutputAttributesOnPre)
+            else
             {
-                renderer.WriteAttributes(obj);
+                renderer.Write("<pre");
+                if (OutputAttributesOnPre)
+                {
+                    renderer.WriteAttributes(obj);
+                }
+                renderer.Write("><code");
+                if (!OutputAttributesOnPre)
+                {
+                    renderer.WriteAttributes(obj);
+                }
+                renderer.Write(">");
+                renderer.WriteLeafRawLines(obj, true, true);
+                renderer.WriteLine("</code></pre>");
             }
-            renderer.Write(">");
-            renderer.WriteLeafRawLines(obj, true, true);
-            renderer.WriteLine("</code></pre>");
         }
     }
 }

src/Markdig/Renderers/Html/HtmlAttributes.cs

@@ -11,7 +11,7 @@ namespace Markdig.Renderers.Html
     /// <summary>
     /// Attached HTML attributes to a <see cref="MarkdownObject"/>.
     /// </summary>
-    public class HtmlAttributes
+    public class HtmlAttributes : MarkdownObject
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="HtmlAttributes"/> class.
@@ -44,9 +44,14 @@ namespace Markdig.Renderers.Html
             if (name == null) throw new ArgumentNullException(nameof(name));
             if (Classes == null)
             {
-                Classes = new List<string>(2); // Use half list compare to default capacity (4), as we don't expect lots of classes
+                Classes = new List<string>(2);
+                    // Use half list compare to default capacity (4), as we don't expect lots of classes
+            }
+
+            if (!Classes.Contains(name))
+            {
+                Classes.Add(name);
             }
-            Classes.Add(name);
         }
 
         /// <summary>
@@ -113,7 +118,7 @@ namespace Markdig.Renderers.Html
             }
             if (htmlAttributes.Classes == null)
             {
-                htmlAttributes.Classes = shared ? Classes : new List<string>(Classes);
+                htmlAttributes.Classes = shared ? Classes : Classes != null ? new List<string>(Classes) : null;
             }
             else if (Classes != null)
             {
@@ -122,7 +127,7 @@ namespace Markdig.Renderers.Html
 
             if (htmlAttributes.Properties == null)
             {
-                htmlAttributes.Properties = shared ? Properties : new List<KeyValuePair<string, string>>(Properties);
+                htmlAttributes.Properties = shared ? Properties : Properties != null ? new List<KeyValuePair<string, string>>(Properties) : null;
             }
             else if (Properties != null)
             {

src/Markdig/Renderers/Html/Inlines/AutolinkInlineRenderer.cs

@@ -11,6 +11,11 @@ namespace Markdig.Renderers.Html.Inlines
     /// <seealso cref="Markdig.Renderers.Html.HtmlObjectRenderer{Markdig.Syntax.Inlines.AutolinkInline}" />
     public class AutolinkInlineRenderer : HtmlObjectRenderer<AutolinkInline>
     {
+        /// <summary>
+        /// Gets or sets a value indicating whether to always add rel="nofollow" for links or not.
+        /// </summary>
+        public bool AutoRelNoFollow { get; set; }
+
         protected override void Write(HtmlRenderer renderer, AutolinkInline obj)
         {
             if (renderer.EnableHtmlForInline)
@@ -22,6 +27,12 @@ namespace Markdig.Renderers.Html.Inlines
                 }
                 renderer.WriteEscapeUrl(obj.Url);
                 renderer.WriteAttributes(obj);
+
+                if (!obj.IsEmail && AutoRelNoFollow)
+                {
+                    renderer.Write(" rel=\"nofollow\"");
+                }
+
                 renderer.Write("\">");
             }
 

src/Markdig/Renderers/Html/Inlines/HardlineBreakInlineRenderer.cs

@@ -1,26 +0,0 @@
-// 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.Syntax.Inlines;
-
-namespace Markdig.Renderers.Html.Inlines
-{
-    /// <summary>
-    /// A HTML renderer for a <see cref="HardlineBreakInline"/>.
-    /// </summary>
-    /// <seealso cref="Markdig.Renderers.Html.HtmlObjectRenderer{Markdig.Syntax.Inlines.HardlineBreakInline}" />
-    public class HardlineBreakInlineRenderer : HtmlObjectRenderer<HardlineBreakInline>
-    {
-        protected override void Write(HtmlRenderer renderer, HardlineBreakInline obj)
-        {
-            if (renderer.EnableHtmlForInline)
-            {
-                renderer.WriteLine("<br />");
-            }
-            else
-            {
-                renderer.Write(" ");
-            }
-        }
-    }
-}

src/Markdig/Renderers/Html/Inlines/LineBreakInlineRenderer.cs

@@ -6,21 +6,21 @@ using Markdig.Syntax.Inlines;
 namespace Markdig.Renderers.Html.Inlines
 {
     /// <summary>
-    /// A HTML renderer for a <see cref="SoftlineBreakInline"/>.
+    /// A HTML renderer for a <see cref="LineBreakInline"/>.
     /// </summary>
-    /// <seealso cref="Markdig.Renderers.Html.HtmlObjectRenderer{Markdig.Syntax.Inlines.SoftlineBreakInline}" />
-    public class SoftlineBreakInlineRenderer : HtmlObjectRenderer<SoftlineBreakInline>
+    /// <seealso cref="Markdig.Renderers.Html.HtmlObjectRenderer{Markdig.Syntax.Inlines.LineBreakInline}" />
+    public class LineBreakInlineRenderer : HtmlObjectRenderer<LineBreakInline>
     {
         /// <summary>
         /// Gets or sets a value indicating whether to render this softline break as a HTML hardline break tag (&lt;br /&gt;)
         /// </summary>
         public bool RenderAsHardlineBreak { get; set; }
 
-        protected override void Write(HtmlRenderer renderer, SoftlineBreakInline obj)
+        protected override void Write(HtmlRenderer renderer, LineBreakInline obj)
         {
             if (renderer.EnableHtmlForInline)
             {
-                if (RenderAsHardlineBreak)
+                if (obj.IsHard || RenderAsHardlineBreak)
                 {
                     renderer.WriteLine("<br />");
                 }

src/Markdig/Renderers/Html/Inlines/LinkInlineRenderer.cs

@@ -11,6 +11,11 @@ namespace Markdig.Renderers.Html.Inlines
     /// <seealso cref="Markdig.Renderers.Html.HtmlObjectRenderer{Markdig.Syntax.Inlines.LinkInline}" />
     public class LinkInlineRenderer : HtmlObjectRenderer<LinkInline>
     {
+        /// <summary>
+        /// Gets or sets a value indicating whether to always add rel="nofollow" for links or not.
+        /// </summary>
+        public bool AutoRelNoFollow { get; set; }
+
         protected override void Write(HtmlRenderer renderer, LinkInline link)
         {
             if (renderer.EnableHtmlForInline)
@@ -54,6 +59,10 @@ namespace Markdig.Renderers.Html.Inlines
             {
                 if (renderer.EnableHtmlForInline)
                 {
+                    if (AutoRelNoFollow)
+                    {
+                        renderer.Write(" rel=\"nofollow\"");
+                    }
                     renderer.Write(">");
                 }
                 renderer.WriteChildren(link);