Temp commit

.editorconfig

@@ -12,9 +12,8 @@ insert_final_newline = false
 trim_trailing_whitespace = true
 
 # Solution Files
-[*.slnx]
-indent_size = 2
-insert_final_newline = true
+[*.sln]
+indent_style = tab
 
 # XML Project Files
 [*.{csproj,vbproj,vcxproj,vcxproj.filters,proj,projitems,shproj}]
@@ -36,8 +35,3 @@ insert_final_newline = true
 # Bash Files
 [*.sh]
 end_of_line = lf
-
-# C# files
-[*.cs]
-# License header
-file_header_template = Copyright (c) Alexandre Mutel. All rights reserved.\nThis file is licensed under the BSD-Clause 2 license.\nSee the license.txt file in the project root for more information.

.gitattributes

@@ -1,3 +1,3 @@
 * text=auto
 *.cs text=auto diff=csharp
-*.slnx text=auto eol=crlf
+*.sln text=auto eol=crlf

.github/workflows/ci.yml

@@ -1,5 +1,8 @@
 name: ci
 
+env:
+  PROJECT_NAME: Markdig
+
 on:
   push:
     paths-ignore:
@@ -11,11 +14,51 @@ on:
 
 jobs:
   build:
-    uses: xoofx/.github/.github/workflows/dotnet.yml@main
-    with:
-      dotnet-version: |
-        6.0
-        8.0
-        9.0
-    secrets:
-      NUGET_TOKEN: ${{ secrets.NUGET_TOKEN }}    
+    runs-on: windows-latest
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v1
+
+    - name: Install .NET 5.0
+      uses: actions/setup-dotnet@v1
+      with:
+        dotnet-version: '5.0.x'
+
+    - name: Build (Release)
+      run: dotnet build src -c Release
+      
+    - name: SpecFileGen
+      run: dotnet src/SpecFileGen/bin/Release/net5.0/SpecFileGen.dll
+
+    - name: Test (Release)
+      run: dotnet test src -c Release
+
+    - name: Build & Test (Debug)
+      run: dotnet test src -c Debug
+
+    - name: Coverlet
+      run: dotnet test src -c Release -f net5.0 /p:Include=\"[${{env.PROJECT_NAME}}]*\" /p:CollectCoverage=true /p:CoverletOutputFormat=lcov
+
+    - name: Coveralls Upload
+      uses: coverallsapp/github-action@v1.0.1
+      if: github.event_name == 'push' && github.ref == 'refs/heads/master'
+      with:
+        github-token: ${{ secrets.GITHUB_TOKEN }}
+        path-to-lcov: src/${{env.PROJECT_NAME}}.Tests/coverage.info
+
+    - name: Pack
+      run: dotnet pack src -c Release
+
+    - name: Pack Signed
+      run: dotnet pack -c Release src/${{env.PROJECT_NAME}}.Signed/${{env.PROJECT_NAME}}.Signed.csproj
+
+    - name: Publish
+      if: github.event_name == 'push'
+      run: |      
+          if ( "${{github.ref}}" -match "^refs/tags/[0-9]+\.[0-9]+\.[0-9]+$" ) {
+              dotnet nuget push src\${{env.PROJECT_NAME}}\bin\Release\*.nupkg -s nuget.org -k ${{secrets.NUGET_TOKEN}}
+              dotnet nuget push src\${{env.PROJECT_NAME}}.Signed\bin\Release\*.nupkg -s nuget.org -k ${{secrets.NUGET_TOKEN}}
+          } else {
+              echo "publish is only enabled by tagging with a release tag"
+          }

.github/workflows/nuget_org_only.config

@@ -1,7 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<configuration>
-  <packageSources>
-    <clear />
-    <add key="nuget.org" value="https://api.nuget.org/v3/index.json" />
-  </packageSources>
-</configuration>

.github/workflows/test-netstandard.yml

@@ -1,44 +0,0 @@
-name: Test netstandard
-
-on: pull_request
-
-jobs:
-  test-netstandard:
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        netstandard-version: ['netstandard2.0', 'netstandard2.1']
-
-    steps:
-    - uses: actions/checkout@v4
-
-    - name: Setup .NET
-      uses: actions/setup-dotnet@v4
-      with:
-        dotnet-version: |
-          8.0.x
-          9.0.x
-
-    - name: Patch build to test ${{ matrix.netstandard-version }}
-      run: |
-        cd src
-        sed -i 's/<TargetFrameworks>.*<\/TargetFrameworks>/<TargetFrameworks>${{ matrix.netstandard-version }}<\/TargetFrameworks>/' Markdig/Markdig.targets
-        sed -i 's/<TargetFrameworks>.*<\/TargetFrameworks>/<TargetFrameworks>net8.0;net9.0<\/TargetFrameworks>/' Markdig.Tests/Markdig.Tests.csproj
-        echo "Markdig.targets TFMs:"
-        grep "TargetFrameworks" Markdig/Markdig.targets
-        echo "Markdig.Tests.csproj TFMs:"
-        grep "TargetFrameworks" Markdig.Tests/Markdig.Tests.csproj
-
-    - name: Restore dependencies
-      run: dotnet restore src/Markdig.Tests/Markdig.Tests.csproj
-
-    - name: Test Debug
-      run: |
-        dotnet build src/Markdig.Tests/Markdig.Tests.csproj -c Debug --no-restore
-        dotnet test src/Markdig.Tests/Markdig.Tests.csproj -c Debug --no-build
-
-    - name: Test Release
-      run: |
-        dotnet build src/Markdig.Tests/Markdig.Tests.csproj -c Release --no-restore
-        dotnet test src/Markdig.Tests/Markdig.Tests.csproj -c Release --no-build

.gitignore

@@ -8,8 +8,6 @@
 *.sln.docstates
 *.nuget.props
 *.nuget.targets
-src/.idea
-BenchmarkDotNet.Artifacts
 
 # User-specific files (MonoDevelop/Xamarin Studio)
 *.userprefs
@@ -241,6 +239,3 @@ _Pvt_Extensions
 **/.idea/**/*.iml
 **/.idea/**/contentModel.xml
 **/.idea/**/modules.xml
-
-# Remove artifacts produced by dotnet-releaser
-artifacts-dotnet-releaser/

changelog.md

@@ -1,13 +1,5 @@
 # Changelog
 
-## 0.27.0 (23 Jan 2022)
-- Fix link reference definition parse bug with title and CRLF ([PR #590](https://github.com/lunet-io/markdig/pull/590))
-- Move tests to net6.0 ([PR #560](https://github.com/lunet-io/markdig/pull/560))
-
-## 0.26.0 (27 Aug 2021)
-- Fix rendering diff between line endings ([PR #560](https://github.com/lunet-io/markdig/pull/560))
-- Make Mathematics extension respect EnableHtml* options ([PR #570](https://github.com/lunet-io/markdig/pull/570))
-
 ## 0.25.0 (10 June 2021)
 - Fix regression when parsing link reference definitions (#543)
 - Make digits in JiraKey's posible ([PR #548](https://github.com/lunet-io/markdig/pull/548))

contributing.md

@@ -1,36 +0,0 @@
-# How to Contribute
-
-Thanks for your interest in contributing to `Markdig`! Here are a few general guidelines on contributing and
-reporting bugs that we ask you to review. Following these guidelines helps to communicate that you respect the time of
-the contributors managing and developing this open source project.
-
-## Reporting Issues
-
-Before reporting a new issue, please ensure that the issue was not already reported or fixed by searching through our
-[issues list](https://github.com/xoofx/markdig/issues).
-
-When creating a new issue, please be sure to include a **title and clear description**, as much relevant information as
-possible, and, if possible, a test case.
-
-## Sending Pull Requests
-
-Before sending a new pull request, take a look at existing pull requests and issues to see if the proposed change or fix
-has been discussed in the past, or if the change was already implemented but not yet released.
-
-We expect new pull requests to include tests for any affected behavior, and, as we follow semantic versioning, we may
-reserve breaking changes until the next major version release.
-
-## Other Ways to Contribute
-
-We welcome anyone that wants to contribute to `Markdig` to triage and reply to open issues to help troubleshoot
-and fix existing bugs. Here is what you can do:
-
-- Help ensure that existing issues follows the recommendations from the _[Reporting Issues](#reporting-issues)_ section,
-  providing feedback to the issue's author on what might be missing.
-  instructions and code samples.
-- Review existing pull requests, and testing patches against real existing applications that use `Markdig`.
-- Write a test, or add a missing test case to an existing test.
-
-Thanks again for your interest on contributing to `Markdig`!
-
-:heart:

doc/parsing-ast.md

@@ -1,134 +0,0 @@
-# The Abstract Syntax Tree
-
-If successful, the `Markdown.Parse(...)` method returns the abstract syntax tree (AST) of the source text.
-
-This will be an object of the `MarkdownDocument` type, which is in turn derived from a more general block container and is part of a larger taxonomy of classes which represent different semantic constructs of a markdown syntax tree.
-
-This document will discuss the different types of elements within the Markdig representation of the AST.
-
-## Structure of the AST
-
-Within Markdig, there are two general types of node in the markdown syntax tree: `Block`, and `Inline`.  Block nodes may contain inline nodes, but the reverse is not true.  Blocks may contain other blocks, and inlines may contain other inlines.
-
-The root of the AST is the `MarkdownDocument` which is itself derived from a container block but also contains information on the line count and starting positions within the document.  Nodes in the AST have links both to parent and children, allowing the edges in the tree to be traversed efficiently in either direction.
-
-Different semantic constructs are represented by types derived from the `Block` and `Inline` types, which are both `abstract` themselves.  These elements are produced by `BlockParser` and `InlineParser` derived types, respectively, and so new constructs can be added with the implementation of a new block or inline parser and a new block or inline type, as well as an extension to register it in the pipeline. For more information on extending Markdig this way refer to the [Extensions/Parsers](parsing-extensions.md) document.
-
-The AST is assembled by the static method `Markdown.Parse(...)` using the collections of block and inline parsers contained in the `MarkdownPipeline`.  For more detailed information refer to the [Markdig Parsing Overview](parsing-overview.md) document.
-
-### Quick Examples: Descendants API
-
-The easiest way to traverse the abstract syntax tree is with a group of extension methods that have the name `Descendants`.  Several different overloads exist to allow it to search for both `Block` and `Inline` elements, starting from any node in the tree.
-
-The `Descendants` methods return `IEnumerable<MarkdownObject>` or `IEnumerable<T>` as their results.  Internally they are using `yield return` to perform edge traversals lazily.
-
-#### Depth-First Like Traversal of All Elements
-
-```csharp
-MarkdownDocument result = Markdown.Parse(sourceText, pipeline);
-
-// Iterate through all MarkdownObjects in a depth-first order
-foreach (var item in result.Descendants())
-{
-    Console.WriteLine(item.GetType());
-
-    // You can use pattern matching to isolate elements of certain type,
-    // otherwise you can use the filtering mechanism demonstrated in the
-    // next section
-    if (item is ListItemBlock listItem) 
-    {
-        // ...
-    }
-}
-```
-
-#### Filtering of Specific Child Types
-
-Filtering can be performed using the `Descendants<T>()` method, in which T is required to be derived from `MarkdownObject`.
-
-```csharp
-MarkdownDocument result = Markdown.Parse(sourceText, pipeline);
-
-// Iterate through all ListItem blocks
-foreach (var item in result.Descendants<ListItemBlock>())
-{
-    // ...
-}
-
-// Iterate through all image links
-foreach (var item in result.Descendants<LinkInline>().Where(x => x.IsImage)) 
-{
-    // ...
-}
-```
-
-#### Combined Hierarchies
-
-The `Descendants` method can be used on any `MarkdownObject`, not just the root node, so complex hierarchies can be queried.
-
-```csharp
-MarkdownDocument result = Markdown.Parse(sourceText, pipeline);
-
-// Find all Emphasis inlines which descend from a ListItem block
-var items = document.Descendants<ListItemBlock>()
-    .Select(block => block.Descendants<EmphasisInline>());
-
-// Find all Emphasis inlines whose direct parent block is a ListItem
-var other = document.Descendants<EmphasisInline>()
-    .Where(inline => inline.ParentBlock is ListItemBlock);
-```
-
-## Block Elements
-
-Block elements all derive from `Block` and may be one of two types:
-
-1. `ContainerBlock`, which is a block which holds other blocks (`MarkdownDocument` is itself derived from this)
-2. `LeafBlock`, which is a block that has no child blocks, but may contain inlines
-
-Block elements in markdown refer to things like paragraphs, headings, lists, code, etc.  Most blocks may contain inlines, with the exception of things like code blocks.
-
-### Properties of Blocks
-
-The following are properties of `Block` objects which warrant elaboration. For a full list of properties see the generated API documentation (coming soon).
-
-#### Block Parent
-All blocks have a reference to a parent (`Parent`) of type `ContainerBlock?`, which allows for efficient traversal up the abstract syntax tree. The parent will be `null` in the case of the root node (the `MarkdownDocument`). 
-
-#### Parser
-
-All blocks have a reference to a parser (`Parser`) of type `BlockParser?` which refers to the instance of the parser which created this block. 
-
-#### IsOpen Flag
-
-Blocks have an `IsOpen` boolean flag which is set true while they're being parsed and then closed when parsing is complete.  
-
-Blocks are created by `BlockParser` objects which are managed by an instance of a `BlockProcessor` object. During the parsing algorithm the `BlockProcessor` maintains a list of all currently open `Block` objects as it steps through the source line by line. The `IsOpen` flag indicates to the `BlockProcessor` that the block should remain open as the next line begins.  If the `IsOpen` flag is not directly set by the `BlockParser` on each line, the `BlockProcessor` will consider the `Block` fully parsed and will no longer call its `BlockParser` on it.
-
-#### IsBreakable Flag
-
-Blocks are either breakable or not, specified by the `IsBreakable` flag.  If a block is non-breakable it indicates to the parser that the close condition of any parent container do not apply so long as the non-breakable child block is still open.
-
-The only built-in example of this is the `FencedCodeBlock`, which, if existing as the child of a container block of some sort, will prevent that container from being closed before the `FencedCodeBlock` is closed, since any characters inside the `FencedCodeBlock` are considered to be valid code and not the container's close condition.
-
-#### RemoveAfterProcessInlines
-
-
-
-## Inline Elements
-
-Inlines in markdown refer to things like embellishments (italics, bold, underline, etc), links, urls, inline code, images, etc.
-
-Inline elements may be one of two types:
-
-1. `Inline`, whose parent is always a `ContainerInline` 
-2. `ContainerInline`, derived from `Inline`, which contains other inlines.  `ContainerInline` also has a `ParentBlock` property of type `LeafBlock?`
-
-
-**(Is there anything special worth documenting about inlines or types of inlines?)**
-
-## The SourceSpan Struct
-
-If the pipeline was configured with `.UsePreciseSourceLocation()`, all elements in the abstract syntax tree will contain a reference to the location in the original source where they occurred.  This is done with the `SourceSpan` type, a custom Markdig `struct` which provides a start and end location.
-
-All objects derived from `MarkdownObject` contain the `Span` property, which is of type `SourceSpan`.  
-

doc/parsing-extensions.md

@@ -1,127 +0,0 @@
-# Extensions and Parsers
-
-Markdig was [implemented in such a way](http://xoofx.github.io/blog/2016/06/13/implementing-a-markdown-processor-for-dotnet/) as to be extremely pluggable, with even basic behaviors being mutable and extendable.
-
-The basic mechanism for extension of Markdig is the `IMarkdownExtension` interface, which allows any implementing class to be registered with the pipeline builder and thus to directly modify the collections of `BlockParser` and `InlineParser` objects which end up in the pipeline.
-
-This document discusses the `IMarkdownExtension` interface, the `BlockParser` abstract base class, and the `InlineParser` abstract base class, which together are the foundation of extending Markdig's parsing machinery.
-
-## Creating Extensions
-
-Extensions can vary from very simple to very complicated. 
-
-A simple extension, for example, might simply find a parser already in the pipeline and modify a setting on it.  An example of this is the `SoftlineBreakAsHardlineExtension`, which locates the `LineBreakInlineParser` and modifies a single boolean flag on it.
-
-A complex extension, on the other hand, might add an entire taxonomy of new `Block` and `Inline` types, as well as several related parsers and renderers, and require being added to the the pipeline in a specific order in relation to other extensions which are already configured. The `FootnoteExtension` and `PipeTableExtension` are examples of more complex extensions.
-
-For extensions that don't require order considerations, the implementation of the extension itself is adequate, and the extension can be added to the pipeline with the generic `Use<TExtension>()` method on the pipeline builder. For extensions which do require order considerations, it is best to create an extension method on the `MarkdownPipelineBuilder` to perform the registration.  See the following two sections for further information.
-
-### Implementation of an Extension
-
-The [IMarkdownExtension.cs](https://github.com/xoofx/markdig/blob/master/src/Markdig/IMarkdownExtension.cs) interface specifies two methods which must be implemented.
-
-The first, which takes only the pipeline builder as an argument, is called when the `Build()` method on the pipeline builder is invoked, and should set up any modifications to the parsers or parser collections. These parsers will then be used by the main parsing algorithm to process the source text.
-
-```csharp
-void Setup(MarkdownPipelineBuilder pipeline);
-```
-
-The second, which takes the pipeline itself and a renderer, is used to set up a rendering component in order to convert any special `MarkdownObject` types associated with the extension into an output.  This is not relevant for parsing, but is necessary for rendering.
-
-```csharp
-void Setup(MarkdownPipeline pipeline, IMarkdownRenderer renderer);
-```
-
-The extension can then be registered to the pipeline builder using the `Use<TExtension>()` method.  A skeleton example is given below:
-
-```csharp
-public class MySpecialBlockParser : BlockParser 
-{
-    // ...
-}
-
-public class MyExtension : IMarkdownExtension 
-{
-    void Setup(MarkdownPipelineBuilder pipeline)
-    {
-        pipeline.BlockParsers.AddIfNotAlready<MySpecialBlockParser>();
-    }
-
-    void Setup(MarkdownPipeline pipeline, IMarkdownRenderer renderer) { }
-}
-```
-
-```csharp
-var builder = new MarkdownPipelineBuilder()
-    .Use<MyExtension>();
-```
-
-### Pipeline Builder Extension Methods
-
-For extensions which require specific ordering and/or need to perform multiple operations to register with the builder, it's recommended to create an extension method.
-
-```csharp
-public static class MyExtensionMethods 
-{
-    public static MarkdownPipelineBuilder UseMyExtension(this MarkdownPipelineBuilder pipeline)
-    {
-        // Directly access or modify pipeline.Extensions here, with the ability to
-        // search for other extensions, insert before or after, remove other extensions,
-        // or modify their settings.
-
-        // ...
-
-        return pipeline;
-    }
-}
-
-```
-
-### Simple Extension Example
-
-An example of a simple extension which does not add any new parsers, but instead creates a new, horrific emphasis tag, marked by triple percentage signs.  This example is based on [CitationExtension.cs](https://github.com/xoofx/markdig/blob/master/src/Markdig/Extensions/Citations/CitationExtension.cs)
-
-```csharp
-/// <summary> 
-/// An extension which applies to text of the form %%%text%%%
-/// </summary>
-public class BlinkExtension : IMarkdownExtension
-{
-    // This setup method will be run when the pipeline builder's `Build()` method is invoked. As this
-    // is a simple, self-contained extension we won't be adding anything new, but rather finding an 
-    // existing parser already in the pipeline and adding some settings to it.
-    public void Setup(MarkdownPipelineBuilder pipeline)
-    {
-        // We check the pipeline builder's inline parser collection and see if we can find a parser
-        // registered of the type EmphasisInlineParser. This is the parser which nominally handles
-        // bold and italic emphasis, but we know from its documentation that it is a general parser
-        // that can have new characters added to it.
-        var parser = pipeline.InlineParsers.FindExact<EmphasisInlineParser>();
-
-        // If we find the parser and it doesn't already have the % character registered, we add
-        // a descriptor for 3 consecutive % signs. This is specific to the EmphasisInlineParser and
-        // is just used here as an example.
-        if (parser is not null && !parser.HasEmphasisChar('%'))
-        {
-            parser.EmphasisDescriptors.Add(new EmphasisDescriptor('%', 3, 3, false));
-        }
-    }
-
-    // This method is called by the pipeline before rendering, which is a separate operation from 
-    // parsing. This implementation is just here for the purpose of the example, in which we 
-    // daisy-chain a delegate specific to the EmphasisInlineRenderer to cause an unconscionable tag 
-    // to be inserted into the HTML output wherever a %%% annotated span was placed in the source.
-    public void Setup(MarkdownPipeline pipeline, IMarkdownRenderer renderer)
-    {
-        if (renderer is not HtmlRenderer) return;
-
-        var emphasisRenderer = renderer.ObjectRenderers.FindExact<EmphasisInlineRenderer>();
-        if (emphasisRenderer is null) return;
-
-        var previousTag = emphasisRenderer.GetTag;
-        emphasisRenderer.GetTag = inline =>
-            (inline.DelimiterCount == 3 && inline.DelimiterChar == '%' ? "blink" : null)
-            ?? previousTag(inline);
-    }
-}
-```

doc/parsing-overview.md

@@ -1,336 +0,0 @@
-# Markdig Parsing
-
-Markdig provides efficient, regex-free parsing of markdown documents directly into an abstract syntax tree (AST). The AST is a representation of the markdown document's semantic constructs, which can be manipulated and explored programmatically.
-
-* This document contains a general overview of the parsing system and components and their use
-* The [Abstract Syntax Tree](parsing-ast.md) document contains a discussion of how Markdig represents the product of the parsing operation
-* The [Extensions/Parsers](parsing-extensions.md) document explores extensions and block/inline parsers within the context of extending Markdig's parsing capabilities
-
-## Introduction
-
-Markdig's parsing machinery consists of two main components at its surface: the `Markdown.Parse(...)` method and the `MarkdownPipeline` type.  The parsed document is represented by a `MarkdownDocument` object, which is a tree of objects derived from `MarkdownObject`, including block and inline elements. 
-
-The `Markdown` static class is the main entrypoint to the Markdig API. It contains the `Parse(...)` method, the main algorithm for parsing a markdown document. The `Parse(...)` method in turn uses a `MarkdownPipeline`, which is a sealed internal class which maintains some configuration information and the collections of parsers and extensions.  The `MarkdownPipeline` determines how the parser behaves and what its capabilities are.  The `MarkdownPipeline` can be modified with built-in as well as user developed extensions.
-
-### Glossary of Relevant Types
-
-The following is a table of some of the types relevant to parsing and mentioned in the related documentation. For an exhaustive list refer to API documentation (coming soon).
-
-|Type|Description|
-|-|-|
-|`Markdown`|Static class with the entry point to the parsing algorithm via the `Parse(...)` method|
-|`MarkdownPipeline`|Configuration object for the parser, contains collections of block and inline parsers and registered extensions|
-|`MarkdownPipelineBuilder`|Responsible for constructing the `MarkdownPipeline`, used by client code to configure pipeline options and behaviors|
-|`IMarkdownExtension`|Interface for [Extensions](#extensions-imarkdownextension) which alter the behavior of the pipeline, this is the standard mechanism for extending Markdig|
-|`BlockParser`|Base type for an individual parsing component meant to identify `Block` elements in the markdown source|
-|`InlineParser`|Base type for an individual parsing component meant to identify `Inline` elements within a `Block`|
-|`Block`|A node in the AST representing a markdown block element, can either be a `ContainerBlock` or a `LeafBlock`|
-|`Inline`|A node in the AST representing a markdown inline element|
-|`MarkdownDocument`|The root node of the AST produced by the parser, derived from `ContainerBlock`|
-|`MarkdownObject`|The base type of all `Block` and `Inline` derived objects (as well as `HtmlAttributes`)|
-
-### Simple Examples
-
-*The following are simple examples of parsing to help get you started, see the following sections for an in-depth explanation of the different parts of Markdig's parsing mechanisms*
-
-The `MarkdownPipeline` dictate how the parser will behave.  The `Markdown.Parse(...)` method will construct a default pipeline if none is provided.  A default pipeline will be CommonMark compliant but nothing else.
-
-```csharp
-var markdownText = File.ReadAllText("sample.md");
-
-// No pipeline provided means a default pipeline will be used
-var document = Markdown.Parse(markdownText);
-```
-
-Pipelines can be created and configured manually, however this must be done using a `MarkdownPipelineBuilder` object, which then is configured through a fluent interface composed of extension methods.  
-
-```csharp
-var markdownText = File.ReadAllText("sample.md");
-
-// Markdig's "UseAdvancedExtensions" option includes many common extensions beyond
-// CommonMark, such as citations, figures, footnotes, grid tables, mathematics
-// task lists, diagrams, and more.
-var pipeline = new MarkdownPipelineBuilder()
-    .UseAdvancedExtensions()
-    .Build();
-
-var document = Markdown.Parse(markdownText, pipeline);
-```
-
-Extensions can also be added individually:
-
-```csharp
-var markdownText = File.ReadAllText("sample.md");
-
-var pipeline = new MarkdownPipelineBuilder()
-    .UseCitations()
-    .UseFootnotes()
-    .UseMyCustomExtension()
-    .Build();
-
-var document = Markdown.Parse(markdownText, pipeline);
-```
-
-## Markdown.Parse and the MarkdownPipeline
-
-As metioned in the [Introduction](#introduction), Markdig's parsing machinery involves two surface components: the `Markdown.Parse(...)` method, and the `MarkdownPipeline` type.  The main parsing algorithm (not to be confused with individual `BlockParser` and `InlineParser` components) lives in the `Markdown.Parse(...)` static method. The `MarkdownPipeline` is responsible for configuring the behavior of the parser.
-
-These two components are covered in further detail in the following sections.
-
-### The MarkdownPipeline
-
-The `MarkdownPipeline` is a sealed internal class which dictates what features the parsing algorithm has.  The pipeline must be created by using a `MarkdownPipelineBuilder` as shown in the examples above.
-
-The `MarkdownPipeline` holds configuration information and collections of extensions and parsers.  Parsers fall into one of two categories:
-
-* Block Parsers (`BlockParser`)
-* Inline Parsers (`InlineParser`)
-
-Extensions are classes implementing `IMarkdownExtension` which are allowed to add to the list of parsers, or modify existing parsers and/or renderers. They are invoked to perform their mutations on the pipeline when the pipeline is built by the `MarkdownPipelineBuilder`.
-
-Lastly, the `MarkdownPipeline` contains a few extra elements:
-
-* A configuration setting determining whether or not trivial elements, referred to as *trivia*, (whitespace, extra heading characters, unescaped strings, etc) are to be tracked
-* A configuration setting determining whether or not nodes in the resultant abstract syntax tree will refer to their precise original locations in the source
-* An optional delegate which will be invoked when the document has been processed.
-* An optional `TextWriter` which will get debug logging from the parser
-
-### The Markdown.Parse Method
-
-`Markdown.Parse` is a static method which contains the overall parsing algorithm but not the actual parsing components, which instead are contained within the pipeline.
-
-The `Markdown.Parse(...)` method takes a string containing raw markdown and returns a `MarkdownDocument`, which is the root node in the abstract syntax tree.  The `Parse(...)` method optionally takes a pre-configured `MarkdownPipeline`, but if none is given will create a default pipeline which has minimal features.
-
-Within the `Parse(...)` method, the following sequence of operations occur:
-
-1. The block parsers contained in the pipeline are invoked on the raw markdown text, creating the initial tree of block elements
-2. If the pipeline is configured to track markdown trivia (trivial/non-contributing elements), the blocks are expanded to absorb neighboring trivia
-3. The inline parsers contained in the pipeline are now invoked on the blocks, populating the inline elements of the abstract syntax tree
-4. If a delegate has been configured for when the document has completed processing, it is now invoked
-5. The abstract syntax tree (`MarkdownDocument` object) is returned
-
-## The Pipeline Builder and Extensions
-
-The `MarkdownPipeline` determines the behavior and capabilities of the parser, and *extensions* added via the `MarkdownPipelineBuilder` determine the configuration of the pipeline.  
-
-This section discusses the pipeline builder and the concept of *extensions* in more detail.
-
-### Extensions (IMarkdownExtension)
-
-***Note**: This section discusses how to consume extensions by adding them to pipeline. For a discussion on how to implement an extension, refer to the [Extensions/Parsers](parsing-extensions.md) document.*
-
-Extensions are the primary mechanism for modifying the parsers in the pipeline.
-
-An extension is any class which implements the `IMarkdownExtension` interface found in [IMarkdownExtension.cs](https://github.com/xoofx/markdig/blob/master/src/Markdig/IMarkdownExtension.cs). This interface consists solely of two `Setup(...)` overloads, which both take a `MarkdownPipelineBuilder` as the first argument.
-
-When the `MarkdownPipelineBuilder.Build()` method is invoked as the final stage in pipeline construction, the builder runs through the list of registered extensions in order and calls the `Setup(...)` method on each of them.  The extension then has full access to modify both the parser collections themselves (by adding new parsers to it), or to find and modify existing parsers.  
-
-Because of this, *some* extensions may need to be ordered in relation to others, for instance if they modify a parser that gets added by a different extension. The `OrderedList<T>` class contains convenience methods to this end, which aid in finding other extensions by type and then being able to added an item before or after them.
-
-### The MarkdownPipelineBuilder
-
-Because the `MarkdownPipeline` is a sealed internal class, it cannot (and *should* not be attempted to) be created directly.  Rather, the `MarkdownPipelineBuilder` manages the requisite construction of the pipeline after the configuration has been provided by the client code.
-
-As discussed in the [section above](#the-markdownpipeline), the `MarkdownPipeline` primarily consists of a collection of block parsers and a collection of inline parsers, which are provided to the `Markdown.Parse(...)` method and thus determine its features and behavior.  Both the collections and some of the parsers themselves are mutable, and the mechanism of mutation is the `Setup(...)` method of the `IMarkdownExtension` interface.  This is covered in more detail in the section on [Extensions](#extensions-imarkdownextension).
-
-#### The Fluent Interface
-
-A collection of extension methods in the [MarkdownExtensions.cs](https://github.com/xoofx/markdig/blob/master/src/Markdig/MarkdownExtensions.cs) source file provides a convenient fluent API for the configuration of the pipeline builder.  This should be considered the standard way of configuring the builder.
-
-##### Configuration Options
-
-There are several extension methods which apply configurations to the builder which change settings in the pipeline outside of the use of typical extensions. 
-
-|Method|Description|
-|-|-|
-|`.ConfigureNewLine(...)`|Takes a string which will serve as the newline delimiter during parsing|
-|`.DisableHeadings()`|Disables the parsing of ATX and Setex headings|
-|`.DisableHtml()`|Disables the parsing of HTML elements|
-|`.EnableTrackTrivia()`|Enables the tracking of trivia (trivial elements like whitespace)|
-|`.UsePreciseSourceLocation()`|Maps syntax objects to their precise location in the original source, such as would be required for syntax highlighting|
-
-```csharp
-var builder = new MarkdownPipelineBuilder()
-    .ConfigureNewLine("\r\n")
-    .DisableHeadings()
-    .DisableHtml()
-    .EnableTrackTrivia()
-    .UsePreciseSourceLocation();
-
-var pipeline = builder.Build();
-```
-
-##### Adding Extensions
-
-All extensions which ship with Markdig can be added through a dedicated fluent method, while user code which implements the `IMarkdownExtension` interface can be added with one of the `Use()` methods, or via a custom extension method implemented in the client code.
-
-Refer to [MarkdownExtensions.cs](https://github.com/xoofx/markdig/blob/master/src/Markdig/MarkdownExtensions.cs) for a full list of extension methods:
-
-```csharp
-var builder = new MarkdownPipelineBuilder()
-    .UseFootnotes()
-    .UseFigures();
-```
-
-For custom/user-provided extensions, the `Use<TExtension>(...)` methods allow either a type to be directly added or an already constructed instance to be put into the extension container. Internally they will prevent two of the same type of extension from being added to the container.
-
-```csharp
-public class MyExtension : IMarkdownExtension 
-{
-    // ...
-}
-
-// Only works if MyExtension has an empty constructor (aka new())
-var builder = new MarkdownPipelineBuilder()
-    .Use<MyExtension>();
-```
-
-Alternatively:
-
-```csharp
-public class MyExtension : IMarkdownExtension 
-{
-    public MyExtension(object someConfigurationObject) { /* ... */ }
-    // ...
-}
-
-var instance = new MyExtension(configData);
-
-var builder = new MarkdownPipelineBuilder()
-    .Use(instance);
-```
-
-##### Adding Extensions with the Configure Method
-
-The `MarkdownPipelineBuilder` has one additional method for the configuration of extensions worth mentioning: the `Configure(...)` method, which takes a `string?` of `+` delimited tokens specifying which extensions should be dynamically configured.  This is a convenience method for the configuration of pipelines whose extensions are only known at runtime.
-
-Refer to [MarkdownExtensions.cs's `Configure(...)`](https://github.com/xoofx/markdig/blob/983187eace6ba02ee16d1443c387267ad6e78f58/src/Markdig/MarkdownExtensions.cs#L538) code for the full list of extensions.
-
-
-```csharp
-var builder = new MarkdownPipelineBuilder()
-    .Configure("common+footnotes+figures");
-
-var pipeline = builder.Build();
-```
-
-#### Manual Configuration
-
-Internally, the fluent interface wraps manual operations on the three primary collections:
-
-* `MarkdownPipelineBuilder.BlockParsers` - this is an `OrderedList<BlockParser>` of the block parsers
-* `MarkdownPipelineBuilder.InlineParsers` - this is an `OrderedList<InlineParser>` of the inline element parsers
-* `MarkdownPipelineBuilder.Extensions` - this is an `OrderedList<IMarkdownExtension>` of the extensions
-
-All three collections are `OrderedList<T>`, which is a collection type custom to Markdig which contains special methods for finding and inserting derived types.  With the builder created, manual configuration can be performed by accessing these collections and their elements and modifying them as necessary.  
-
-***Warning**: be aware that it should not be necessary to directly modify either the `BlockParsers` or the `InlineParsers` collections directly during the pipeline configuration. Rather, these can and should be modified whenever possible through the `Setup(...)` method of extensions, which will be deferred until the pipeline is actually built and will allow for ordering such that operations dependent on other operations can be accounted for.*
-
-## Block and Inline Parsers
-
-Let's dive deeper into the parsing system.  With a configured pipeline, the `Markdown.Parse` method will run through two two conceptual passes to produce the abstract syntax tree.
-
-1. First, `BlockProcessor.ProcessLine` is called on the file's lines, one by one, trying to identify block elements in the source
-2. Next, an `InlineProcessor` is created or borrowed and run on each block to identify inline elements.
-
-These two conceptual operations dictate Markdig's two types of parsers, both of which derive from `ParserBase<TProcessor>`. 
-
-Block parsers, derived from `BlockParser`, identify block elements from lines in the source text and push them onto the abstract syntax tree.  Inline parsers, derived from `InlineParser`, identify inline elements from `LeafBlock` elements and push them into an attached container: the `ContainerInline? LeafBlock.Inline` property.  
-
-Both inline and block parsers are regex-free, and instead work on finding opening characters and then making fast read-only views into the source text.
-
-### Block Parser
-
-**(The contents of this section I am very unsure of, this is from my reading of the code but I could use some guidance here)**
-
-**(Does `CanInterrupt` specifically refer to interrupting a paragraph block?)**
-
-In order to be added to the parsing pipeline, all block parsers must be derived from `BlockParser`.
-
-Internally, the main parsing algorithm will be stepping through the source text, using the `HasOpeningCharacter(char c)` method of the block parser collection to pre-identify parsers which *could* be opening a block at a given position in the text based on the active character.  Thus any derived implementation needs to set the value of the `char[]? OpeningCharacter` property with the initial characters that might begin the block.
-
-If a parser can potentially open a block at a place in the source text it should expect to have the `TryOpen(BlockProcessor processor)` method called.  This is a virtual method that must be implemented on any derived class.  The `BlockProcessor` argument is a reference to an object which stores the current state of parsing and the position in the source.
-
-**(What are the rules concerning how the `BlockState` return type should work for `TryOpen`? I see examples returning `None`, `Continue`, `BreakDiscard`, `ContinueDiscard`.  How does the return value change the algorithm behavior?)**
-
-**(Should a new block always be pushed into `processor.NewBlocks` in the `TryOpen` method?)**
-
-As the main parsing algorithm moves forward, it will then call `TryContinue(...)` on blocks that were opened in `TryOpen(..)`. 
-
-**(Is this where/how you close a block? Is there anything that needs to be done to perform that beyond `block.UpdateSpanEnd` and returning `BlockState.Break`?)**
-
-
-### Inline Parsers
-
-Inline parsers extract inline markdown elements from the source, but their starting point is the text of each individual `LeafBlock` produced by the block parsing process.  To understand the role of each inline parser it is necessary to first understand the inline parsing process as a whole.
-
-#### The Inline Parsing Process
-
-After the block parsing process has occurred, the abstract syntax tree of the document has been populated only with block elements, starting from the root `MarkdownDocument` node and ending with the individual `LeafBlock` derived block elements, most of which will be `ParagraphBlocks`, but also include things like `CodeBlocks`, `HeadingBlocks`, `FigureCaptions`, and so on.
-
-At this point, the parsing machinery will iterate through each `LeafBlock` one by one, creating and assigning its `LeafBlock.Inline` property with an empty `ContainerInline`, and then sweeping through the `LeafBlock`'s text running the inline parsers.  This occurs by the following process:
-
-Starting at the first character of the text it will run through all of its `InlineParser` objects which have that character as a possible opening character for the type of inline they extract.  The parsers will run in order (as such ordering is the *only* way which conflicts between parsers are resolved, and thus is important to the overall behavior of the parsing system) and the `Match(...)` method will be called on each candidate parser, in order, until one of them returns `true`.
-
-The `Match(...)` method will be passed a slice of the text beginning at the *specific character* being processed and running until the end of the `LeafBlock`'s complete text.  If the parser can create an `Inline` element it will do so and return `true`, otherwise it will return `false`.  The parser will store the created `Inline` object in the processor's `InlineProcessor.Inline` property, which as passed into the `Match(...)` method as an argument.  The parser will also advance the start of the working `StringSlice` by the characters consumed in the match.
-
-* If the parser has created an inline element and returned `true`, that element is pushed into the deepest open `ContainerInline`
-* If `false` was returned, a default `LiteralInlineParser` will run instead:
-    * If the `InlineProcessor.Inline` property already has an existing `LiteralInline` in it, these characters will be added to the existing `LiteralInline`, effectively growing it
-    * If no `LiteralInline` exists in the `InlineProcessor.Inline` property, a new one will be created containing the consumed characters and pushed into the deepest open `ContainerInline`
-
-After that, the working text of the `LeafBlock` has been conceptually shortened by the advancing start of the working `StringSlice`, moving the starting character forward.  If there is still text remaining, the process repeats from the new starting character until all of the text is consumed.
-
-At this point, when all of the source text from the `LeafBlock` has been consumed, a post-processing step occurs.  `InlineParser` objects in the pipeline which also implement `IPostInlineProcessor` are invoked on the `LeafBlock`'s root `ContainerInline`.  This, for example, is the mechanism by which the unstructured output of the `EmphasisInlineParser` is then restructured into cleanly nested `EmphasisInline` and `LiteralInline` elements.
-
-
-#### Responsibilities of an Inline Parser
-
-Like the block parsers, an inline parser must provide an array of opening characters with the `char[]? OpeningCharacter` property.
-
-However, inline parsers only require one other method, the `Match(InlineProcessor processor, ref StringSlice slice)` method, which is expected to determine if a match for the related inline is located at the starting character of the slice.
-
-Within the `Match` method a parser should:
-
-1. Determine if a match begins at the starting character of the `slice` argument
-2. If no match exists, the method should return `false` and not advance the `Start` property of the `slice` argument
-3. If a match does exist, perform the following actions: 
-    * Instantiate the appropriate `Inline` derived class and assign it to the processor argument with `processor.Inline = myInlineObject`
-    * Advance the `Start` property of the `slice` argument by the number of characters contained in the match, for example by using the `NextChar()`, `SkipChar()`, or other helper methods of the `StringSlice` class
-    * Return `true`
-
-While parsing, the `InlineProcessor` performing the processing, which is available to the `Match` function through the `processor` argument, contains a number of properties which can be used to access the current state of parsing.  For example, the `processor.Inline` property is the mechanism for returning a new inline element, but before assignment it contains the last created inline, which in turn can be accessed for its parents.
-
-Additionally, in the case of inlines which can be expected to contain other inlines, a possible strategy is to inject an inline element derived from `DelimiterInline` when the opening delimiter is detected, then to replace the opening delimiter with the final desired element when the closing delimiter is found.  This is the strategy used by the `LinkInlineParser`, for example.  In such cases the tools described in the next section, such as the `ReplaceBy` method, can be used.  Note that if this method is used the post-processing should be invoked on the `InlineProcessor` in order to finalize any emphasis elements.  For example, in the following code adapted from the `LinkInlineParser`:
-
-```csharp
-var parent = processor.Inline?.FirstParentOfType<MyDelimiterInline>();
-if (parent is null) return;
-
-var myInline = new MySpecialInline { /* set span and other parameters here */ };
-
-// Replace the delimiter inline with the final inline type, adopting all of its children
-parent.ReplaceBy(myInline);
-
-// Notifies processor as we are creating an inline locally
-processor.Inline = myInline;
-
-// Process emphasis delimiters
-processor.PostProcessInlines(0, myInline, null, false);
-```
-
-#### Inline Post-Processing
-
-The purpose of post-processing inlines is typically to re-structure inline elements after the initial parsing is complete and the entire structure of the inline elements within a parent container is now available in a way it was not during the parsing process.  Generally this consists of removing, replacing, and re-ordering `Inline` elements.
-
-To this end, the `Inline` abstract base class contains several helper methods intended to allow manipulation of inline elements during the post-processing phase.
-
-|Method|Purpose|
-|-|-|
-|`InsertAfter(...)`|Takes a new inline as an argument and inserts it into the same parent container after this instance|
-|`InsertBefore(...)`|Takes a new inline as an argument and inserts it into the same parent container before this instance|
-|`Remove()`|Removes this inline from its parent container|
-|`ReplaceBy(...)`|Removes this instance and replaces it with a new inline specified in the argument. Has an option to move all of the original inline's children into the new inline.|
-
-Additionally, the `PreviousSibling` and `NextSibling` properties can be used to determine the siblings of an inline element within its parent container.  The `FirstParentOfType<T>()` method can be used to search for a parent element, which is often useful when searching for `DelimiterInline` derived elements, which are implemented as containers.
-

readme.md

@@ -1,8 +1,8 @@
-# Markdig [![ci](https://github.com/xoofx/markdig/actions/workflows/ci.yml/badge.svg)](https://github.com/xoofx/markdig/actions/workflows/ci.yml) [![Coverage Status](https://coveralls.io/repos/github/xoofx/markdig/badge.svg?branch=master)](https://coveralls.io/github/xoofx/markdig?branch=master) [![NuGet](https://img.shields.io/nuget/v/Markdig.svg)](https://www.nuget.org/packages/Markdig/) [![Donate](https://www.paypalobjects.com/en_US/i/btn/btn_donate_SM.gif)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=FRGHXBTP442JL)
+# Markdig [![Build Status](https://github.com/lunet-io/markdig/workflows/ci/badge.svg?branch=master)](https://github.com/lunet-io/markdig/actions) [![Coverage Status](https://coveralls.io/repos/github/xoofx/markdig/badge.svg?branch=master)](https://coveralls.io/github/xoofx/markdig?branch=master) [![NuGet](https://img.shields.io/nuget/v/Markdig.svg)](https://www.nuget.org/packages/Markdig/) [![Donate](https://www.paypalobjects.com/en_US/i/btn/btn_donate_SM.gif)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=FRGHXBTP442JL)
 
 <img align="right" width="160px" height="160px" src="img/markdig.png">
 
-Markdig is a fast, powerful, [CommonMark](https://commonmark.org/) compliant, extensible Markdown processor for .NET.
+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!
 
@@ -12,9 +12,9 @@ You can **try Markdig online** and compare it to other implementations on [babel
 
 - **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 [Markdown Editor v2 for Visual Studio 2022](https://marketplace.visualstudio.com/items?itemName=MadsKristensen.MarkdownEditor2) powered by Markdig!
+  - 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 (0.31.2)](https://spec.commonmark.org/)
+- Passing more than **600+ tests** from the latest [CommonMark specs (0.29)](http://spec.commonmark.org/)
 - Includes all the core elements of CommonMark:
   - including **GFM fenced code blocks**.  
 - **Extensible** architecture
@@ -22,9 +22,9 @@ You can **try Markdig online** and compare it to other implementations on [babel
 - [**Roundtrip support**](./src/Markdig/Roundtrip.md): Parses trivia (whitespace, newlines and other characters) to support lossless parse ⭢ render roundtrip. This enables changing markdown documents without introducing undesired trivia changes.
 - Built-in with **20+ extensions**, including:
   - 2 kind of tables:
-    - [**Pipe tables**](src/Markdig.Tests/Specs/PipeTableSpecs.md) (inspired from GitHub tables and [PanDoc - Pipe Tables](https://pandoc.org/MANUAL.html#extension-pipe_tables))
-    - [**Grid tables**](src/Markdig.Tests/Specs/GridTableSpecs.md) (inspired from [Pandoc - Grid Tables](https://pandoc.org/MANUAL.html#extension-grid_tables)) 
-  - [**Extra emphasis**](src/Markdig.Tests/Specs/EmphasisExtraSpecs.md) (inspired from [Pandoc - Emphasis](https://pandoc.org/MANUAL.html#strikeout) and [Markdown-it](https://markdown-it.github.io/)) 
+    - [**Pipe tables**](src/Markdig.Tests/Specs/PipeTableSpecs.md) (inspired from GitHub tables and [PanDoc - Pipe Tables](http://pandoc.org/README.html#extension-pipe_tables))
+    - [**Grid tables**](src/Markdig.Tests/Specs/GridTableSpecs.md) (inspired from [Pandoc - Grid Tables](http://pandoc.org/README.html#extension-grid_tables)) 
+  - [**Extra emphasis**](src/Markdig.Tests/Specs/EmphasisExtraSpecs.md) (inspired from [Pandoc - Emphasis](http://pandoc.org/README.html#strikeout) and [Markdown-it](https://markdown-it.github.io/)) 
     - strike through `~~`,
     - Subscript `~`
     - Superscript `^` 
@@ -33,7 +33,7 @@ You can **try Markdig online** and compare it to other implementations on [babel
   - [**Special attributes**](src/Markdig.Tests/Specs/GenericAttributesSpecs.md) or attached HTML attributes (inspired from [PHP Markdown Extra - Special Attributes](https://michelf.ca/projects/php-markdown/extra/#spe-attr))
   - [**Definition lists**](src/Markdig.Tests/Specs/DefinitionListSpecs.md) (inspired from [PHP Markdown Extra - Definitions Lists](https://michelf.ca/projects/php-markdown/extra/#def-list))
   - [**Footnotes**](src/Markdig.Tests/Specs/FootnotesSpecs.md) (inspired from [PHP Markdown Extra - Footnotes](https://michelf.ca/projects/php-markdown/extra/#footnotes))
-  - [**Auto-identifiers**](src/Markdig.Tests/Specs/AutoIdentifierSpecs.md) for headings (similar to [Pandoc - Auto Identifiers](https://pandoc.org/MANUAL.html#extension-auto_identifiers))
+  - [**Auto-identifiers**](src/Markdig.Tests/Specs/AutoIdentifierSpecs.md) for headings (similar to [Pandoc - Auto Identifiers](http://pandoc.org/README.html#extension-auto_identifiers))
   - [**Auto-links**](src/Markdig.Tests/Specs/AutoLinks.md) generates links if a text starts with `http://` or `https://` or `ftp://` or `mailto:` or `www.xxx.yyy`
   - [**Task Lists**](src/Markdig.Tests/Specs/TaskListSpecs.md)  inspired from [Github Task lists](https://github.com/blog/1375-task-lists-in-gfm-issues-pulls-comments).
   - [**Extra bullet lists**](src/Markdig.Tests/Specs/ListExtraSpecs.md), supporting alpha bullet `a.` `b.` and roman bullet (`i`, `ii`...etc.)
@@ -48,7 +48,7 @@ You can **try Markdig online** and compare it to other implementations on [babel
   - [**Emoji**](src/Markdig.Tests/Specs/EmojiSpecs.md) support (inspired from [Markdown-it](https://markdown-it.github.io/))
   - [**SmartyPants**](src/Markdig.Tests/Specs/SmartyPantsSpecs.md) (inspired from [Daring Fireball - SmartyPants](https://daringfireball.net/projects/smartypants/))
   - [**Bootstrap**](src/Markdig.Tests/Specs/BootstrapSpecs.md) class (to output bootstrap class)
-  - [**Diagrams**](src/Markdig.Tests/Specs/DiagramsSpecs.md) extension whenever a fenced code block contains a special keyword, it will be converted to a div block with the content as-is (currently, supports [`mermaid`](https://mermaid.js.org) and [`nomnoml`](https://github.com/skanaar/nomnoml) diagrams)
+  - [**Diagrams**](src/Markdig.Tests/Specs/DiagramsSpecs.md) extension whenever a fenced code block contains a special keyword, it will be converted to a div block with the content as-is (currently, supports [`mermaid`](https://knsv.github.io/mermaid/) and [`nomnoml`](https://github.com/skanaar/nomnoml) diagrams)
   - [**YAML Front Matter**](src/Markdig.Tests/Specs/YamlSpecs.md) to parse without evaluating the front matter and to discard it from the HTML output (typically used for previewing without the front matter in MarkdownEditor)
   - [**JIRA links**](src/Markdig.Tests/Specs/JiraLinks.md) to automatically generate links for JIRA project references (Thanks to @clarkd: https://github.com/clarkd/MarkdigJiraLinker)
 - Starting with Markdig version `0.20.0+`, Markdig is compatible only with `NETStandard 2.0`, `NETStandard 2.1`, `NETCoreApp 2.1` and `NETCoreApp 3.1`.
@@ -60,7 +60,6 @@ If you are looking for support for an old .NET Framework 3.5 or 4.0, you can dow
 - [**WPF/XAML Markdown Renderer**: `markdig.wpf`](https://github.com/Kryptos-FR/markdig.wpf)
 - [**WPF/XAML Markdown Renderer**: `Neo.Markdig.Xaml`](https://github.com/neolithos/NeoMarkdigXaml)
 - [**Syntax highlighting**: `Markdig.SyntaxHighlighting`](https://github.com/RichardSlater/Markdig.SyntaxHighlighting)
-- [**Syntax highlighting using ColorCode-Universal**: `Markdown.ColorCode`](https://github.com/wbaldoumas/markdown-colorcode)
 - [**Syntax highlighting using Prism.js**: `WebStoating.Markdig.Prism`](https://github.com/ilich/Markdig.Prism)
 - [**Embedded C# scripting**: `Markdig.Extensions.ScriptCs`](https://github.com/macaba/Markdig.Extensions.ScriptCs)
 
@@ -70,7 +69,7 @@ If you are looking for support for an old .NET Framework 3.5 or 4.0, you can dow
 
 While there is not yet a dedicated documentation, you can find from the [specs documentation](src/Markdig.Tests/Specs/readme.md) how to use these extensions.
 
-In the meantime, you can have a "behind the scene" article about Markdig in my blog post ["Implementing a Markdown Engine for .NET"](https://xoofx.github.io/blog/2016/06/13/implementing-a-markdown-processor-for-dotnet/)
+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
 
@@ -101,13 +100,9 @@ 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)
 
-## Contributing
-
-Contributions are what make the open source community such an amazing place to learn, inspire, and create. Any contributions you make are greatly appreciated. For detailed contributing guidelines, please see [contributing.md](contributing.md).
-
 ## Build
 
-In order to build Markdig, you need to install [.NET 6.0](https://dotnet.microsoft.com/en-us/download)
+In order to build Markdig, you need to install [.NET Core RTM](https://www.microsoft.com/net/core)
 
 ## License
 
@@ -116,44 +111,97 @@ This software is released under the [BSD-Clause 2 license](https://github.com/lu
 
 ## Benchmarking
 
-The latest benchmark was collected on April 23 2022, against the following implementations:
+This is an early preview of the benchmarking against various implementations:
 
-- [Markdig](https://github.com/lunet-io/markdig) (version: 0.30.2): itself
-- [cmark](https://github.com/commonmark/cmark) (version: 0.30.2): Reference C implementation of CommonMark, no support for extensions
-- [CommonMark.NET(master)](https://github.com/Knagis/CommonMark.NET) (version: 0.15.1): CommonMark implementation for .NET, no support for extensions, port of cmark, deprecated.
-- [MarkdownSharp](https://github.com/Kiri-rin/markdownsharp) (version: 2.0.5): Open source C# implementation of Markdown processor, as featured previously on Stack Overflow, regexp based.
+**C implementations**:
+
+- [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
+
+**.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.7.0+
+OS=Microsoft Windows NT 6.2.9200.0
+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
 
-BenchmarkDotNet=v0.13.1, OS=Windows 10.0.22000
-AMD Ryzen 9 5950X, 1 CPU, 32 logical and 16 physical cores
-.NET SDK=6.0.202
-  [Host]     : .NET 6.0.4 (6.0.422.16404), X64 RyuJIT
-  DefaultJob : .NET 6.0.4 (6.0.422.16404), X64 RyuJIT
+Type=Program  Mode=SingleRun  LaunchCount=2
+WarmupCount=2  TargetCount=10
 
-
-|            Method |       Mean |     Error |    StdDev |
-|------------------ |-----------:|----------:|----------:|
-|           markdig |   1.979 ms | 0.0221 ms | 0.0185 ms |
-|             cmark |   2.571 ms | 0.0081 ms | 0.0076 ms |
-|    CommonMark.NET |   2.016 ms | 0.0169 ms | 0.0158 ms |
-|     MarkdownSharp | 221.455 ms | 1.4442 ms | 1.3509 ms |
+                     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 |
 ```
 
-- Markdig is roughly **x100 times faster than MarkdownSharp**
-- **20% faster than the reference cmark C implementation** 
+### Performance for x64:
 
-## Sponsors
+```
+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
+Frequency=3319351 ticks, Resolution=301.2637 ns, Timer=TSC
+HostCLR=MS.NET 4.0.30319.42000, Arch=64-bit RELEASE [RyuJIT]
+JitModules=clrjit-v4.6.1080.0
 
-Supports this project with a monthly donation and help me continue improving it. \[[Become a sponsor](https://github.com/sponsors/xoofx)\]
+Type=Program  Mode=SingleRun  LaunchCount=2
+WarmupCount=2  TargetCount=10
 
-[<img src="https://github.com/lilith.png?size=200" width="64px;" style="border-radius: 50%" alt="lilith"/>](https://github.com/lilith) Lilith River, author of [Imageflow Server, an easy on-demand
-image editing, optimization, and delivery server](https://github.com/imazen/imageflow-server)
+               Method |    Median |    StdDev |  Gen 0 |  Gen 1 | Gen 2 | Bytes Allocated/Op |
+--------------------- |---------- |---------- |------- |------- |------ |------------------- |
+          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 |
+```
+
+## Donate
+
+If you are using this library and find it useful for your project, please consider a donation for it!
+
+[![Donate](https://www.paypalobjects.com/en_US/i/btn/btn_donate_SM.gif)](https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=FRGHXBTP442JL)
 
 ## Credits
 
-Thanks to the fantastic work done by [John Mac Farlane](https://johnmacfarlane.net/) for the CommonMark specs and all the people involved in making Markdown a better standard!
+Thanks to the fantastic work done by [John Mac Farlane](http://johnmacfarlane.net/) for the CommonMark specs and all the people involved in making Markdown a better standard!
 
 This project would not have been possible without this huge foundation.
 
@@ -161,7 +209,7 @@ Thanks also to the project [BenchmarkDotNet](https://github.com/PerfDotNet/Bench
 
 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)
 
-Thanks to the work done by @clarkd on the [JIRA Link extension](https://github.com/clarkd/MarkdigJiraLinker), now included with this project!
+Thanks to the work done by @clarkd on the JIRA Link extension (https://github.com/clarkd/MarkdigJiraLinker), now included with this project!
 ## Author
 
-Alexandre MUTEL aka [xoofx](https://xoofx.github.io/)
+Alexandre MUTEL aka [xoofx](http://xoofx.com)

src/Directory.Packages.props

@@ -1,23 +0,0 @@
-<Project>
-  <PropertyGroup>
-    <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
-    <CentralPackageTransitivePinningEnabled>false</CentralPackageTransitivePinningEnabled>
-  </PropertyGroup>
-  <ItemGroup>
-    <PackageVersion Include="BenchmarkDotNet" Version="0.14.0" />
-    <PackageVersion Include="BenchmarkDotNet.Diagnostics.Windows" Version="0.14.0" />
-    <PackageVersion Include="CommonMark.NET" Version="0.15.1" />
-    <PackageVersion Include="Markdown" Version="2.2.1" />
-    <PackageVersion Include="MarkdownSharp" Version="2.0.5" />
-    <PackageVersion Include="Microsoft.ApplicationInsights.AspNetCore" Version="2.23.0" />
-    <PackageVersion Include="Microsoft.Diagnostics.Runtime" Version="3.1.512801" />
-    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.0.1" />
-    <PackageVersion Include="MinVer" Version="6.0.0" />
-    <PackageVersion Include="NUnit" Version="4.4.0" />
-    <PackageVersion Include="NUnit3TestAdapter" Version="5.2.0" />
-    <PackageVersion Include="SharpFuzz" Version="2.2.0" />
-  </ItemGroup>
-  <ItemGroup Condition=" '$(TargetFramework)' == 'net462' OR '$(TargetFramework)' == 'netstandard2.0'">
-    <PackageVersion Include="System.Memory" Version="4.6.3" />
-  </ItemGroup>
-</Project>

src/Markdig.Benchmarks/CommonMarkLib.cs

@@ -1,38 +1,40 @@
-// Copyright (c) Alexandre Mutel. All rights reserved.
+// Copyright (c) Alexandre Mutel. All rights reserved.
 // This file is licensed under the BSD-Clause 2 license. 
 // See the license.txt file in the project root for more information.
 
+using System;
 using System.Runtime.InteropServices;
 using System.Text;
 
-namespace Testamina.Markdig.Benchmarks;
-
-public static class CommonMarkLib
+namespace Testamina.Markdig.Benchmarks
 {
-    public static string ToHtml(string text)
+    public static class CommonMarkLib
     {
-        unsafe
+        public static string ToHtml(string text)
         {
-            var textAsArray = Encoding.UTF8.GetBytes(text);
-
-            fixed (void* ptext = textAsArray)
+            unsafe
             {
-                var ptr = (byte*)cmark_markdown_to_html(new IntPtr(ptext), text.Length);
-                int length = 0;
-                while (ptr[length] != 0)
+                var textAsArray = Encoding.UTF8.GetBytes(text);
+
+                fixed (void* ptext = textAsArray)
                 {
-                    length++;
+                    var ptr = (byte*)cmark_markdown_to_html(new IntPtr(ptext), text.Length);
+                    int length = 0;
+                    while (ptr[length] != 0)
+                    {
+                        length++;
+                    }
+                    var buffer = new byte[length];
+                    Marshal.Copy(new IntPtr(ptr), buffer, 0, length);
+                    var result = Encoding.UTF8.GetString(buffer);
+                    Marshal.FreeHGlobal(new IntPtr(ptr));
+                    return result;
                 }
-                var buffer = new byte[length];
-                Marshal.Copy(new IntPtr(ptr), buffer, 0, length);
-                var result = Encoding.UTF8.GetString(buffer);
-                Marshal.FreeHGlobal(new IntPtr(ptr));
-                return result;
             }
         }
-    }
 
-    // char *cmark_markdown_to_html(const char *text, size_t len, int options);
-    [DllImport("cmark", CallingConvention = CallingConvention.Cdecl)]
-    private static extern IntPtr cmark_markdown_to_html(IntPtr charBuffer, int len, int options = 0);
+        // char *cmark_markdown_to_html(const char *text, size_t len, int options);
+        [DllImport("cmark", CallingConvention = CallingConvention.Cdecl)]
+        private static extern IntPtr cmark_markdown_to_html(IntPtr charBuffer, int len, int options = 0);
+    }
 }

src/Markdig.Benchmarks/Markdig.Benchmarks.csproj

@@ -1,30 +1,47 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFrameworks>net471</TargetFrameworks>
     <OutputType>Exe</OutputType>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <IsPackable>false</IsPackable>
-    <ImplicitUsings>enable</ImplicitUsings>
   </PropertyGroup>
   <ItemGroup>
     <None Remove="spec.md" />
   </ItemGroup>
+  <ItemGroup>
+    <Reference Include="CommonMarkNew, Version=0.1.0.0, Culture=neutral, PublicKeyToken=001ef8810438905d, processorArchitecture=MSIL">
+      <HintPath>lib\CommonMarkNew.dll</HintPath>
+      <SpecificVersion>False</SpecificVersion>
+      <Aliases>newcmark</Aliases>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="MoonShine">
+      <HintPath>lib\MoonShine.dll</HintPath>
+    </Reference>
+    <Reference Include="MarkdownDeep">
+      <HintPath>lib\MarkdownDeep.dll</HintPath>
+    </Reference>
+  </ItemGroup>
   <ItemGroup>
     <Content Include="cmark.dll">
       <HintPath>cmark.dll</HintPath>
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
+    <Content Include="libsundown.dll">
+      <HintPath>libsundown.dll</HintPath>
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
     <Content Include="spec.md">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </Content>
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="BenchmarkDotNet" />
-    <PackageReference Include="BenchmarkDotNet.Diagnostics.Windows" />
-    <PackageReference Include="CommonMark.NET" />
-    <PackageReference Include="Markdown" />
-    <PackageReference Include="MarkdownSharp" />
-    <PackageReference Include="Microsoft.Diagnostics.Runtime" />
+    <PackageReference Include="BenchmarkDotNet" Version="0.12.1" />
+    <PackageReference Include="BenchmarkDotNet.Diagnostics.Windows" Version="0.12.1" />
+    <PackageReference Include="CommonMark.NET" Version="0.15.1" />
+    <PackageReference Include="MarkdownSharp" Version="2.0.5" />
+    <PackageReference Include="Microsoft.Diagnostics.Runtime" Version="2.0.161401" />
+    <PackageReference Include="Microsoft.Diagnostics.Tracing.TraceEvent" Version="2.0.62" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Markdig\Markdig.csproj" />

src/Markdig.Benchmarks/PipeTable/PipeTableBenchmark.cs

@@ -1,81 +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 BenchmarkDotNet.Attributes;
-using BenchmarkDotNet.Diagnosers;
-using Markdig;
-
-namespace Testamina.Markdig.Benchmarks.PipeTable;
-
-/// <summary>
-/// Benchmark for pipe table parsing performance, especially for large tables.
-/// Tests the performance of PipeTableParser with varying table sizes.
-/// </summary>
-[MemoryDiagnoser]
-[GcServer(true)] // Use server GC to get more comprehensive GC stats
-public class PipeTableBenchmark
-{
-    private string _100Rows = null!;
-    private string _500Rows = null!;
-    private string _1000Rows = null!;
-    private string _1500Rows = null!;
-    private string _5000Rows = null!;
-    private string _10000Rows = null!;
-    private MarkdownPipeline _pipeline = null!;
-
-    [GlobalSetup]
-    public void Setup()
-    {
-        // Pipeline with pipe tables enabled (part of advanced extensions)
-        _pipeline = new MarkdownPipelineBuilder()
-            .UseAdvancedExtensions()
-            .Build();
-
-        // Generate tables of various sizes
-        // Note: Before optimization, 5000+ rows hit depth limit due to nested tree structure.
-        // After optimization, these should work.
-        _100Rows = PipeTableGenerator.Generate(rows: 100, columns: 5);
-        _500Rows = PipeTableGenerator.Generate(rows: 500, columns: 5);
-        _1000Rows = PipeTableGenerator.Generate(rows: 1000, columns: 5);
-        _1500Rows = PipeTableGenerator.Generate(rows: 1500, columns: 5);
-        _5000Rows = PipeTableGenerator.Generate(rows: 5000, columns: 5);
-        _10000Rows = PipeTableGenerator.Generate(rows: 10000, columns: 5);
-    }
-
-    [Benchmark(Description = "PipeTable 100 rows x 5 cols")]
-    public string Parse100Rows()
-    {
-        return Markdown.ToHtml(_100Rows, _pipeline);
-    }
-
-    [Benchmark(Description = "PipeTable 500 rows x 5 cols")]
-    public string Parse500Rows()
-    {
-        return Markdown.ToHtml(_500Rows, _pipeline);
-    }
-
-    [Benchmark(Description = "PipeTable 1000 rows x 5 cols")]
-    public string Parse1000Rows()
-    {
-        return Markdown.ToHtml(_1000Rows, _pipeline);
-    }
-
-    [Benchmark(Description = "PipeTable 1500 rows x 5 cols")]
-    public string Parse1500Rows()
-    {
-        return Markdown.ToHtml(_1500Rows, _pipeline);
-    }
-
-    [Benchmark(Description = "PipeTable 5000 rows x 5 cols")]
-    public string Parse5000Rows()
-    {
-        return Markdown.ToHtml(_5000Rows, _pipeline);
-    }
-
-    [Benchmark(Description = "PipeTable 10000 rows x 5 cols")]
-    public string Parse10000Rows()
-    {
-        return Markdown.ToHtml(_10000Rows, _pipeline);
-    }
-}

src/Markdig.Benchmarks/PipeTable/PipeTableGenerator.cs

@@ -1,61 +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 System.Text;
-
-namespace Testamina.Markdig.Benchmarks.PipeTable;
-
-/// <summary>
-/// Generates pipe table markdown content for benchmarking purposes.
-/// </summary>
-public static class PipeTableGenerator
-{
-    private const int DefaultCellWidth = 10;
-
-    /// <summary>
-    /// Generates a pipe table in markdown format.
-    /// </summary>
-    /// <param name="rows">Number of data rows (excluding header)</param>
-    /// <param name="columns">Number of columns</param>
-    /// <param name="cellWidth">Width of each cell content (default: 10)</param>
-    /// <returns>Pipe table markdown string</returns>
-    public static string Generate(int rows, int columns, int cellWidth = DefaultCellWidth)
-    {
-        var sb = new StringBuilder();
-
-        // Header row
-        sb.Append('|');
-        for (int col = 0; col < columns; col++)
-        {
-            sb.Append(' ');
-            sb.Append($"Header {col + 1}".PadRight(cellWidth));
-            sb.Append(" |");
-        }
-        sb.AppendLine();
-
-        // Separator row (with dashes)
-        sb.Append('|');
-        for (int col = 0; col < columns; col++)
-        {
-            sb.Append(new string('-', cellWidth + 2));
-            sb.Append('|');
-        }
-        sb.AppendLine();
-
-        // Data rows
-        for (int row = 0; row < rows; row++)
-        {
-            sb.Append('|');
-            for (int col = 0; col < columns; col++)
-            {
-                sb.Append(' ');
-                sb.Append($"R{row + 1}C{col + 1}".PadRight(cellWidth));
-                sb.Append(" |");
-            }
-            sb.AppendLine();
-        }
-
-        return sb.ToString();
-    }
-}

src/Markdig.Benchmarks/Program.cs

@@ -1,86 +1,147 @@
-// Copyright (c) Alexandre Mutel. All rights reserved.
+// Copyright (c) Alexandre Mutel. All rights reserved.
 // This file is licensed under the BSD-Clause 2 license. 
 // See the license.txt file in the project root for more information.
-
+extern alias newcmark;
+using System;
+using System.Diagnostics;
+using System.IO;
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Configs;
 using BenchmarkDotNet.Running;
-
 using Markdig;
-using Testamina.Markdig.Benchmarks.PipeTable;
 
 
-namespace Testamina.Markdig.Benchmarks;
-
-//[BenchmarkTask(platform: BenchmarkPlatform.X64, jitVersion: BenchmarkJitVersion.RyuJit, processCount: 1, warmupIterationCount: 2)]
-public class Program
+namespace Testamina.Markdig.Benchmarks
 {
-    private string text;
-
-    public Program()
+    //[BenchmarkTask(platform: BenchmarkPlatform.X64, jitVersion: BenchmarkJitVersion.RyuJit, processCount: 1, warmupIterationCount: 2)]
+    public class Program
     {
-        //text = File.ReadAllText("progit.md");
-        text = File.ReadAllText("spec.md");
-    }
+        private string text;
 
-    //[Benchmark(Description = "TestMarkdig", OperationsPerInvoke = 4096)]
-    [Benchmark(Description = "markdig")]
-    public void TestMarkdig()
-    {
-        //var reader = new StreamReader(File.Open("spec.md", FileMode.Open));
-        Markdown.ToHtml(text);
-        //File.WriteAllText("spec.html", writer.ToString());
-    }
-
-    [Benchmark(Description = "cmark")]
-    public void TestCommonMarkCpp()
-    {
-        //var reader = new StreamReader(File.Open("spec.md", FileMode.Open));
-        CommonMarkLib.ToHtml(text);
-        //File.WriteAllText("spec.html", writer.ToString());
-    }
-
-    [Benchmark(Description = "CommonMark.NET")]
-    public void TestCommonMarkNet()
-    {
-        ////var reader = new StreamReader(File.Open("spec.md", FileMode.Open));
-        // var reader = new StringReader(text);
-        //CommonMark.CommonMarkConverter.Parse(reader);
-        //CommonMark.CommonMarkConverter.Parse(reader);
-        //reader.Dispose();
-        //var writer = new StringWriter();
-        CommonMark.CommonMarkConverter.Convert(text);
-        //writer.Flush();
-        //writer.ToString();
-    }
-
-    [Benchmark(Description = "MarkdownSharp")]
-    public void TestMarkdownSharp()
-    {
-        new MarkdownSharp.Markdown().Transform(text);
-    }
-
-    static void Main(string[] args)
-    {
-        var config = ManualConfig.Create(DefaultConfig.Instance);
-        //var gcDiagnoser = new MemoryDiagnoser();
-        //config.Add(new Job { Mode = Mode.SingleRun, LaunchCount = 2, WarmupCount = 2, IterationTime = 1024, TargetCount = 10 });
-        //config.Add(new Job { Mode = Mode.Throughput, LaunchCount = 2, WarmupCount = 2, TargetCount = 10 });
-        //config.Add(gcDiagnoser);
-
-        //var  config = DefaultConfig.Instance;
-
-        // Run specific benchmarks based on command line arguments
-        if (args.Length > 0 && args[0] == "--pipetable")
+        public Program()
         {
-            BenchmarkRunner.Run<PipeTableBenchmark>(config);
+            //text = File.ReadAllText("progit.md");
+            text = File.ReadAllText("spec.md");
         }
-        else
+
+        //[Benchmark(Description = "TestMarkdig", OperationsPerInvoke = 4096)]
+        [Benchmark]
+        public void TestMarkdig()
         {
-            BenchmarkRunner.Run<Program>(config);
+            //var reader = new StreamReader(File.Open("spec.md", FileMode.Open));
+            Markdown.ToHtml(text);
+            //File.WriteAllText("spec.html", writer.ToString());
+        }
+
+        [Benchmark]
+        public void TestCommonMarkCpp()
+        {
+            //var reader = new StreamReader(File.Open("spec.md", FileMode.Open));
+            CommonMarkLib.ToHtml(text);
+            //File.WriteAllText("spec.html", writer.ToString());
+        }
+
+        [Benchmark]
+        public void TestCommonMarkNet()
+        {
+            ////var reader = new StreamReader(File.Open("spec.md", FileMode.Open));
+            // var reader = new StringReader(text);
+            //CommonMark.CommonMarkConverter.Parse(reader);
+            //CommonMark.CommonMarkConverter.Parse(reader);
+            //reader.Dispose();
+            //var writer = new StringWriter();
+            CommonMark.CommonMarkConverter.Convert(text);
+            //writer.Flush();
+            //writer.ToString();
+        }
+
+        [Benchmark]
+        public void TestCommonMarkNetNew()
+        {
+            ////var reader = new StreamReader(File.Open("spec.md", FileMode.Open));
+            // var reader = new StringReader(text);
+            //CommonMark.CommonMarkConverter.Parse(reader);
+            //CommonMark.CommonMarkConverter.Parse(reader);
+            //reader.Dispose();
+            //var writer = new StringWriter();
+            newcmark::CommonMark.CommonMarkConverter.Convert(text);
+            //writer.Flush();
+            //writer.ToString();
+        }
+
+        [Benchmark]
+        public void TestMarkdownDeep()
+        {
+            new MarkdownDeep.Markdown().Transform(text);
+        }
+
+        [Benchmark]
+        public void TestMarkdownSharp()
+        {
+            new MarkdownSharp.Markdown().Transform(text);
+        }
+
+        [Benchmark]
+        public void TestMoonshine()
+        {
+            Sundown.MoonShine.Markdownify(text);
+        }
+
+        static void Main(string[] args)
+        {
+            bool markdig = args.Length == 0;
+            bool simpleBench = false;
+
+            if (simpleBench)
+            {
+                var clock = Stopwatch.StartNew();
+                var program = new Program();
+
+                GC.Collect(2, GCCollectionMode.Forced, true);
+
+                var gc0 = GC.CollectionCount(0);
+                var gc1 = GC.CollectionCount(1);
+                var gc2 = GC.CollectionCount(2);
+
+                const int count = 12*64;
+                for (int i = 0; i < count; i++)
+                {
+                    if (markdig)
+                    {
+                        program.TestMarkdig();
+                    }
+                    else
+                    {
+                        program.TestCommonMarkNetNew();
+                    }
+                }
+                clock.Stop();
+                Console.WriteLine((markdig ? "MarkDig" : "CommonMark") +  $" => time: {(double)clock.ElapsedMilliseconds/count}ms (total {clock.ElapsedMilliseconds}ms)");
+                DumpGC(gc0, gc1, gc2);
+            }
+            else
+            {
+                //new TestMatchPerf().TestMatch();
+
+                var config = ManualConfig.Create(DefaultConfig.Instance);
+                //var gcDiagnoser = new MemoryDiagnoser();
+                //config.Add(new Job { Mode = Mode.SingleRun, LaunchCount = 2, WarmupCount = 2, IterationTime = 1024, TargetCount = 10 });
+                //config.Add(new Job { Mode = Mode.Throughput, LaunchCount = 2, WarmupCount = 2, TargetCount = 10 });
+                //config.Add(gcDiagnoser);
+
+                //var  config = DefaultConfig.Instance;
+                BenchmarkRunner.Run<Program>(config);
+                //BenchmarkRunner.Run<TestDictionary>(config);
+                //BenchmarkRunner.Run<TestMatchPerf>();
+                //BenchmarkRunner.Run<TestStringPerf>();
+            }
+        }
+
+        private static void DumpGC(int gc0, int gc1, int gc2)
+        {
+            Console.WriteLine($"gc0: {GC.CollectionCount(0)-gc0}");
+            Console.WriteLine($"gc1: {GC.CollectionCount(1)-gc1}");
+            Console.WriteLine($"gc2: {GC.CollectionCount(2)-gc2}");
         }
-        //BenchmarkRunner.Run<TestDictionary>(config);
-        //BenchmarkRunner.Run<TestMatchPerf>();
-        //BenchmarkRunner.Run<TestStringPerf>();
     }
 }

src/Markdig.Benchmarks/TestMatchPerf.cs

@@ -2,79 +2,81 @@
 // This file is licensed under the BSD-Clause 2 license. 
 // See the license.txt file in the project root for more information.
 
+using System.Collections.Generic;
 using System.Text;
 using System.Text.RegularExpressions;
 
-namespace Testamina.Markdig.Benchmarks;
-
-public class TextRegexHelper
+namespace Testamina.Markdig.Benchmarks
 {
-    private readonly Dictionary<string, string> replacers;
-    private readonly Regex regex;
-
-    public TextRegexHelper(Dictionary<string, string> replacers)
+    public class TextRegexHelper
     {
-        this.replacers = replacers;
-        var builder = new StringBuilder();
+        private readonly Dictionary<string, string> replacers;
+        private readonly Regex regex;
 
-        // (?<1>:value:?)|(?<1>:noo:?)
-        foreach (var replace in replacers)
+        public TextRegexHelper(Dictionary<string, string> replacers)
         {
-            var matchStr = Regex.Escape(replace.Key);
-            if (builder.Length > 0)
+            this.replacers = replacers;
+            var builder = new StringBuilder();
+
+            // (?<1>:value:?)|(?<1>:noo:?)
+            foreach (var replace in replacers)
             {
-                builder.Append('|');
+                var matchStr = Regex.Escape(replace.Key);
+                if (builder.Length > 0)
+                {
+                    builder.Append('|');
+                }
+                builder.Append("(?<1>").Append(matchStr).Append("?)");
             }
-            builder.Append("(?<1>").Append(matchStr).Append("?)");
+
+            regex = new Regex(builder.ToString());
         }
 
-        regex = new Regex(builder.ToString());
-    }
-
-    public bool TryMatch(string text, int offset, out string matchText, out string replaceText)
-    {
-        replaceText = null;
-        matchText = null;
-        var result = regex.Match(text, offset);
-        if (!result.Success)
+        public bool TryMatch(string text, int offset, out string matchText, out string replaceText)
         {
-            return false;
+            replaceText = null;
+            matchText = null;
+            var result = regex.Match(text, offset);
+            if (!result.Success)
+            {
+                return false;
+            }
+
+            matchText = result.Groups[1].Value;
+            replaceText = replacers[matchText];
+            return true;
         }
-
-        matchText = result.Groups[1].Value;
-        replaceText = replacers[matchText];
-        return true;
     }
-}
 
-/*
-public class TestMatchPerf
-{
-    private readonly TextMatchHelper matcher;
-
-    public TestMatchPerf()
+    /*
+    public class TestMatchPerf
     {
-        var replacers = new Dictionary<string, string>();
-        for (int i = 0; i < 1000; i++)
+        private readonly TextMatchHelper matcher;
+
+        public TestMatchPerf()
         {
-            replacers.Add($":z{i}:", i.ToString());
+            var replacers = new Dictionary<string, string>();
+            for (int i = 0; i < 1000; i++)
+            {
+                replacers.Add($":z{i}:", i.ToString());
+            }
+            replacers.Add(":abc:", "yes");
+
+            matcher = new TextMatchHelper(new HashSet<string>(replacers.Keys));
         }
-        replacers.Add(":abc:", "yes");
 
-        matcher = new TextMatchHelper(new HashSet<string>(replacers.Keys));
-    }
-
-    [Benchmark]
-    public void TestMatch()
-    {
-
-        for (int i = 0; i < 1000; i++)
+        [Benchmark]
+        public void TestMatch()
         {
-            string matchText;
-            //var text = ":z150: this is a long string";
-            var text = ":z1:";
-            matcher.TryMatch(text, 0, text.Length, out matchText);
+
+            for (int i = 0; i < 1000; i++)
+            {
+                string matchText;
+                //var text = ":z150: this is a long string";
+                var text = ":z1:";
+                matcher.TryMatch(text, 0, text.Length, out matchText);
+            }
         }
     }
-}
-*/
+    */
+}

src/Markdig.Benchmarks/TestStringPerf.cs

@@ -1,57 +1,58 @@
+using System.IO;
 using BenchmarkDotNet.Attributes;
-
 using Markdig.Renderers;
 
-namespace Testamina.Markdig.Benchmarks;
-
-public class TestStringPerf
+namespace Testamina.Markdig.Benchmarks
 {
-    private string text;
-
-    public TestStringPerf()
+    public class TestStringPerf
     {
-        text = new string('a', 1000);
-    }
+        private string text;
 
-    [Benchmark]
-    public void TestIndexOfAny()
-    {
-        var writer = new HtmlRenderer(new StringWriter());
-        for (int i = 0; i < 100; i++)
+        public TestStringPerf()
         {
-            writer.WriteEscape(text, 0, text.Length);
-            writer.WriteEscape(text, 0, text.Length);
-            writer.WriteEscape(text, 0, text.Length);
-            writer.WriteEscape(text, 0, text.Length);
-            writer.WriteEscape(text, 0, text.Length);
-
-            writer.WriteEscape(text, 0, text.Length);
-            writer.WriteEscape(text, 0, text.Length);
-            writer.WriteEscape(text, 0, text.Length);
-            writer.WriteEscape(text, 0, text.Length);
-            writer.WriteEscape(text, 0, text.Length);
+            text = new string('a', 1000);
         }
+
+        [Benchmark]
+        public void TestIndexOfAny()
+        {
+            var writer = new HtmlRenderer(new StringWriter());
+            for (int i = 0; i < 100; i++)
+            {
+                writer.WriteEscape(text, 0, text.Length);
+                writer.WriteEscape(text, 0, text.Length);
+                writer.WriteEscape(text, 0, text.Length);
+                writer.WriteEscape(text, 0, text.Length);
+                writer.WriteEscape(text, 0, text.Length);
+
+                writer.WriteEscape(text, 0, text.Length);
+                writer.WriteEscape(text, 0, text.Length);
+                writer.WriteEscape(text, 0, text.Length);
+                writer.WriteEscape(text, 0, text.Length);
+                writer.WriteEscape(text, 0, text.Length);
+            }
+        }
+
+
+        //[Benchmark]
+        //public void TestCustomIndexOfAny()
+        //{
+        //    var writer = new HtmlRenderer(new StringWriter());
+        //    for (int i = 0; i < 100; i++)
+        //    {
+        //        writer.WriteEscapeOptimized(text, 0, text.Length);
+        //        writer.WriteEscapeOptimized(text, 0, text.Length);
+        //        writer.WriteEscapeOptimized(text, 0, text.Length);
+        //        writer.WriteEscapeOptimized(text, 0, text.Length);
+        //        writer.WriteEscapeOptimized(text, 0, text.Length);
+
+        //        writer.WriteEscapeOptimized(text, 0, text.Length);
+        //        writer.WriteEscapeOptimized(text, 0, text.Length);
+        //        writer.WriteEscapeOptimized(text, 0, text.Length);
+        //        writer.WriteEscapeOptimized(text, 0, text.Length);
+        //        writer.WriteEscapeOptimized(text, 0, text.Length);
+        //    }
+        //}
+
     }
-
-
-    //[Benchmark]
-    //public void TestCustomIndexOfAny()
-    //{
-    //    var writer = new HtmlRenderer(new StringWriter());
-    //    for (int i = 0; i < 100; i++)
-    //    {
-    //        writer.WriteEscapeOptimized(text, 0, text.Length);
-    //        writer.WriteEscapeOptimized(text, 0, text.Length);
-    //        writer.WriteEscapeOptimized(text, 0, text.Length);
-    //        writer.WriteEscapeOptimized(text, 0, text.Length);
-    //        writer.WriteEscapeOptimized(text, 0, text.Length);
-
-    //        writer.WriteEscapeOptimized(text, 0, text.Length);
-    //        writer.WriteEscapeOptimized(text, 0, text.Length);
-    //        writer.WriteEscapeOptimized(text, 0, text.Length);
-    //        writer.WriteEscapeOptimized(text, 0, text.Length);
-    //        writer.WriteEscapeOptimized(text, 0, text.Length);
-    //    }
-    //}
-
 }

src/Markdig.Fuzzing/.gitignore

@@ -1,4 +0,0 @@
-corpus
-libfuzzer-dotnet-windows.exe
-crash-*
-timeout-*

src/Markdig.Fuzzing/Markdig.Fuzzing.csproj

@@ -1,19 +0,0 @@
-<Project Sdk="Microsoft.NET.Sdk">
-
-  <PropertyGroup>
-    <OutputType>Exe</OutputType>
-    <TargetFramework>net9.0</TargetFramework>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <Nullable>enable</Nullable>
-    <IsPackable>false</IsPackable>
-  </PropertyGroup>
-
-  <ItemGroup>
-    <PackageReference Include="SharpFuzz" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ProjectReference Include="..\Markdig\Markdig.csproj" />
-  </ItemGroup>
-
-</Project>

src/Markdig.Fuzzing/Program.cs

@@ -1,71 +0,0 @@
-using Markdig;
-using Markdig.Renderers.Roundtrip;
-using Markdig.Syntax;
-using SharpFuzz;
-using System.Diagnostics;
-using System.Text;
-
-ReadOnlySpanAction fuzzTarget = ParseRenderFuzzer.FuzzTarget;
-
-if (args.Length > 0)
-{
-    // Run the target on existing inputs
-    string[] files = Directory.Exists(args[0])
-        ? Directory.GetFiles(args[0])
-        : [args[0]];
-
-    Debugger.Launch();
-
-    foreach (string inputFile in files)
-    {
-        fuzzTarget(File.ReadAllBytes(inputFile));
-    }
-}
-else
-{
-    Fuzzer.LibFuzzer.Run(fuzzTarget);
-}
-
-sealed class ParseRenderFuzzer
-{
-    private static readonly MarkdownPipeline s_advancedPipeline = new MarkdownPipelineBuilder()
-        .UseAdvancedExtensions()
-        .Build();
-
-    private static readonly ResettableRoundtripRenderer _roundtripRenderer = new();
-
-    public static void FuzzTarget(ReadOnlySpan<byte> bytes)
-    {
-        string text = Encoding.UTF8.GetString(bytes);
-
-        try
-        {
-            MarkdownDocument document = Markdown.Parse(text);
-            _ = document.ToHtml();
-
-            document = Markdown.Parse(text, s_advancedPipeline);
-            _ = document.ToHtml(s_advancedPipeline);
-
-            document = Markdown.Parse(text, trackTrivia: true);
-            _ = document.ToHtml();
-            _roundtripRenderer.Reset();
-            _roundtripRenderer.Render(document);
-
-            _ = Markdown.Normalize(text);
-            _ = Markdown.ToPlainText(text);
-        }
-        catch (Exception ex) when (IsIgnorableException(ex)) { }
-    }
-
-    private static bool IsIgnorableException(Exception exception)
-    {
-        return exception.Message.Contains("Markdown elements in the input are too deeply nested", StringComparison.Ordinal);
-    }
-
-    private sealed class ResettableRoundtripRenderer : RoundtripRenderer
-    {
-        public ResettableRoundtripRenderer() : base(new StringWriter(new StringBuilder(1024 * 1024))) { }
-
-        public new void Reset() => base.Reset();
-    }
-}

src/Markdig.Fuzzing/run-fuzzer.ps1

@@ -1,86 +0,0 @@
-param (
-    [string]$configuration = $null
-)
-
-Set-StrictMode -Version Latest
-
-$libFuzzer = "libfuzzer-dotnet-windows.exe"
-$outputDir = "bin"
-
-function Get-LibFuzzer {
-    param (
-        [string]$Path
-    )
-
-    $libFuzzerUrl = "https://github.com/Metalnem/libfuzzer-dotnet/releases/download/v2025.05.02.0904/libfuzzer-dotnet-windows.exe"
-    $expectedHash = "17af5b3f6ff4d2c57b44b9a35c13051b570eb66f0557d00015df3832709050bf"
-
-    Write-Output "Downloading libFuzzer from $libFuzzerUrl..."
-
-    try {
-        $tempFile = "$Path.tmp"
-        Invoke-WebRequest -Uri $libFuzzerUrl -OutFile $tempFile -UseBasicParsing
-
-        $downloadedHash = (Get-FileHash -Path $tempFile -Algorithm SHA256).Hash
-
-        if ($downloadedHash -eq $ExpectedHash) {
-            Move-Item -Path $tempFile -Destination $Path -Force
-            Write-Output "libFuzzer downloaded successfully to $Path"
-        }
-        else {
-            Write-Error "Hash validation failed."
-            Remove-Item -Path $tempFile -Force -ErrorAction SilentlyContinue
-            exit 1
-        }
-    }
-    catch {
-        Write-Error "Failed to download libFuzzer: $($_.Exception.Message)"
-        Remove-Item -Path $tempFile -Force -ErrorAction SilentlyContinue
-        exit 1
-    }
-}
-
-# Check if libFuzzer exists, download if not
-if (-not (Test-Path $libFuzzer)) {
-    Get-LibFuzzer -Path $libFuzzer
-}
-
-$toolListOutput = dotnet tool list --global sharpFuzz.CommandLine 2>$null
-if (-not ($toolListOutput -match "sharpfuzz")) {
-    Write-Output "Installing sharpfuzz CLI"
-    dotnet tool install --global sharpFuzz.CommandLine
-}
-
-if (Test-Path $outputDir) {
-    Remove-Item -Recurse -Force $outputDir
-}
-
-if ($configuration -eq $null) {
-    $configuration = "Debug"
-}
-
-dotnet publish -c $configuration -o $outputDir
-
-$project = Join-Path $outputDir "Markdig.Fuzzing.dll"
-
-$fuzzingTarget = Join-Path $outputDir "Markdig.dll"
-
-Write-Output "Instrumenting $fuzzingTarget"
-& sharpfuzz $fuzzingTarget
-
-if ($LastExitCode -ne 0) {
-    Write-Error "An error occurred while instrumenting $fuzzingTarget"
-    exit 1
-}
-
-New-Item -ItemType Directory -Force -Path corpus | Out-Null
-
-$libFuzzerArgs = @("--target_path=dotnet", "--target_arg=$project", "-timeout=10", "corpus")
-
-# Add any additional arguments passed to the script
-if ($args) {
-    $libFuzzerArgs += $args
-}
-
-Write-Output "Starting libFuzzer with arguments: $libFuzzerArgs"
-& ./$libFuzzer @libFuzzerArgs

src/Markdig.Tests/GlobalUsings.cs

@@ -1,5 +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.
-
-global using Assert = NUnit.Framework.Legacy.ClassicAssert;

src/Markdig.Tests/Markdig.Tests.csproj

@@ -1,56 +1,24 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net8.0;net9.0</TargetFrameworks>
+    <TargetFramework>net5.0</TargetFramework>
     <OutputType>Exe</OutputType>
     <IsPackable>false</IsPackable>
-    <ImplicitUsings>enable</ImplicitUsings>
-    <LangVersion>13.0</LangVersion>
     <StartupObject>Markdig.Tests.Program</StartupObject>
-    <SpecExecutable>$(MSBuildProjectDirectory)\..\SpecFileGen\bin\$(Configuration)\$(TargetFramework)\SpecFileGen.dll</SpecExecutable>
-    <SpecTimestamp>$(MSBuildProjectDirectory)\..\SpecFileGen\bin\$(Configuration)\$(TargetFramework)\SpecFileGen.timestamp</SpecTimestamp>
-    <NoWarn>$(NoWarn);NETSDK1138</NoWarn>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" />
-    <PackageReference Include="NUnit" />
-    <PackageReference Include="NUnit3TestAdapter" />
+    <PackageReference Include="coverlet.msbuild" Version="2.9.0">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.8.3" />
+    <PackageReference Include="NUnit" Version="3.12.0" />
+    <PackageReference Include="NUnit3TestAdapter" Version="3.17.0" />
   </ItemGroup>
 
   <ItemGroup>
     <ProjectReference Include="..\Markdig\Markdig.csproj" />
-    <ProjectReference Include="..\SpecFileGen\SpecFileGen.csproj" />
   </ItemGroup>
 
-  <ItemGroup>
-    <Using Include="NUnit.Framework" />
-  </ItemGroup>
-
-  <ItemGroup>
-    <ItemSpecExecutable Include="$(SpecExecutable)" />
-    <InputSpecFiles Include="Specs\*.md" />
-    <InputSpecFiles Include="NormalizeSpecs\*.md" />
-    <InputSpecFiles Include="PlainTextSpecs\*.md" />
-    <InputSpecFiles Include="RoundtripSpecs\*.md" />
-    <InputSpecFiles Remove="Specs\readme.md" />
-    <!-- Allow Visual Studio up-to-date check to verify that nothing has changed - https://github.com/dotnet/project-system/blob/main/docs/up-to-date-check.md -->
-    <UpToDateCheckInput Include="@(InputSpecFiles)" />
-    <OutputSpecFiles Include="@(InputSpecFiles-&gt;'%(RelativeDir)%(Filename).generated.cs')" />
-  </ItemGroup>
-
-  <Target Name="GeneratedSpecsFile" BeforeTargets="BeforeCompile;CoreCompile" Inputs="@(ItemSpecExecutable);@(InputSpecFiles)" Outputs="@(ItemSpecExecutable-&gt;'%(RelativeDir)%(Filename).timestamp');@(InputSpecFiles-&gt;'%(RelativeDir)%(Filename).generated.cs')">
-    <Message Importance="high" Text="Regenerating Specs Files" />
-    <Exec Command="dotnet $(SpecExecutable)" />
-    <WriteLinesToFile File="$(SpecTimestamp)" Lines="$([System.DateTime]::Now)" />
-    <ItemGroup>
-      <FileWrites Include="$(SpecTimestamp)" />
-      <_GeneratedSpecsFile Include="Specs\*.generated.cs" />
-      <_GeneratedSpecsFile Include="NormalizeSpecs\*.generated.cs" />
-      <_GeneratedSpecsFile Include="PlainTextSpecs\*.generated.cs" />
-      <_GeneratedSpecsFile Include="RoundtripSpecs\*.generated.cs" />
-      <_GeneratedSpecsFile Remove="@(Compile)" />
-      <Compile Include="@(_GeneratedSpecsFile)" />
-    </ItemGroup>
-  </Target>
 </Project>

src/Markdig.Tests/MiscTests.cs

@@ -1,192 +1,192 @@
+using System;
+using System.IO;
+using System.Linq;
 using System.Text.RegularExpressions;
-
 using Markdig.Extensions.AutoLinks;
-using Markdig.Extensions.Tables;
-using Markdig.Syntax;
 using NUnit.Framework;
 
-namespace Markdig.Tests;
-
-public class MiscTests
+namespace Markdig.Tests
 {
-    [Test]
-    public void LinkWithInvalidNonAsciiDomainNameIsIgnored()
+    public class MiscTests
     {
-        // Url from https://github.com/lunet-io/markdig/issues/438
-        _ = Markdown.ToHtml("[minulém díle](http://V%20minulém%20díle%20jsme%20nainstalovali%20SQL%20Server,%20který%20je%20nutný%20pro%20běh%20Configuration%20Manageru.%20Dnes%20nás%20čeká%20instalace%20WSUS,%20což%20je%20produkt,%20jež%20je%20možné%20používat%20i%20jako%20samostatnou%20funkci%20ve%20Windows%20Serveru,%20který%20se%20stará%20o%20stažení%20a%20instalaci%20aktualizací%20z%20Microsoft%20Update%20na%20klientské%20počítače.%20Stejně%20jako%20v%20předchozích%20dílech,%20tak%20i%20v%20tomto%20si%20ukážeme%20obě%20varianty%20instalace%20–%20a%20to%20jak%20instalaci%20z%20PowerShellu,%20tak%20instalaci%20pomocí%20GUI.) ");
-
-        // Valid IDN
-        TestParser.TestSpec("[foo](http://ünicode.com)", "<p><a href=\"http://xn--nicode-2ya.com\">foo</a></p>");
-        TestParser.TestSpec("[foo](http://ünicode.ünicode.com)", "<p><a href=\"http://xn--nicode-2ya.xn--nicode-2ya.com\">foo</a></p>");
-
-        // Invalid IDN
-        TestParser.TestSpec("[foo](http://ünicode..com)", "<p><a href=\"http://%C3%BCnicode..com\">foo</a></p>");
-    }
-
-    [TestCase("link [foo [bar]]")] // https://spec.commonmark.org/0.29/#example-508
-    [TestCase("link [foo][bar]")]
-    [TestCase("link [][foo][bar][]")]
-    [TestCase("link [][foo][bar][[]]")]
-    [TestCase("link [foo] [bar]")]
-    [TestCase("link [[foo] [] [bar] [[abc]def]]")]
-    [TestCase("[]")]
-    [TestCase("[ ]")]
-    [TestCase("[bar][]")]
-    [TestCase("[bar][ foo]")]
-    [TestCase("[bar][foo ][]")]
-    [TestCase("[bar][fo[ ]o ][][]")]
-    [TestCase("[a]b[c[d[e]f]g]h")]
-    [TestCase("a[b[c[d]e]f[g]h]i foo [j]k[l[m]n]o")]
-    [TestCase("a[b[c[d]e]f[g]h]i[] [][foo][bar][] foo [j]k[l[m]n]o")]
-    [TestCase("a[b[c[d]e]f[g]h]i foo [j]k[l[m]n]o[][]")]
-    public void LinkTextMayContainBalancedBrackets(string linkText)
-    {
-        string markdown = $"[{linkText}](/uri)";
-        string expected = $@"<p><a href=""/uri"">{linkText}</a></p>";
-
-        TestParser.TestSpec(markdown, expected);
-
-        // Make the link text unbalanced
-        foreach (var bracketIndex in linkText
-            .Select((c, i) => new Tuple<char, int>(c, i))
-            .Where(t => t.Item1 == '[' || t.Item1 == ']')
-            .Select(t => t.Item2))
+        [Test]
+        public void LinkWithInvalidNonAsciiDomainNameIsIgnored()
         {
-            string brokenLinkText = linkText.Remove(bracketIndex, 1);
+            // Url from https://github.com/lunet-io/markdig/issues/438
+            _ = Markdown.ToHtml("[minulém díle](http://V%20minulém%20díle%20jsme%20nainstalovali%20SQL%20Server,%20který%20je%20nutný%20pro%20běh%20Configuration%20Manageru.%20Dnes%20nás%20čeká%20instalace%20WSUS,%20což%20je%20produkt,%20jež%20je%20možné%20používat%20i%20jako%20samostatnou%20funkci%20ve%20Windows%20Serveru,%20který%20se%20stará%20o%20stažení%20a%20instalaci%20aktualizací%20z%20Microsoft%20Update%20na%20klientské%20počítače.%20Stejně%20jako%20v%20předchozích%20dílech,%20tak%20i%20v%20tomto%20si%20ukážeme%20obě%20varianty%20instalace%20–%20a%20to%20jak%20instalaci%20z%20PowerShellu,%20tak%20instalaci%20pomocí%20GUI.) ");
 
-            markdown = $"[{brokenLinkText}](/uri)";
-            expected = $@"<p><a href=""/uri"">{brokenLinkText}</a></p>";
+            // Valid IDN
+            TestParser.TestSpec("[foo](http://ünicode.com)", "<p><a href=\"http://xn--nicode-2ya.com\">foo</a></p>");
+            TestParser.TestSpec("[foo](http://ünicode.ünicode.com)", "<p><a href=\"http://xn--nicode-2ya.xn--nicode-2ya.com\">foo</a></p>");
 
-            string actual = Markdown.ToHtml(markdown);
-            Assert.AreNotEqual(expected, actual);
+            // Invalid IDN
+            TestParser.TestSpec("[foo](http://ünicode..com)", "<p><a href=\"http://%C3%BCnicode..com\">foo</a></p>");
         }
-    }
 
-    [Theory]
-    [TestCase('[', 9 * 1024, true, false)]
-    [TestCase('[', 11 * 1024, true, true)]
-    [TestCase('[', 100, false, false)]
-    [TestCase('[', 150, false, true)]
-    [TestCase('>', 100, true, false)]
-    [TestCase('>', 150, true, true)]
-    public void GuardsAgainstHighlyNestedNodes(char c, int count, bool parseOnly, bool shouldThrow)
-    {
-        var markdown = new string(c, count);
-        TestDelegate test = parseOnly ? () => Markdown.Parse(markdown) : () => Markdown.ToHtml(markdown);
-
-        if (shouldThrow)
+        [TestCase("link [foo [bar]]")] // https://spec.commonmark.org/0.29/#example-508
+        [TestCase("link [foo][bar]")]
+        [TestCase("link [][foo][bar][]")]
+        [TestCase("link [][foo][bar][[]]")]
+        [TestCase("link [foo] [bar]")]
+        [TestCase("link [[foo] [] [bar] [[abc]def]]")]
+        [TestCase("[]")]
+        [TestCase("[ ]")]
+        [TestCase("[bar][]")]
+        [TestCase("[bar][ foo]")]
+        [TestCase("[bar][foo ][]")]
+        [TestCase("[bar][fo[ ]o ][][]")]
+        [TestCase("[a]b[c[d[e]f]g]h")]
+        [TestCase("a[b[c[d]e]f[g]h]i foo [j]k[l[m]n]o")]
+        [TestCase("a[b[c[d]e]f[g]h]i[] [][foo][bar][] foo [j]k[l[m]n]o")]
+        [TestCase("a[b[c[d]e]f[g]h]i foo [j]k[l[m]n]o[][]")]
+        public void LinkTextMayContainBalancedBrackets(string linkText)
         {
-            Exception e = Assert.Throws<ArgumentException>(test);
-            Assert.True(e.Message.Contains("depth limit"));
+            string markdown = $"[{linkText}](/uri)";
+            string expected = $@"<p><a href=""/uri"">{linkText}</a></p>";
+
+            TestParser.TestSpec(markdown, expected);
+
+            // Make the link text unbalanced
+            foreach (var bracketIndex in linkText
+                .Select((c, i) => new Tuple<char, int>(c, i))
+                .Where(t => t.Item1 == '[' || t.Item1 == ']')
+                .Select(t => t.Item2))
+            {
+                string brokenLinkText = linkText.Remove(bracketIndex, 1);
+
+                markdown = $"[{brokenLinkText}](/uri)";
+                expected = $@"<p><a href=""/uri"">{brokenLinkText}</a></p>";
+
+                string actual = Markdown.ToHtml(markdown);
+                Assert.AreNotEqual(expected, actual);
+            }
         }
-        else
+
+        [Theory]
+        [TestCase('[', 9 * 1024, true, false)]
+        [TestCase('[', 11 * 1024, true, true)]
+        [TestCase('[', 100, false, false)]
+        [TestCase('[', 150, false, true)]
+        [TestCase('>', 100, true, false)]
+        [TestCase('>', 150, true, true)]
+        public void GuardsAgainstHighlyNestedNodes(char c, int count, bool parseOnly, bool shouldThrow)
         {
-            test();
+            var markdown = new string(c, count);
+            TestDelegate test = parseOnly ? () => Markdown.Parse(markdown) : () => Markdown.ToHtml(markdown);
+
+            if (shouldThrow)
+            {
+                Exception e = Assert.Throws<ArgumentException>(test);
+                Assert.True(e.Message.Contains("depth limit"));
+            }
+            else
+            {
+                test();
+            }
         }
-    }
 
-    [Test]
-    public void IsIssue356Corrected()
-    {
-        string input = @"https://foo.bar/path/\#m4mv5W0GYKZpGvfA.97";
-        string expected = @"<p><a href=""https://foo.bar/path/%5C#m4mv5W0GYKZpGvfA.97"">https://foo.bar/path/\#m4mv5W0GYKZpGvfA.97</a></p>";
-
-        TestParser.TestSpec($"<{input}>", expected);
-        TestParser.TestSpec(input, expected, "autolinks|advanced");
-    }
-
-    [Test]
-    public void IsIssue365Corrected()
-    {
-        // The scheme must be escaped too...
-        string input = "![image](\"onclick=\"alert&amp;#40;'click'&amp;#41;\"://)";
-        string expected = "<p><img src=\"%22onclick=%22alert&amp;#40;%27click%27&amp;#41;%22://\" alt=\"image\" /></p>";
-
-        TestParser.TestSpec(input, expected);
-    }
-
-    [Test]
-    public void TestAltTextIsCorrectlyEscaped()
-    {
-        TestParser.TestSpec(
-            @"![This is image alt text with quotation ' and double quotation ""hello"" world](girl.png)",
-            @"<p><img src=""girl.png"" alt=""This is image alt text with quotation ' and double quotation &quot;hello&quot; world"" /></p>");
-    }
-
-    [Test]
-    public void TestChangelogPRLinksMatchDescription()
-    {
-        string solutionFolder = Path.GetFullPath(Path.Combine(TestParser.TestsDirectory, "../.."));
-        string changelogPath = Path.Combine(solutionFolder, "changelog.md");
-        string changelog = File.ReadAllText(changelogPath);
-        var matches = Regex.Matches(changelog, @"\(\[\(PR #(\d+)\)\]\(.*?pull\/(\d+)\)\)");
-        Assert.Greater(matches.Count, 0);
-        foreach (Match match in matches)
+        [Test]
+        public void IsIssue356Corrected()
         {
-            Assert.True(int.TryParse(match.Groups[1].Value, out int textNr));
-            Assert.True(int.TryParse(match.Groups[2].Value, out int linkNr));
-            Assert.AreEqual(textNr, linkNr);
+            string input = @"https://foo.bar/path/\#m4mv5W0GYKZpGvfA.97";
+            string expected = @"<p><a href=""https://foo.bar/path/%5C#m4mv5W0GYKZpGvfA.97"">https://foo.bar/path/\#m4mv5W0GYKZpGvfA.97</a></p>";
+
+            TestParser.TestSpec($"<{input}>", expected);
+            TestParser.TestSpec(input, expected, "autolinks|advanced");
         }
-    }
 
-    [Test]
-    public void TestFixHang()
-    {
-        var input = File.ReadAllText(Path.Combine(TestParser.TestsDirectory, "hang.md"));
-        _ = Markdown.ToHtml(input);
-    }
+        [Test]
+        public void IsIssue365Corrected()
+        {
+            // The scheme must be escaped too...
+            string input = "![image](\"onclick=\"alert&amp;#40;'click'&amp;#41;\"://)";
+            string expected = "<p><img src=\"%22onclick=%22alert&amp;#40;%27click%27&amp;#41;%22://\" alt=\"image\" /></p>";
 
-    [Test]
-    public void TestInvalidHtmlEntity()
-    {
-        var input = "9&ddr;&*&ddr;&de<64><65>__";
-        TestParser.TestSpec(input, "<p>9&amp;ddr;&amp;*&amp;ddr;&amp;de<64><65>__</p>");
-    }
+            TestParser.TestSpec(input, expected);
+        }
 
-    [Test]
-    public void TestInvalidCharacterHandling()
-    {
-        var input = File.ReadAllText(Path.Combine(TestParser.TestsDirectory, "ArgumentOutOfRangeException.md"));
-        _ = Markdown.ToHtml(input);
-    }
+        [Test]
+        public void TestAltTextIsCorrectlyEscaped()
+        {
+            TestParser.TestSpec(
+                @"![This is image alt text with quotation ' and double quotation ""hello"" world](girl.png)",
+                @"<p><img src=""girl.png"" alt=""This is image alt text with quotation ' and double quotation &quot;hello&quot; world"" /></p>");
+        }
 
-    [Test]
-    public void TestInvalidCodeEscape()
-    {
-        var input = "```**Header**	";
-        _ = Markdown.ToHtml(input);
-    }
+        [Test]
+        public void TestChangelogPRLinksMatchDescription()
+        {
+            string solutionFolder = Path.GetFullPath(Path.Combine(TestParser.TestsDirectory, "../.."));
+            string changelogPath = Path.Combine(solutionFolder, "changelog.md");
+            string changelog = File.ReadAllText(changelogPath);
+            var matches = Regex.Matches(changelog, @"\(\[\(PR #(\d+)\)\]\(.*?pull\/(\d+)\)\)");
+            Assert.Greater(matches.Count, 0);
+            foreach (Match match in matches)
+            {
+                Assert.True(int.TryParse(match.Groups[1].Value, out int textNr));
+                Assert.True(int.TryParse(match.Groups[2].Value, out int linkNr));
+                Assert.AreEqual(textNr, linkNr);
+            }
+        }
 
-    [Test]
-    public void TestEmphasisAndHtmlEntity()
-    {
-        var markdownText = "*Unlimited-Fun&#174;*&#174;";
-        TestParser.TestSpec(markdownText, "<p><em>Unlimited-Fun®</em>®</p>");
-    }
+        [Test]
+        public void TestFixHang()
+        {
+            var input = File.ReadAllText(Path.Combine(TestParser.TestsDirectory, "hang.md"));
+            _ = Markdown.ToHtml(input);
+        }
 
-    [Test]
-    public void TestThematicInsideCodeBlockInsideList()
-    {
-        var input = @"1. In the :
+        [Test]
+        public void TestInvalidHtmlEntity()
+        {
+            var input = "9&ddr;&*&ddr;&de<64><65>__";
+            TestParser.TestSpec(input, "<p>9&amp;ddr;&amp;*&amp;ddr;&amp;de<64><65>__</p>");
+        }
+
+        [Test]
+        public void TestInvalidCharacterHandling()
+        {
+            var input = File.ReadAllText(Path.Combine(TestParser.TestsDirectory, "ArgumentOutOfRangeException.md"));
+            _ = Markdown.ToHtml(input);
+        }
+
+        [Test]
+        public void TestInvalidCodeEscape()
+        {
+            var input = "```**Header**	";
+            _ = Markdown.ToHtml(input);
+        }
+
+        [Test]
+        public void TestEmphasisAndHtmlEntity()
+        {
+            var markdownText = "*Unlimited-Fun&#174;*&#174;";
+            TestParser.TestSpec(markdownText, "<p><em>Unlimited-Fun®</em>®</p>");
+        }
+
+        [Test]
+        public void TestThematicInsideCodeBlockInsideList()
+        {
+            var input = @"1. In the :
 
    ```
    Id                                   DisplayName         Description
    --                                   -----------         -----------
    62375ab9-6b52-47ed-826b-58e47e0e304b Group.Unified       ...
    ```";
-        TestParser.TestSpec(input, @"<ol>
+            TestParser.TestSpec(input, @"<ol>
 <li><p>In the :</p>
 <pre><code>Id                                   DisplayName         Description
 --                                   -----------         -----------
 62375ab9-6b52-47ed-826b-58e47e0e304b Group.Unified       ...
 </code></pre></li>
 </ol>");
-    }
+        }
 
-    [Test]
-    public void VisualizeMathExpressions()
-    {
-        string math = @"Math expressions
+        [Test]
+        public void VisualizeMathExpressions()
+        {
+            string math = @"Math expressions
 
 $\frac{n!}{k!(n-k)!} = \binom{n}{k}$
 
@@ -199,214 +199,90 @@ $$
 <div class=""math"">
 \begin{align}
 \sqrt{37} & = \sqrt{\frac{73^2-1}{12^2}} \\
- & = \sqrt{\frac{73^2}{12^2}\cdot\frac{73^2-1}{73^2}} \\
+ & = \sqrt{\frac{73^2}{12^2}\cdot\frac{73^2-1}{73^2}} \\ 
  & = \sqrt{\frac{73^2}{12^2}}\sqrt{\frac{73^2-1}{73^2}} \\
- & = \frac{73}{12}\sqrt{1 - \frac{1}{73^2}} \\
+ & = \frac{73}{12}\sqrt{1 - \frac{1}{73^2}} \\ 
  & \approx \frac{73}{12}\left(1 - \frac{1}{2\cdot73^2}\right)
 \end{align}
 </div>
 ";
-        //Console.WriteLine("Math Expressions:\n");
-        var pl = new MarkdownPipelineBuilder().UseMathematics().Build(); // UseEmphasisExtras(EmphasisExtraOptions.Subscript).Build()
-        var html = Markdown.ToHtml(math, pl);
-        //Console.WriteLine(html);
-    }
+            Console.WriteLine("Math Expressions:\n");
 
-    [Test]
-    public void InlineMathExpression()
-    {
-        string math = @"Math expressions
+            var pl = new MarkdownPipelineBuilder().UseMathematics().Build(); // UseEmphasisExtras(EmphasisExtraOptions.Subscript).Build()
 
-$\frac{n!}{k!(n-k)!} = \binom{n}{k}$
-";
-        var pl = new MarkdownPipelineBuilder().UseMathematics().Build(); // UseEmphasisExtras(EmphasisExtraOptions.Subscript).Build()
 
-        var html = Markdown.ToHtml(math, pl);
-
-        var test1 = html.Contains("<p><span class=\"math\">\\(");
-        var test2 = html.Contains("\\)</span></p>");
-        if (!test1 || !test2)
-        {
+            var html = Markdown.ToHtml(math, pl);
             Console.WriteLine(html);
         }
 
-        Assert.IsTrue(test1, "Leading bracket missing");
-        Assert.IsTrue(test2, "Trailing bracket missing");
-    }
+        [Test]
+        public void InlineMathExpression()
+        {
+            string math = @"Math expressions
 
-    [Test]
-    public void BlockMathExpression()
-    {
-        string math = @"Math expressions
+$\frac{n!}{k!(n-k)!} = \binom{n}{k}$
+";
+            var pl = new MarkdownPipelineBuilder().UseMathematics().Build(); // UseEmphasisExtras(EmphasisExtraOptions.Subscript).Build()
+
+            var html = Markdown.ToHtml(math, pl);
+            Console.WriteLine(html);
+
+            Assert.IsTrue(html.Contains("<p><span class=\"math\">\\("), "Leading bracket missing");
+            Assert.IsTrue(html.Contains("\\)</span></p>"), "Trailing bracket missing");
+        }
+
+        [Test]
+        public void BlockMathExpression()
+        {
+            string math = @"Math expressions
 
 $$
 \frac{n!}{k!(n-k)!} = \binom{n}{k}
 $$
 ";
-        var pl = new MarkdownPipelineBuilder().UseMathematics().Build(); // UseEmphasisExtras(EmphasisExtraOptions.Subscript).Build()
+            var pl = new MarkdownPipelineBuilder().UseMathematics().Build(); // UseEmphasisExtras(EmphasisExtraOptions.Subscript).Build()
 
-        var html = Markdown.ToHtml(math, pl);
-        var test1 = html.Contains("<div class=\"math\">\n\\[");
-        var test2 = html.Contains("\\]</div>");
-        if (!test1 || !test2)
-        {
+            var html = Markdown.ToHtml(math, pl);
             Console.WriteLine(html);
+
+            Assert.IsTrue(html.Contains("<div class=\"math\">\n\\["), "Leading bracket missing");
+            Assert.IsTrue(html.Contains("\\]</div>"), "Trailing bracket missing");
         }
 
-        Assert.IsTrue(test1, "Leading bracket missing");
-        Assert.IsTrue(test2, "Trailing bracket missing");
-    }
+        [Test]
+        public void CanDisableParsingHeadings()
+        {
+            var noHeadingsPipeline = new MarkdownPipelineBuilder().DisableHeadings().Build();
 
-    [Test]
-    public void CanDisableParsingHeadings()
-    {
-        var noHeadingsPipeline = new MarkdownPipelineBuilder().DisableHeadings().Build();
+            TestParser.TestSpec("Foo\n===", "<h1>Foo</h1>");
+            TestParser.TestSpec("Foo\n===", "<p>Foo\n===</p>", noHeadingsPipeline);
 
-        TestParser.TestSpec("Foo\n===", "<h1>Foo</h1>");
-        TestParser.TestSpec("Foo\n===", "<p>Foo\n===</p>", noHeadingsPipeline);
+            TestParser.TestSpec("# Heading 1", "<h1>Heading 1</h1>");
+            TestParser.TestSpec("# Heading 1", "<p># Heading 1</p>", noHeadingsPipeline);
 
-        TestParser.TestSpec("# Heading 1", "<h1>Heading 1</h1>");
-        TestParser.TestSpec("# Heading 1", "<p># Heading 1</p>", noHeadingsPipeline);
+            // Does not also disable link reference definitions
+            TestParser.TestSpec("[Foo]\n\n[Foo]: bar", "<p><a href=\"bar\">Foo</a></p>");
+            TestParser.TestSpec("[Foo]\n\n[Foo]: bar", "<p><a href=\"bar\">Foo</a></p>", noHeadingsPipeline);
+        }
 
-        // Does not also disable link reference definitions
-        TestParser.TestSpec("[Foo]\n\n[Foo]: bar", "<p><a href=\"bar\">Foo</a></p>");
-        TestParser.TestSpec("[Foo]\n\n[Foo]: bar", "<p><a href=\"bar\">Foo</a></p>", noHeadingsPipeline);
-    }
+        [Test]
+        public void CanOpenAutoLinksInNewWindow()
+        {
+            var pipeline = new MarkdownPipelineBuilder().UseAutoLinks().Build();
+            var newWindowPipeline = new MarkdownPipelineBuilder().UseAutoLinks(new AutoLinkOptions() { OpenInNewWindow = true }).Build();
 
-    [Test]
-    public void CanOpenAutoLinksInNewWindow()
-    {
-        var pipeline = new MarkdownPipelineBuilder().UseAutoLinks().Build();
-        var newWindowPipeline = new MarkdownPipelineBuilder().UseAutoLinks(new AutoLinkOptions() { OpenInNewWindow = true }).Build();
+            TestParser.TestSpec("www.foo.bar", "<p><a href=\"http://www.foo.bar\">www.foo.bar</a></p>", pipeline);
+            TestParser.TestSpec("www.foo.bar", "<p><a href=\"http://www.foo.bar\" target=\"blank\">www.foo.bar</a></p>", newWindowPipeline);
+        }
 
-        TestParser.TestSpec("www.foo.bar", "<p><a href=\"http://www.foo.bar\">www.foo.bar</a></p>", pipeline);
-        TestParser.TestSpec("www.foo.bar", "<p><a href=\"http://www.foo.bar\" target=\"_blank\">www.foo.bar</a></p>", newWindowPipeline);
-    }
+        [Test]
+        public void CanUseHttpsPrefixForWWWAutoLinks()
+        {
+            var pipeline = new MarkdownPipelineBuilder().UseAutoLinks().Build();
+            var httpsPipeline = new MarkdownPipelineBuilder().UseAutoLinks(new AutoLinkOptions() { UseHttpsForWWWLinks = true }).Build();
 
-    [Test]
-    public void CanUseHttpsPrefixForWWWAutoLinks()
-    {
-        var pipeline = new MarkdownPipelineBuilder().UseAutoLinks().Build();
-        var httpsPipeline = new MarkdownPipelineBuilder().UseAutoLinks(new AutoLinkOptions() { UseHttpsForWWWLinks = true }).Build();
-
-        TestParser.TestSpec("www.foo.bar", "<p><a href=\"http://www.foo.bar\">www.foo.bar</a></p>", pipeline);
-        TestParser.TestSpec("www.foo.bar", "<p><a href=\"https://www.foo.bar\">www.foo.bar</a></p>", httpsPipeline);
-    }
-
-    [Test]
-    public void RootInlineHasCorrectSourceSpan()
-    {
-        var pipeline = new MarkdownPipelineBuilder().UsePreciseSourceLocation().Build();
-        pipeline.TrackTrivia = true;
-
-        var document = Markdown.Parse("0123456789\n", pipeline);
-
-        var expectedSourceSpan = new SourceSpan(0, 10);
-        Assert.That(((LeafBlock)document.LastChild).Inline.Span == expectedSourceSpan);
-    }
-
-    [Test]
-    public void RootInlineInTableCellHasCorrectSourceSpan()
-    {
-        var pipeline = new MarkdownPipelineBuilder().UsePreciseSourceLocation().UseAdvancedExtensions().Build();
-        pipeline.TrackTrivia = true;
-
-        var document = Markdown.Parse("| a | b |\n| --- | --- |\n| <span id=\"dest\"></span><span id=\"DEST\"></span>*dest*<br/> | \\[in\\] The address of the result of the operation.<br/> |", pipeline);
-
-        var paragraph = (ParagraphBlock)((TableCell)((TableRow)((Table)document.LastChild).LastChild).First()).LastChild;
-        Assert.That(paragraph.Inline.Span.Start == paragraph.Inline.FirstChild.Span.Start);
-        Assert.That(paragraph.Inline.Span.End == paragraph.Inline.LastChild.Span.End);
-    }
-
-    [Test]
-    public void TestGridTableShortLine()
-    {
-        var input = @"
-+--+
-|  |
-+-";
-
-        var expected = @"<table>
-<col style=""width:100%"" />
-<tbody>
-<tr>
-<td></td>
-</tr>
-</tbody>
-</table>
-";
-        TestParser.TestSpec(input, expected, new MarkdownPipelineBuilder().UseGridTables().Build());
-    }
-  
-    [Test]
-    public void TestDefinitionListInListItemWithBlankLine()
-    {
-        var input = @"
-- 
-
-  term
-  :   definition
-";
-
-        var expected = @"<ul>
-<li>
-<dl>
-<dt>term</dt>
-<dd>definition</dd>
-</dl>
-</li>
-</ul>
-";
-        TestParser.TestSpec(input, expected, new MarkdownPipelineBuilder().UseDefinitionLists().Build());
-    }
-
-    [Test]
-    public void TestAlertWithinAlertOrNestedBlock()
-    {
-        var input = @"
->[!NOTE]
-[!NOTE]
-The second one is not a note.
-
->>[!NOTE]
-Also not a note.
-";
-
-        var expected = @"<div class=""markdown-alert markdown-alert-note"">
-<p class=""markdown-alert-title""><svg viewBox=""0 0 16 16"" version=""1.1"" width=""16"" height=""16"" aria-hidden=""true""><path d=""M0 8a8 8 0 1 1 16 0A8 8 0 0 1 0 8Zm8-6.5a6.5 6.5 0 1 0 0 13 6.5 6.5 0 0 0 0-13ZM6.5 7.75A.75.75 0 0 1 7.25 7h1a.75.75 0 0 1 .75.75v2.75h.25a.75.75 0 0 1 0 1.5h-2a.75.75 0 0 1 0-1.5h.25v-2h-.25a.75.75 0 0 1-.75-.75ZM8 6a1 1 0 1 1 0-2 1 1 0 0 1 0 2Z""></path></svg>Note</p>
-<p>[!NOTE]
-The second one is not a note.</p>
-</div>
-<blockquote>
-<blockquote>
-<p>[!NOTE]
-Also not a note.</p>
-</blockquote>
-</blockquote>
-";
-        TestParser.TestSpec(input, expected, new MarkdownPipelineBuilder().UseAlertBlocks().Build());
-    }
-
-
-    [Test]
-    public void TestIssue845ListItemBlankLine()
-    {
-        TestParser.TestSpec("-\n\n  foo",@"
-<ul>
-<li></li>
-</ul>
-<p>foo</p>");
-        TestParser.TestSpec("-\n-\n\n  foo",@"
-<ul>
-<li></li>
-<li></li>
-</ul>
-<p>foo</p>");
-        TestParser.TestSpec("-\n\n-\n\n  foo",@"
-<ul>
-<li></li>
-<li></li>
-</ul>
-<p>foo</p>");
+            TestParser.TestSpec("www.foo.bar", "<p><a href=\"http://www.foo.bar\">www.foo.bar</a></p>", pipeline);
+            TestParser.TestSpec("www.foo.bar", "<p><a href=\"https://www.foo.bar\">www.foo.bar</a></p>", httpsPipeline);
+        }
     }
 }

src/Markdig.Tests/NormalizeSpecs/Headings.generated.cs

@@ -44,7 +44,8 @@ namespace Markdig.Tests.Specs.Normalize.Headings
             //     
             //     ###### Heading 6
 
-            TestNormalize.TestSpec("# Heading 1\n\n## Heading 2\n\n### Heading 3\n\n#### Heading 4\n\n##### Heading 5\n\n###### Heading 6", "# Heading 1\n\n## Heading 2\n\n### Heading 3\n\n#### Heading 4\n\n##### Heading 5\n\n###### Heading 6", "", context: "Example 1\nSection Headings\n");
+            Console.WriteLine("Example 1\nSection Headings\n");
+            TestNormalize.TestSpec("# Heading 1\n\n## Heading 2\n\n### Heading 3\n\n#### Heading 4\n\n##### Heading 5\n\n###### Heading 6", "# Heading 1\n\n## Heading 2\n\n### Heading 3\n\n#### Heading 4\n\n##### Heading 5\n\n###### Heading 6", "");
         }
 
         [Test]
@@ -63,7 +64,8 @@ namespace Markdig.Tests.Specs.Normalize.Headings
             //     
             //     Text after two newlines
 
-            TestNormalize.TestSpec("###### Heading\n\nText after two newlines", "###### Heading\n\nText after two newlines", "", context: "Example 2\nSection Headings\n");
+            Console.WriteLine("Example 2\nSection Headings\n");
+            TestNormalize.TestSpec("###### Heading\n\nText after two newlines", "###### Heading\n\nText after two newlines", "");
         }
 
         [Test]
@@ -83,7 +85,8 @@ namespace Markdig.Tests.Specs.Normalize.Headings
             //     
             //     Text after two newlines 1
 
-            TestNormalize.TestSpec("Heading\n=======\n\nText after two newlines 1", "# Heading\n\nText after two newlines 1", "", context: "Example 3\nSection Headings\n");
+            Console.WriteLine("Example 3\nSection Headings\n");
+            TestNormalize.TestSpec("Heading\n=======\n\nText after two newlines 1", "# Heading\n\nText after two newlines 1", "");
         }
     }
 }

src/Markdig.Tests/PlainTextSpecs/SamplePlainText.generated.cs

@@ -27,7 +27,8 @@ namespace Markdig.Tests.Specs.PlainText.Sample
             //     Hello, world!
             //     
 
-            TestPlainText.TestSpec("*Hello*, [world](http://example.com)!", "Hello, world!\n", "", context: "Example 1\nSection Sample plain text spec\n");
+            Console.WriteLine("Example 1\nSection Sample plain text spec\n");
+            TestPlainText.TestSpec("*Hello*, [world](http://example.com)!", "Hello, world!\n", "");
         }
     }
 }

src/Markdig.Tests/Program.cs

@@ -2,15 +2,42 @@
 // This file is licensed under the BSD-Clause 2 license.
 // See the license.txt file in the project root for more information.
 
-namespace Markdig.Tests;
+using System;
+using System.Diagnostics;
+using System.IO;
+using Markdig.Jira;
+using Markdig.Renderers.Normalize;
+using Markdig.Renderers.Roundtrip;
 
-class Program
+namespace Markdig.Tests
 {
-    public static void Main(string[] args)
+    class Program
     {
-        Console.WriteLine("Run NUnit tests runner with this");
-        // Uncomment the following line to debug a specific tests more easily
-        //var tests = new Specs.CommonMarkV_0_29.TestLeafBlocksSetextHeadings();
-        //tests.LeafBlocksSetextHeadings_Example063();
+        public static void Main(string[] args)
+        {
+            Console.WriteLine("Run NUnit tests runner with this");
+            // Uncomment the following line to debug a specific tests more easily
+            //var tests = new Specs.CommonMarkV_0_29.TestLeafBlocksSetextHeadings();
+            //tests.LeafBlocksSetextHeadings_Example063();
+
+
+            var parser = new WikiMarkupParser();
+
+            var doc = parser.Parse("This is a *text*\n{noformat}\nYo\n{noformat}\nAnother paragraph\n");
+
+            var writer = new StringWriter();
+            var renderer = new RoundtripRenderer(writer);
+            
+            var pipeline = new MarkdownPipelineBuilder().UseEmphasisExtras().UseCustomContainers().Build();
+            pipeline.Setup(renderer);
+
+            renderer.Render(doc);
+
+            var result = writer.ToString();
+
+            Console.WriteLine(result);
+
+
+        }
     }
 }

src/Markdig.Tests/RoundtripSpecs/TestAtxHeading.cs

@@ -1,53 +1,55 @@
+using NUnit.Framework;
 using static Markdig.Tests.TestRoundtrip;
 
-namespace Markdig.Tests.RoundtripSpecs;
-
-[TestFixture]
-public class TestAtxHeading
+namespace Markdig.Tests.RoundtripSpecs
 {
-    [TestCase("# h")]
-    [TestCase("# h ")]
-    [TestCase("# h\n#h")]
-    [TestCase("# h\n #h")]
-    [TestCase("# h\n # h")]
-    [TestCase("# h\n # h ")]
-    [TestCase(" #  h   \n    #     h      ")]
-    public void Test(string value)
+    [TestFixture]
+    public class TestAtxHeading
     {
-        RoundTrip(value);
-    }
+        [TestCase("# h")]
+        [TestCase("# h ")]
+        [TestCase("# h\n#h")]
+        [TestCase("# h\n #h")]
+        [TestCase("# h\n # h")]
+        [TestCase("# h\n # h ")]
+        [TestCase(" #  h   \n    #     h      ")]
+        public void Test(string value)
+        {
+            RoundTrip(value);
+        }
 
-    [TestCase("\n# h\n\np")]
-    [TestCase("\n# h\n\np\n")]
-    [TestCase("\n# h\n\np\n\n")]
-    [TestCase("\n\n# h\n\np\n\n")]
-    [TestCase("\n\n# h\np\n\n")]
-    [TestCase("\n\n# h\np\n\n")]
-    public void TestParagraph(string value)
-    {
-        RoundTrip(value);
-    }
+        [TestCase("\n# h\n\np")]
+        [TestCase("\n# h\n\np\n")]
+        [TestCase("\n# h\n\np\n\n")]
+        [TestCase("\n\n# h\n\np\n\n")]
+        [TestCase("\n\n# h\np\n\n")]
+        [TestCase("\n\n# h\np\n\n")]
+        public void TestParagraph(string value)
+        {
+            RoundTrip(value);
+        }
 
-    [TestCase("\n# h")]
-    [TestCase("\n# h\n")]
-    [TestCase("\n# h\r")]
-    [TestCase("\n# h\r\n")]
+        [TestCase("\n# h")]
+        [TestCase("\n# h\n")]
+        [TestCase("\n# h\r")]
+        [TestCase("\n# h\r\n")]
 
-    [TestCase("\r# h")]
-    [TestCase("\r# h\n")]
-    [TestCase("\r# h\r")]
-    [TestCase("\r# h\r\n")]
+        [TestCase("\r# h")]
+        [TestCase("\r# h\n")]
+        [TestCase("\r# h\r")]
+        [TestCase("\r# h\r\n")]
 
-    [TestCase("\r\n# h")]
-    [TestCase("\r\n# h\n")]
-    [TestCase("\r\n# h\r")]
-    [TestCase("\r\n# h\r\n")]
+        [TestCase("\r\n# h")]
+        [TestCase("\r\n# h\n")]
+        [TestCase("\r\n# h\r")]
+        [TestCase("\r\n# h\r\n")]
 
-    [TestCase("# h\n\n ")]
-    [TestCase("# h\n\n  ")]
-    [TestCase("# h\n\n   ")]
-    public void TestNewline(string value)
-    {
-        RoundTrip(value);
+        [TestCase("# h\n\n ")]
+        [TestCase("# h\n\n  ")]
+        [TestCase("# h\n\n   ")]
+        public void TestNewline(string value)
+        {
+            RoundTrip(value);
+        }
     }
 }

src/Markdig.Tests/RoundtripSpecs/TestFencedCodeBlock.cs

@@ -1,105 +1,107 @@
+using NUnit.Framework;
 using static Markdig.Tests.TestRoundtrip;
 
-namespace Markdig.Tests.RoundtripSpecs;
-
-[TestFixture]
-public class TestFencedCodeBlock
+namespace Markdig.Tests.RoundtripSpecs
 {
-    [TestCase("```\nc\n```")]
-    [TestCase("```\nc\n```\n")]
-    [TestCase("\n```\nc\n```")]
-    [TestCase("\n\n```\nc\n```")]
-    [TestCase("```\nc\n```\n")]
-    [TestCase("```\nc\n```\n\n")]
-    [TestCase("\n```\nc\n```\n")]
-    [TestCase("\n```\nc\n```\n\n")]
-    [TestCase("\n\n```\nc\n```\n")]
-    [TestCase("\n\n```\nc\n```\n\n")]
-
-    [TestCase(" ```\nc\n````")]
-    [TestCase("```\nc\n````")]
-    [TestCase("p\n\n```\nc\n```")]
-
-    [TestCase("```\n c\n```")]
-    [TestCase("```\nc \n```")]
-    [TestCase("```\n c \n```")]
-
-    [TestCase(" ``` \n c \n ``` ")]
-    [TestCase("\t```\t\n\tc\t\n\t```\t")]
-    [TestCase("\v```\v\n\vc\v\n\v```\v")]
-    [TestCase("\f```\f\n\fc\f\n\f```\f")]
-    public void Test(string value)
+    [TestFixture]
+    public class TestFencedCodeBlock
     {
-        RoundTrip(value);
-    }
+        [TestCase("```\nc\n```")]
+        [TestCase("```\nc\n```\n")]
+        [TestCase("\n```\nc\n```")]
+        [TestCase("\n\n```\nc\n```")]
+        [TestCase("```\nc\n```\n")]
+        [TestCase("```\nc\n```\n\n")]
+        [TestCase("\n```\nc\n```\n")]
+        [TestCase("\n```\nc\n```\n\n")]
+        [TestCase("\n\n```\nc\n```\n")]
+        [TestCase("\n\n```\nc\n```\n\n")]
 
-    [TestCase("~~~ aa ``` ~~~\nfoo\n~~~")]
-    [TestCase("~~~ aa ``` ~~~\nfoo\n~~~ ")]
-    public void TestTilde(string value)
-    {
-        RoundTrip(value);
-    }
+        [TestCase(" ```\nc\n````")]
+        [TestCase("```\nc\n````")]
+        [TestCase("p\n\n```\nc\n```")]
 
-    [TestCase("```\n c \n```")]
-    [TestCase("```\n c \r```")]
-    [TestCase("```\n c \r\n```")]
-    [TestCase("```\r c \n```")]
-    [TestCase("```\r c \r```")]
-    [TestCase("```\r c \r\n```")]
-    [TestCase("```\r\n c \n```")]
-    [TestCase("```\r\n c \r```")]
-    [TestCase("```\r\n c \r\n```")]
+        [TestCase("```\n c\n```")]
+        [TestCase("```\nc \n```")]
+        [TestCase("```\n c \n```")]
 
-    [TestCase("```\n c \n```\n")]
-    [TestCase("```\n c \r```\n")]
-    [TestCase("```\n c \r\n```\n")]
-    [TestCase("```\r c \n```\n")]
-    [TestCase("```\r c \r```\n")]
-    [TestCase("```\r c \r\n```\n")]
-    [TestCase("```\r\n c \n```\n")]
-    [TestCase("```\r\n c \r```\n")]
-    [TestCase("```\r\n c \r\n```\n")]
+        [TestCase(" ``` \n c \n ``` ")]
+        [TestCase("\t```\t\n\tc\t\n\t```\t")]
+        [TestCase("\v```\v\n\vc\v\n\v```\v")]
+        [TestCase("\f```\f\n\fc\f\n\f```\f")]
+        public void Test(string value)
+        {
+            RoundTrip(value);
+        }
 
-    [TestCase("```\n c \n```\r")]
-    [TestCase("```\n c \r```\r")]
-    [TestCase("```\n c \r\n```\r")]
-    [TestCase("```\r c \n```\r")]
-    [TestCase("```\r c \r```\r")]
-    [TestCase("```\r c \r\n```\r")]
-    [TestCase("```\r\n c \n```\r")]
-    [TestCase("```\r\n c \r```\r")]
-    [TestCase("```\r\n c \r\n```\r")]
+        [TestCase("~~~ aa ``` ~~~\nfoo\n~~~")]
+        [TestCase("~~~ aa ``` ~~~\nfoo\n~~~ ")]
+        public void TestTilde(string value)
+        {
+            RoundTrip(value);
+        }
 
-    [TestCase("```\n c \n```\r\n")]
-    [TestCase("```\n c \r```\r\n")]
-    [TestCase("```\n c \r\n```\r\n")]
-    [TestCase("```\r c \n```\r\n")]
-    [TestCase("```\r c \r```\r\n")]
-    [TestCase("```\r c \r\n```\r\n")]
-    [TestCase("```\r\n c \n```\r\n")]
-    [TestCase("```\r\n c \r```\r\n")]
-    [TestCase("```\r\n c \r\n```\r\n")]
-    public void TestNewline(string value)
-    {
-        RoundTrip(value);
-    }
+        [TestCase("```\n c \n```")]
+        [TestCase("```\n c \r```")]
+        [TestCase("```\n c \r\n```")]
+        [TestCase("```\r c \n```")]
+        [TestCase("```\r c \r```")]
+        [TestCase("```\r c \r\n```")]
+        [TestCase("```\r\n c \n```")]
+        [TestCase("```\r\n c \r```")]
+        [TestCase("```\r\n c \r\n```")]
 
-    [TestCase("```i a\n```")]
-    [TestCase("```i a a2\n```")]
-    [TestCase("```i a a2 a3\n```")]
-    [TestCase("```i a a2 a3 a4\n```")]
+        [TestCase("```\n c \n```\n")]
+        [TestCase("```\n c \r```\n")]
+        [TestCase("```\n c \r\n```\n")]
+        [TestCase("```\r c \n```\n")]
+        [TestCase("```\r c \r```\n")]
+        [TestCase("```\r c \r\n```\n")]
+        [TestCase("```\r\n c \n```\n")]
+        [TestCase("```\r\n c \r```\n")]
+        [TestCase("```\r\n c \r\n```\n")]
 
-    [TestCase("```i\ta\n```")]
-    [TestCase("```i\ta a2\n```")]
-    [TestCase("```i\ta a2 a3\n```")]
-    [TestCase("```i\ta a2 a3 a4\n```")]
+        [TestCase("```\n c \n```\r")]
+        [TestCase("```\n c \r```\r")]
+        [TestCase("```\n c \r\n```\r")]
+        [TestCase("```\r c \n```\r")]
+        [TestCase("```\r c \r```\r")]
+        [TestCase("```\r c \r\n```\r")]
+        [TestCase("```\r\n c \n```\r")]
+        [TestCase("```\r\n c \r```\r")]
+        [TestCase("```\r\n c \r\n```\r")]
 
-    [TestCase("```i\ta \n```")]
-    [TestCase("```i\ta a2 \n```")]
-    [TestCase("```i\ta a2 a3 \n```")]
-    [TestCase("```i\ta a2 a3 a4 \n```")]
-    public void TestInfoArguments(string value)
-    {
-        RoundTrip(value);
+        [TestCase("```\n c \n```\r\n")]
+        [TestCase("```\n c \r```\r\n")]
+        [TestCase("```\n c \r\n```\r\n")]
+        [TestCase("```\r c \n```\r\n")]
+        [TestCase("```\r c \r```\r\n")]
+        [TestCase("```\r c \r\n```\r\n")]
+        [TestCase("```\r\n c \n```\r\n")]
+        [TestCase("```\r\n c \r```\r\n")]
+        [TestCase("```\r\n c \r\n```\r\n")]
+        public void TestNewline(string value)
+        {
+            RoundTrip(value);
+        }
+
+        [TestCase("```i a\n```")]
+        [TestCase("```i a a2\n```")]
+        [TestCase("```i a a2 a3\n```")]
+        [TestCase("```i a a2 a3 a4\n```")]
+
+        [TestCase("```i\ta\n```")]
+        [TestCase("```i\ta a2\n```")]
+        [TestCase("```i\ta a2 a3\n```")]
+        [TestCase("```i\ta a2 a3 a4\n```")]
+
+        [TestCase("```i\ta \n```")]
+        [TestCase("```i\ta a2 \n```")]
+        [TestCase("```i\ta a2 a3 \n```")]
+        [TestCase("```i\ta a2 a3 a4 \n```")]
+        public void TestInfoArguments(string value)
+        {
+            RoundTrip(value);
+        }
     }
 }

src/Markdig.Tests/RoundtripSpecs/TestHtmlBlock.cs

@@ -1,18 +1,20 @@
+using NUnit.Framework;
 using static Markdig.Tests.TestRoundtrip;
 
-namespace Markdig.Tests.RoundtripSpecs;
-
-[TestFixture]
-public class TestHtmlBlock
+namespace Markdig.Tests.RoundtripSpecs
 {
-    [TestCase("<br>")]
-    [TestCase("<br>\n")]
-    [TestCase("<br>\n\n")]
-    [TestCase("<div></div>\n\n# h")]
-    [TestCase("p\n\n<div></div>\n")]
-    [TestCase("<div></div>\n\n# h")]
-    public void Test(string value)
+    [TestFixture]
+    public class TestHtmlBlock
     {
-        RoundTrip(value);
+        [TestCase("<br>")]
+        [TestCase("<br>\n")]
+        [TestCase("<br>\n\n")]
+        [TestCase("<div></div>\n\n# h")]
+        [TestCase("p\n\n<div></div>\n")]
+        [TestCase("<div></div>\n\n# h")]
+        public void Test(string value)
+        {
+            RoundTrip(value);
+        }
     }
 }

src/Markdig.Tests/RoundtripSpecs/TestIndentedCodeBlock.cs

@@ -1,84 +1,86 @@
+using NUnit.Framework;
 using static Markdig.Tests.TestRoundtrip;
 
-namespace Markdig.Tests.RoundtripSpecs;
-
-[TestFixture]
-public class TestIndentedCodeBlock
+namespace Markdig.Tests.RoundtripSpecs
 {
-    // A codeblock is indented with 4 spaces. After the 4th space, whitespace is interpreted as content.
-    // l = line
-    [TestCase("    l")]
-    [TestCase("     l")]
-    [TestCase("\tl")]
-    [TestCase("\t\tl")]
-    [TestCase("\tl1\n    l1")]
-
-    [TestCase("\n    l")]
-    [TestCase("\n\n    l")]
-    [TestCase("\n    l\n")]
-    [TestCase("\n    l\n\n")]
-    [TestCase("\n\n    l\n")]
-    [TestCase("\n\n    l\n\n")]
-
-    [TestCase("    l\n    l")]
-    [TestCase("    l\n    l\n    l")]
-
-
-    // two newlines are needed for indented codeblock start after paragraph
-    [TestCase("p\n\n    l")]
-    [TestCase("p\n\n    l\n")]
-    [TestCase("p\n\n    l\n\n")]
-
-    [TestCase("p\n\n    l\n    l")]
-    [TestCase("p\n\n    l\n     l")]
-
-    [TestCase("    l\n\np\n\n    l")]
-    [TestCase("    l    l\n\np\n\n    l    l")]
-    public void Test(string value)
+    [TestFixture]
+    public class TestIndentedCodeBlock
     {
-        RoundTrip(value);
-    }
+        // A codeblock is indented with 4 spaces. After the 4th space, whitespace is interpreted as content.
+        // l = line
+        [TestCase("    l")]
+        [TestCase("     l")]
+        [TestCase("\tl")]
+        [TestCase("\t\tl")]
+        [TestCase("\tl1\n    l1")]
 
-    [TestCase("    l\n")]
-    [TestCase("    l\r")]
-    [TestCase("    l\r\n")]
+        [TestCase("\n    l")]
+        [TestCase("\n\n    l")]
+        [TestCase("\n    l\n")]
+        [TestCase("\n    l\n\n")]
+        [TestCase("\n\n    l\n")]
+        [TestCase("\n\n    l\n\n")]
 
-    [TestCase("    l\n    l")]
-    [TestCase("    l\n    l\n")]
-    [TestCase("    l\n    l\r")]
-    [TestCase("    l\n    l\r\n")]
+        [TestCase("    l\n    l")]
+        [TestCase("    l\n    l\n    l")]
 
-    [TestCase("    l\r    l")]
-    [TestCase("    l\r    l\n")]
-    [TestCase("    l\r    l\r")]
-    [TestCase("    l\r    l\r\n")]
 
-    [TestCase("    l\r\n    l")]
-    [TestCase("    l\r\n    l\n")]
-    [TestCase("    l\r\n    l\r")]
-    [TestCase("    l\r\n    l\r\n")]
-    public void TestNewline(string value)
-    {
-        RoundTrip(value);
-    }
+        // two newlines are needed for indented codeblock start after paragraph
+        [TestCase("p\n\n    l")]
+        [TestCase("p\n\n    l\n")]
+        [TestCase("p\n\n    l\n\n")]
 
-    [TestCase("    l\n\n    l\n")]
-    [TestCase("    l\n\n\n    l\n")]
-    public void TestNewlinesInBetweenResultInOneCodeBlock(string value)
-    {
-        var pipelineBuilder = new MarkdownPipelineBuilder();
-        pipelineBuilder.EnableTrackTrivia();
-        MarkdownPipeline pipeline = pipelineBuilder.Build();
-        var markdownDocument = Markdown.Parse(value, pipeline);
+        [TestCase("p\n\n    l\n    l")]
+        [TestCase("p\n\n    l\n     l")]
 
-        Assert.AreEqual(1, markdownDocument.Count);
-    }
+        [TestCase("    l\n\np\n\n    l")]
+        [TestCase("    l    l\n\np\n\n    l    l")]
+        public void Test(string value)
+        {
+            RoundTrip(value);
+        }
 
-    [TestCase("    l\n\np")]
-    [TestCase("    l\n\n\np")]
-    [TestCase("    l\n\n\n\np")]
-    public void TestParagraph(string value)
-    {
-        RoundTrip(value);
+        [TestCase("    l\n")]
+        [TestCase("    l\r")]
+        [TestCase("    l\r\n")]
+
+        [TestCase("    l\n    l")]
+        [TestCase("    l\n    l\n")]
+        [TestCase("    l\n    l\r")]
+        [TestCase("    l\n    l\r\n")]
+
+        [TestCase("    l\r    l")]
+        [TestCase("    l\r    l\n")]
+        [TestCase("    l\r    l\r")]
+        [TestCase("    l\r    l\r\n")]
+
+        [TestCase("    l\r\n    l")]
+        [TestCase("    l\r\n    l\n")]
+        [TestCase("    l\r\n    l\r")]
+        [TestCase("    l\r\n    l\r\n")]
+        public void TestNewline(string value)
+        {
+            RoundTrip(value);
+        }
+
+        [TestCase("    l\n\n    l\n")]
+        [TestCase("    l\n\n\n    l\n")]
+        public void TestNewlinesInBetweenResultInOneCodeBlock(string value)
+        {
+            var pipelineBuilder = new MarkdownPipelineBuilder();
+            pipelineBuilder.EnableTrackTrivia();
+            MarkdownPipeline pipeline = pipelineBuilder.Build();
+            var markdownDocument = Markdown.Parse(value, pipeline);
+
+            Assert.AreEqual(1, markdownDocument.Count);
+        }
+
+        [TestCase("    l\n\np")]
+        [TestCase("    l\n\n\np")]
+        [TestCase("    l\n\n\n\np")]
+        public void TestParagraph(string value)
+        {
+            RoundTrip(value);
+        }
     }
 }

src/Markdig.Tests/RoundtripSpecs/TestLinkReferenceDefinition.cs

@@ -1,212 +1,214 @@
+using NUnit.Framework;
 using static Markdig.Tests.TestRoundtrip;
 
-namespace Markdig.Tests.RoundtripSpecs;
-
-[TestFixture]
-public class TestLinkReferenceDefinition
+namespace Markdig.Tests.RoundtripSpecs
 {
-    [TestCase(@"[a]: /r")]
-    [TestCase(@" [a]: /r")]
-    [TestCase(@"  [a]: /r")]
-    [TestCase(@"   [a]: /r")]
-
-    [TestCase(@"[a]:  /r")]
-    [TestCase(@" [a]:  /r")]
-    [TestCase(@"  [a]:  /r")]
-    [TestCase(@"   [a]:  /r")]
-
-    [TestCase(@"[a]:  /r ")]
-    [TestCase(@" [a]:  /r ")]
-    [TestCase(@"  [a]:  /r ")]
-    [TestCase(@"   [a]:  /r ")]
-
-    [TestCase(@"[a]: /r ""l""")]
-    [TestCase(@"[a]:  /r ""l""")]
-    [TestCase(@"[a]: /r  ""l""")]
-    [TestCase(@"[a]: /r ""l"" ")]
-    [TestCase(@"[a]:  /r  ""l""")]
-    [TestCase(@"[a]:  /r  ""l"" ")]
-
-    [TestCase(@" [a]: /r ""l""")]
-    [TestCase(@" [a]:  /r ""l""")]
-    [TestCase(@" [a]: /r  ""l""")]
-    [TestCase(@" [a]: /r ""l"" ")]
-    [TestCase(@" [a]:  /r  ""l""")]
-    [TestCase(@" [a]:  /r  ""l"" ")]
-
-    [TestCase(@"  [a]: /r ""l""")]
-    [TestCase(@"  [a]:  /r ""l""")]
-    [TestCase(@"  [a]: /r  ""l""")]
-    [TestCase(@"  [a]: /r ""l"" ")]
-    [TestCase(@"  [a]:  /r  ""l""")]
-    [TestCase(@"  [a]:  /r  ""l"" ")]
-
-    [TestCase(@"   [a]: /r ""l""")]
-    [TestCase(@"   [a]:  /r ""l""")]
-    [TestCase(@"   [a]: /r  ""l""")]
-    [TestCase(@"   [a]: /r ""l"" ")]
-    [TestCase(@"   [a]:  /r  ""l""")]
-    [TestCase(@"   [a]:  /r  ""l"" ")]
-
-    [TestCase("[a]:\t/r")]
-    [TestCase("[a]:\t/r\t")]
-    [TestCase("[a]:\t/r\t\"l\"")]
-    [TestCase("[a]:\t/r\t\"l\"\t")]
-
-    [TestCase("[a]: \t/r")]
-    [TestCase("[a]: \t/r\t")]
-    [TestCase("[a]: \t/r\t\"l\"")]
-    [TestCase("[a]: \t/r\t\"l\"\t")]
-
-    [TestCase("[a]:\t /r")]
-    [TestCase("[a]:\t /r\t")]
-    [TestCase("[a]:\t /r\t\"l\"")]
-    [TestCase("[a]:\t /r\t\"l\"\t")]
-
-    [TestCase("[a]: \t /r")]
-    [TestCase("[a]: \t /r\t")]
-    [TestCase("[a]: \t /r\t\"l\"")]
-    [TestCase("[a]: \t /r\t\"l\"\t")]
-
-    [TestCase("[a]:\t/r \t")]
-    [TestCase("[a]:\t/r \t\"l\"")]
-    [TestCase("[a]:\t/r \t\"l\"\t")]
-
-    [TestCase("[a]: \t/r")]
-    [TestCase("[a]: \t/r \t")]
-    [TestCase("[a]: \t/r \t\"l\"")]
-    [TestCase("[a]: \t/r \t\"l\"\t")]
-
-    [TestCase("[a]:\t /r")]
-    [TestCase("[a]:\t /r \t")]
-    [TestCase("[a]:\t /r \t\"l\"")]
-    [TestCase("[a]:\t /r \t\"l\"\t")]
-
-    [TestCase("[a]: \t /r")]
-    [TestCase("[a]: \t /r \t")]
-    [TestCase("[a]: \t /r \t\"l\"")]
-    [TestCase("[a]: \t /r \t\"l\"\t")]
-
-    [TestCase("[a]:\t/r\t ")]
-    [TestCase("[a]:\t/r\t \"l\"")]
-    [TestCase("[a]:\t/r\t \"l\"\t")]
-
-    [TestCase("[a]: \t/r")]
-    [TestCase("[a]: \t/r\t ")]
-    [TestCase("[a]: \t/r\t \"l\"")]
-    [TestCase("[a]: \t/r\t \"l\"\t")]
-
-    [TestCase("[a]:\t /r")]
-    [TestCase("[a]:\t /r\t ")]
-    [TestCase("[a]:\t /r\t \"l\"")]
-    [TestCase("[a]:\t /r\t \"l\"\t")]
-
-    [TestCase("[a]: \t /r")]
-    [TestCase("[a]: \t /r\t ")]
-    [TestCase("[a]: \t /r\t \"l\"")]
-    [TestCase("[a]: \t /r\t \"l\"\t")]
-
-    [TestCase("[a]:\t/r \t ")]
-    [TestCase("[a]:\t/r \t \"l\"")]
-    [TestCase("[a]:\t/r \t \"l\"\t")]
-
-    [TestCase("[a]: \t/r")]
-    [TestCase("[a]: \t/r \t ")]
-    [TestCase("[a]: \t/r \t \"l\"")]
-    [TestCase("[a]: \t/r \t \"l\"\t")]
-
-    [TestCase("[a]:\t /r")]
-    [TestCase("[a]:\t /r \t ")]
-    [TestCase("[a]:\t /r \t \"l\"")]
-    [TestCase("[a]:\t /r \t \"l\"\t")]
-
-    [TestCase("[a]: \t /r")]
-    [TestCase("[a]: \t /r \t ")]
-    [TestCase("[a]: \t /r \t \"l\"")]
-    [TestCase("[a]: \t /r \t \"l\"\t")]
-    public void Test(string value)
+    [TestFixture]
+    public class TestLinkReferenceDefinition
     {
-        RoundTrip(value);
-    }
+        [TestCase(@"[a]: /r")]
+        [TestCase(@" [a]: /r")]
+        [TestCase(@"  [a]: /r")]
+        [TestCase(@"   [a]: /r")]
 
-    [TestCase("[a]: /r\n[b]: /r\n")]
-    [TestCase("[a]: /r\n[b]: /r\n[c] /r\n")]
-    public void TestMultiple(string value)
-    {
-        RoundTrip(value);
-    }
+        [TestCase(@"[a]:  /r")]
+        [TestCase(@" [a]:  /r")]
+        [TestCase(@"  [a]:  /r")]
+        [TestCase(@"   [a]:  /r")]
 
-    [TestCase("[a]:\f/r\f\"l\"")]
-    [TestCase("[a]:\v/r\v\"l\"")]
-    public void TestUncommonWhitespace(string value)
-    {
-        RoundTrip(value);
-    }
+        [TestCase(@"[a]:  /r ")]
+        [TestCase(@" [a]:  /r ")]
+        [TestCase(@"  [a]:  /r ")]
+        [TestCase(@"   [a]:  /r ")]
 
-    [TestCase("[a]:\n/r\n\"t\"")]
-    [TestCase("[a]:\n/r\r\"t\"")]
-    [TestCase("[a]:\n/r\r\n\"t\"")]
+        [TestCase(@"[a]: /r ""l""")]
+        [TestCase(@"[a]:  /r ""l""")]
+        [TestCase(@"[a]: /r  ""l""")]
+        [TestCase(@"[a]: /r ""l"" ")]
+        [TestCase(@"[a]:  /r  ""l""")]
+        [TestCase(@"[a]:  /r  ""l"" ")]
 
-    [TestCase("[a]:\r/r\n\"t\"")]
-    [TestCase("[a]:\r/r\r\"t\"")]
-    [TestCase("[a]:\r/r\r\n\"t\"")]
+        [TestCase(@" [a]: /r ""l""")]
+        [TestCase(@" [a]:  /r ""l""")]
+        [TestCase(@" [a]: /r  ""l""")]
+        [TestCase(@" [a]: /r ""l"" ")]
+        [TestCase(@" [a]:  /r  ""l""")]
+        [TestCase(@" [a]:  /r  ""l"" ")]
 
-    [TestCase("[a]:\r\n/r\n\"t\"")]
-    [TestCase("[a]:\r\n/r\r\"t\"")]
-    [TestCase("[a]:\r\n/r\r\n\"t\"")]
+        [TestCase(@"  [a]: /r ""l""")]
+        [TestCase(@"  [a]:  /r ""l""")]
+        [TestCase(@"  [a]: /r  ""l""")]
+        [TestCase(@"  [a]: /r ""l"" ")]
+        [TestCase(@"  [a]:  /r  ""l""")]
+        [TestCase(@"  [a]:  /r  ""l"" ")]
 
-    [TestCase("[a]:\n/r\n\"t\nt\"")]
-    [TestCase("[a]:\n/r\n\"t\rt\"")]
-    [TestCase("[a]:\n/r\n\"t\r\nt\"")]
+        [TestCase(@"   [a]: /r ""l""")]
+        [TestCase(@"   [a]:  /r ""l""")]
+        [TestCase(@"   [a]: /r  ""l""")]
+        [TestCase(@"   [a]: /r ""l"" ")]
+        [TestCase(@"   [a]:  /r  ""l""")]
+        [TestCase(@"   [a]:  /r  ""l"" ")]
 
-    [TestCase("[a]:\r\n  /r\t \n \t \"t\r\nt\"   ")]
-    [TestCase("[a]:\n/r\n\n[a],")]
-    [TestCase("[a]: /r\n[b]: /r\n\n[a],")]
-    public void TestNewlines(string value)
-    {
-        RoundTrip(value);
-    }
+        [TestCase("[a]:\t/r")]
+        [TestCase("[a]:\t/r\t")]
+        [TestCase("[a]:\t/r\t\"l\"")]
+        [TestCase("[a]:\t/r\t\"l\"\t")]
 
-    [TestCase("[ a]: /r")]
-    [TestCase("[a ]: /r")]
-    [TestCase("[ a ]: /r")]
-    [TestCase("[  a]: /r")]
-    [TestCase("[  a ]: /r")]
-    [TestCase("[a  ]: /r")]
-    [TestCase("[ a  ]: /r")]
-    [TestCase("[  a  ]: /r")]
-    [TestCase("[a a]: /r")]
-    [TestCase("[a\va]: /r")]
-    [TestCase("[a\fa]: /r")]
-    [TestCase("[a\ta]: /r")]
-    [TestCase("[\va]: /r")]
-    [TestCase("[\fa]: /r")]
-    [TestCase("[\ta]: /r")]
-    [TestCase(@"[\]]: /r")]
-    public void TestLabel(string value)
-    {
-        RoundTrip(value);
-    }
+        [TestCase("[a]: \t/r")]
+        [TestCase("[a]: \t/r\t")]
+        [TestCase("[a]: \t/r\t\"l\"")]
+        [TestCase("[a]: \t/r\t\"l\"\t")]
 
-    [TestCase("[a]: /r ()")]
-    [TestCase("[a]: /r (t)")]
-    [TestCase("[a]: /r ( t)")]
-    [TestCase("[a]: /r (t )")]
-    [TestCase("[a]: /r ( t )")]
+        [TestCase("[a]:\t /r")]
+        [TestCase("[a]:\t /r\t")]
+        [TestCase("[a]:\t /r\t\"l\"")]
+        [TestCase("[a]:\t /r\t\"l\"\t")]
 
-    [TestCase("[a]: /r ''")]
-    [TestCase("[a]: /r 't'")]
-    [TestCase("[a]: /r ' t'")]
-    [TestCase("[a]: /r 't '")]
-    [TestCase("[a]: /r ' t '")]
-    public void Test_Title(string value)
-    {
-        RoundTrip(value);
-    }
+        [TestCase("[a]: \t /r")]
+        [TestCase("[a]: \t /r\t")]
+        [TestCase("[a]: \t /r\t\"l\"")]
+        [TestCase("[a]: \t /r\t\"l\"\t")]
 
-    [TestCase("[a]: /r\n===\n[a]")]
-    public void TestSetextHeader(string value)
-    {
-        RoundTrip(value);
+        [TestCase("[a]:\t/r \t")]
+        [TestCase("[a]:\t/r \t\"l\"")]
+        [TestCase("[a]:\t/r \t\"l\"\t")]
+
+        [TestCase("[a]: \t/r")]
+        [TestCase("[a]: \t/r \t")]
+        [TestCase("[a]: \t/r \t\"l\"")]
+        [TestCase("[a]: \t/r \t\"l\"\t")]
+
+        [TestCase("[a]:\t /r")]
+        [TestCase("[a]:\t /r \t")]
+        [TestCase("[a]:\t /r \t\"l\"")]
+        [TestCase("[a]:\t /r \t\"l\"\t")]
+
+        [TestCase("[a]: \t /r")]
+        [TestCase("[a]: \t /r \t")]
+        [TestCase("[a]: \t /r \t\"l\"")]
+        [TestCase("[a]: \t /r \t\"l\"\t")]
+
+        [TestCase("[a]:\t/r\t ")]
+        [TestCase("[a]:\t/r\t \"l\"")]
+        [TestCase("[a]:\t/r\t \"l\"\t")]
+
+        [TestCase("[a]: \t/r")]
+        [TestCase("[a]: \t/r\t ")]
+        [TestCase("[a]: \t/r\t \"l\"")]
+        [TestCase("[a]: \t/r\t \"l\"\t")]
+
+        [TestCase("[a]:\t /r")]
+        [TestCase("[a]:\t /r\t ")]
+        [TestCase("[a]:\t /r\t \"l\"")]
+        [TestCase("[a]:\t /r\t \"l\"\t")]
+
+        [TestCase("[a]: \t /r")]
+        [TestCase("[a]: \t /r\t ")]
+        [TestCase("[a]: \t /r\t \"l\"")]
+        [TestCase("[a]: \t /r\t \"l\"\t")]
+
+        [TestCase("[a]:\t/r \t ")]
+        [TestCase("[a]:\t/r \t \"l\"")]
+        [TestCase("[a]:\t/r \t \"l\"\t")]
+
+        [TestCase("[a]: \t/r")]
+        [TestCase("[a]: \t/r \t ")]
+        [TestCase("[a]: \t/r \t \"l\"")]
+        [TestCase("[a]: \t/r \t \"l\"\t")]
+
+        [TestCase("[a]:\t /r")]
+        [TestCase("[a]:\t /r \t ")]
+        [TestCase("[a]:\t /r \t \"l\"")]
+        [TestCase("[a]:\t /r \t \"l\"\t")]
+
+        [TestCase("[a]: \t /r")]
+        [TestCase("[a]: \t /r \t ")]
+        [TestCase("[a]: \t /r \t \"l\"")]
+        [TestCase("[a]: \t /r \t \"l\"\t")]
+        public void Test(string value)
+        {
+            RoundTrip(value);
+        }
+
+        [TestCase("[a]: /r\n[b]: /r\n")]
+        [TestCase("[a]: /r\n[b]: /r\n[c] /r\n")]
+        public void TestMultiple(string value)
+        {
+            RoundTrip(value);
+        }
+
+        [TestCase("[a]:\f/r\f\"l\"")]
+        [TestCase("[a]:\v/r\v\"l\"")]
+        public void TestUncommonWhitespace(string value)
+        {
+            RoundTrip(value);
+        }
+
+        [TestCase("[a]:\n/r\n\"t\"")]
+        [TestCase("[a]:\n/r\r\"t\"")]
+        [TestCase("[a]:\n/r\r\n\"t\"")]
+
+        [TestCase("[a]:\r/r\n\"t\"")]
+        [TestCase("[a]:\r/r\r\"t\"")]
+        [TestCase("[a]:\r/r\r\n\"t\"")]
+
+        [TestCase("[a]:\r\n/r\n\"t\"")]
+        [TestCase("[a]:\r\n/r\r\"t\"")]
+        [TestCase("[a]:\r\n/r\r\n\"t\"")]
+
+        [TestCase("[a]:\n/r\n\"t\nt\"")]
+        [TestCase("[a]:\n/r\n\"t\rt\"")]
+        [TestCase("[a]:\n/r\n\"t\r\nt\"")]
+
+        [TestCase("[a]:\r\n  /r\t \n \t \"t\r\nt\"   ")]
+        [TestCase("[a]:\n/r\n\n[a],")]
+        [TestCase("[a]: /r\n[b]: /r\n\n[a],")]
+        public void TestNewlines(string value)
+        {
+            RoundTrip(value);
+        }
+
+        [TestCase("[ a]: /r")]
+        [TestCase("[a ]: /r")]
+        [TestCase("[ a ]: /r")]
+        [TestCase("[  a]: /r")]
+        [TestCase("[  a ]: /r")]
+        [TestCase("[a  ]: /r")]
+        [TestCase("[ a  ]: /r")]
+        [TestCase("[  a  ]: /r")]
+        [TestCase("[a a]: /r")]
+        [TestCase("[a\va]: /r")]
+        [TestCase("[a\fa]: /r")]
+        [TestCase("[a\ta]: /r")]
+        [TestCase("[\va]: /r")]
+        [TestCase("[\fa]: /r")]
+        [TestCase("[\ta]: /r")]
+        [TestCase(@"[\]]: /r")]
+        public void TestLabel(string value)
+        {
+            RoundTrip(value);
+        }
+
+        [TestCase("[a]: /r ()")]
+        [TestCase("[a]: /r (t)")]
+        [TestCase("[a]: /r ( t)")]
+        [TestCase("[a]: /r (t )")]
+        [TestCase("[a]: /r ( t )")]
+
+        [TestCase("[a]: /r ''")]
+        [TestCase("[a]: /r 't'")]
+        [TestCase("[a]: /r ' t'")]
+        [TestCase("[a]: /r 't '")]
+        [TestCase("[a]: /r ' t '")]
+        public void Test_Title(string value)
+        {
+            RoundTrip(value);
+        }
+
+        [TestCase("[a]: /r\n===\n[a]")]
+        public void TestSetextHeader(string value)
+        {
+            RoundTrip(value);
+        }
     }
 }

src/Markdig.Tests/RoundtripSpecs/TestNoBlocksFoundBlock.cs

@@ -1,21 +1,23 @@
+using NUnit.Framework;
 using static Markdig.Tests.TestRoundtrip;
 
-namespace Markdig.Tests.RoundtripSpecs;
-
-[TestFixture]
-public class TestNoBlocksFoundBlock
+namespace Markdig.Tests.RoundtripSpecs
 {
-    [TestCase("\r")]
-    [TestCase("\n")]
-    [TestCase("\r\n")]
-    [TestCase("\t")]
-    [TestCase("\v")]
-    [TestCase("\f")]
-    [TestCase(" ")]
-    [TestCase("  ")]
-    [TestCase("   ")]
-    public void Test(string value)
+    [TestFixture]
+    public class TestNoBlocksFoundBlock
     {
-        RoundTrip(value);
+        [TestCase("\r")]
+        [TestCase("\n")]
+        [TestCase("\r\n")]
+        [TestCase("\t")]
+        [TestCase("\v")]
+        [TestCase("\f")]
+        [TestCase(" ")]
+        [TestCase("  ")]
+        [TestCase("   ")]
+        public void Test(string value)
+        {
+            RoundTrip(value);
+        }
     }
 }

src/Markdig.Tests/RoundtripSpecs/TestOrderedList.cs

@@ -1,189 +1,191 @@
+using NUnit.Framework;
 using static Markdig.Tests.TestRoundtrip;
 
-namespace Markdig.Tests.RoundtripSpecs;
-
-[TestFixture]
-public class TestOrderedList
+namespace Markdig.Tests.RoundtripSpecs
 {
-    [TestCase("1. i")]
-    [TestCase("1.  i")]
-    [TestCase("1. i ")]
-    [TestCase("1.  i ")]
-    [TestCase("1.  i  ")]
-
-    [TestCase(" 1. i")]
-    [TestCase(" 1.  i")]
-    [TestCase(" 1. i ")]
-    [TestCase(" 1.  i ")]
-    [TestCase(" 1.  i  ")]
-
-    [TestCase("  1. i")]
-    [TestCase("  1.  i")]
-    [TestCase("  1. i ")]
-    [TestCase("  1.  i ")]
-    [TestCase("  1.  i  ")]
-
-    [TestCase("   1. i")]
-    [TestCase("   1.  i")]
-    [TestCase("   1. i ")]
-    [TestCase("   1.  i ")]
-    [TestCase("   1.  i  ")]
-
-    [TestCase("1. i\n")]
-    [TestCase("1.  i\n")]
-    [TestCase("1. i \n")]
-    [TestCase("1.  i \n")]
-    [TestCase("1.  i  \n")]
-
-    [TestCase(" 1. i\n")]
-    [TestCase(" 1.  i\n")]
-    [TestCase(" 1. i \n")]
-    [TestCase(" 1.  i \n")]
-    [TestCase(" 1.  i  \n")]
-
-    [TestCase("  1. i\n")]
-    [TestCase("  1.  i\n")]
-    [TestCase("  1. i \n")]
-    [TestCase("  1.  i \n")]
-    [TestCase("  1.  i  \n")]
-
-    [TestCase("   1. i\n")]
-    [TestCase("   1.  i\n")]
-    [TestCase("   1. i \n")]
-    [TestCase("   1.  i \n")]
-    [TestCase("   1.  i  \n")]
-
-    [TestCase("1. i\n2. j")]
-    [TestCase("1.  i\n2. j")]
-    [TestCase("1. i \n2. j")]
-    [TestCase("1.  i \n2. j")]
-    [TestCase("1.  i  \n2. j")]
-
-    [TestCase(" 1. i\n2. j")]
-    [TestCase(" 1.  i\n2. j")]
-    [TestCase(" 1. i \n2. j")]
-    [TestCase(" 1.  i \n2. j")]
-    [TestCase(" 1.  i  \n2. j")]
-
-    [TestCase("  1. i\n2. j")]
-    [TestCase("  1.  i\n2. j")]
-    [TestCase("  1. i \n2. j")]
-    [TestCase("  1.  i \n2. j")]
-    [TestCase("  1.  i  \n2. j")]
-
-    [TestCase("   1. i\n2. j")]
-    [TestCase("   1.  i\n2. j")]
-    [TestCase("   1. i \n2. j")]
-    [TestCase("   1.  i \n2. j")]
-    [TestCase("   1.  i  \n2. j")]
-
-    [TestCase("1. i\n2. j\n")]
-    [TestCase("1.  i\n2. j\n")]
-    [TestCase("1. i \n2. j\n")]
-    [TestCase("1.  i \n2. j\n")]
-    [TestCase("1.  i  \n2. j\n")]
-
-    [TestCase(" 1. i\n2. j\n")]
-    [TestCase(" 1.  i\n2. j\n")]
-    [TestCase(" 1. i \n2. j\n")]
-    [TestCase(" 1.  i \n2. j\n")]
-    [TestCase(" 1.  i  \n2. j\n")]
-
-    [TestCase("  1. i\n2. j\n")]
-    [TestCase("  1.  i\n2. j\n")]
-    [TestCase("  1. i \n2. j\n")]
-    [TestCase("  1.  i \n2. j\n")]
-    [TestCase("  1.  i  \n2. j\n")]
-
-    [TestCase("   1. i\n2. j\n")]
-    [TestCase("   1.  i\n2. j\n")]
-    [TestCase("   1. i \n2. j\n")]
-    [TestCase("   1.  i \n2. j\n")]
-    [TestCase("   1.  i  \n2. j\n")]
-
-    [TestCase("1. i\n2. j\n3. k")]
-    [TestCase("1. i\n2. j\n3. k\n")]
-    public void Test(string value)
+    [TestFixture]
+    public class TestOrderedList
     {
-        RoundTrip(value);
-    }
+        [TestCase("1. i")]
+        [TestCase("1.  i")]
+        [TestCase("1. i ")]
+        [TestCase("1.  i ")]
+        [TestCase("1.  i  ")]
 
-    [TestCase("10. i")]
-    [TestCase("11. i")]
-    [TestCase("10. i\n12. i")]
-    [TestCase("2. i\n3. i")]
-    public void Test_MoreThenOneStart(string value)
-    {
-        RoundTrip(value);
-    }
+        [TestCase(" 1. i")]
+        [TestCase(" 1.  i")]
+        [TestCase(" 1. i ")]
+        [TestCase(" 1.  i ")]
+        [TestCase(" 1.  i  ")]
+
+        [TestCase("  1. i")]
+        [TestCase("  1.  i")]
+        [TestCase("  1. i ")]
+        [TestCase("  1.  i ")]
+        [TestCase("  1.  i  ")]
+
+        [TestCase("   1. i")]
+        [TestCase("   1.  i")]
+        [TestCase("   1. i ")]
+        [TestCase("   1.  i ")]
+        [TestCase("   1.  i  ")]
+
+        [TestCase("1. i\n")]
+        [TestCase("1.  i\n")]
+        [TestCase("1. i \n")]
+        [TestCase("1.  i \n")]
+        [TestCase("1.  i  \n")]
+
+        [TestCase(" 1. i\n")]
+        [TestCase(" 1.  i\n")]
+        [TestCase(" 1. i \n")]
+        [TestCase(" 1.  i \n")]
+        [TestCase(" 1.  i  \n")]
+
+        [TestCase("  1. i\n")]
+        [TestCase("  1.  i\n")]
+        [TestCase("  1. i \n")]
+        [TestCase("  1.  i \n")]
+        [TestCase("  1.  i  \n")]
+
+        [TestCase("   1. i\n")]
+        [TestCase("   1.  i\n")]
+        [TestCase("   1. i \n")]
+        [TestCase("   1.  i \n")]
+        [TestCase("   1.  i  \n")]
+
+        [TestCase("1. i\n2. j")]
+        [TestCase("1.  i\n2. j")]
+        [TestCase("1. i \n2. j")]
+        [TestCase("1.  i \n2. j")]
+        [TestCase("1.  i  \n2. j")]
+
+        [TestCase(" 1. i\n2. j")]
+        [TestCase(" 1.  i\n2. j")]
+        [TestCase(" 1. i \n2. j")]
+        [TestCase(" 1.  i \n2. j")]
+        [TestCase(" 1.  i  \n2. j")]
+
+        [TestCase("  1. i\n2. j")]
+        [TestCase("  1.  i\n2. j")]
+        [TestCase("  1. i \n2. j")]
+        [TestCase("  1.  i \n2. j")]
+        [TestCase("  1.  i  \n2. j")]
+
+        [TestCase("   1. i\n2. j")]
+        [TestCase("   1.  i\n2. j")]
+        [TestCase("   1. i \n2. j")]
+        [TestCase("   1.  i \n2. j")]
+        [TestCase("   1.  i  \n2. j")]
+
+        [TestCase("1. i\n2. j\n")]
+        [TestCase("1.  i\n2. j\n")]
+        [TestCase("1. i \n2. j\n")]
+        [TestCase("1.  i \n2. j\n")]
+        [TestCase("1.  i  \n2. j\n")]
+
+        [TestCase(" 1. i\n2. j\n")]
+        [TestCase(" 1.  i\n2. j\n")]
+        [TestCase(" 1. i \n2. j\n")]
+        [TestCase(" 1.  i \n2. j\n")]
+        [TestCase(" 1.  i  \n2. j\n")]
+
+        [TestCase("  1. i\n2. j\n")]
+        [TestCase("  1.  i\n2. j\n")]
+        [TestCase("  1. i \n2. j\n")]
+        [TestCase("  1.  i \n2. j\n")]
+        [TestCase("  1.  i  \n2. j\n")]
+
+        [TestCase("   1. i\n2. j\n")]
+        [TestCase("   1.  i\n2. j\n")]
+        [TestCase("   1. i \n2. j\n")]
+        [TestCase("   1.  i \n2. j\n")]
+        [TestCase("   1.  i  \n2. j\n")]
+
+        [TestCase("1. i\n2. j\n3. k")]
+        [TestCase("1. i\n2. j\n3. k\n")]
+        public void Test(string value)
+        {
+            RoundTrip(value);
+        }
+
+        [TestCase("10. i")]
+        [TestCase("11. i")]
+        [TestCase("10. i\n12. i")]
+        [TestCase("2. i\n3. i")]
+        public void Test_MoreThenOneStart(string value)
+        {
+            RoundTrip(value);
+        }
 
 
-    [TestCase("\n1. i")]
-    [TestCase("\r1. i")]
-    [TestCase("\r\n1. i")]
+        [TestCase("\n1. i")]
+        [TestCase("\r1. i")]
+        [TestCase("\r\n1. i")]
 
-    [TestCase("\n1. i\n")]
-    [TestCase("\r1. i\n")]
-    [TestCase("\r\n1. i\n")]
+        [TestCase("\n1. i\n")]
+        [TestCase("\r1. i\n")]
+        [TestCase("\r\n1. i\n")]
 
-    [TestCase("\n1. i\r")]
-    [TestCase("\r1. i\r")]
-    [TestCase("\r\n1. i\r")]
+        [TestCase("\n1. i\r")]
+        [TestCase("\r1. i\r")]
+        [TestCase("\r\n1. i\r")]
 
-    [TestCase("\n1. i\r\n")]
-    [TestCase("\r1. i\r\n")]
-    [TestCase("\r\n1. i\r\n")]
+        [TestCase("\n1. i\r\n")]
+        [TestCase("\r1. i\r\n")]
+        [TestCase("\r\n1. i\r\n")]
 
-    [TestCase("1. i\n2. i")]
-    [TestCase("\n1. i\n2. i")]
-    [TestCase("\r1. i\n2. i")]
-    [TestCase("\r\n1. i\n2. i")]
+        [TestCase("1. i\n2. i")]
+        [TestCase("\n1. i\n2. i")]
+        [TestCase("\r1. i\n2. i")]
+        [TestCase("\r\n1. i\n2. i")]
 
-    [TestCase("1. i\r2. i")]
-    [TestCase("\n1. i\r2. i")]
-    [TestCase("\r1. i\r2. i")]
-    [TestCase("\r\n1. i\r2. i")]
+        [TestCase("1. i\r2. i")]
+        [TestCase("\n1. i\r2. i")]
+        [TestCase("\r1. i\r2. i")]
+        [TestCase("\r\n1. i\r2. i")]
 
-    [TestCase("1. i\r\n2. i")]
-    [TestCase("\n1. i\r\n2. i")]
-    [TestCase("\r1. i\r\n2. i")]
-    [TestCase("\r\n1. i\r\n2. i")]
+        [TestCase("1. i\r\n2. i")]
+        [TestCase("\n1. i\r\n2. i")]
+        [TestCase("\r1. i\r\n2. i")]
+        [TestCase("\r\n1. i\r\n2. i")]
 
-    [TestCase("1. i\n2. i\n")]
-    [TestCase("\n1. i\n2. i\n")]
-    [TestCase("\r1. i\n2. i\n")]
-    [TestCase("\r\n1. i\n2. i\n")]
+        [TestCase("1. i\n2. i\n")]
+        [TestCase("\n1. i\n2. i\n")]
+        [TestCase("\r1. i\n2. i\n")]
+        [TestCase("\r\n1. i\n2. i\n")]
 
-    [TestCase("1. i\r2. i\r")]
-    [TestCase("\n1. i\r2. i\r")]
-    [TestCase("\r1. i\r2. i\r")]
-    [TestCase("\r\n1. i\r2. i\r")]
+        [TestCase("1. i\r2. i\r")]
+        [TestCase("\n1. i\r2. i\r")]
+        [TestCase("\r1. i\r2. i\r")]
+        [TestCase("\r\n1. i\r2. i\r")]
 
-    [TestCase("1. i\r\n2. i\r\n")]
-    [TestCase("\n1. i\r\n2. i\r\n")]
-    [TestCase("\r1. i\r\n2. i\r\n")]
-    [TestCase("\r\n1. i\r\n2. i\r\n")]
-    public void TestNewline(string value)
-    {
-        RoundTrip(value);
-    }
+        [TestCase("1. i\r\n2. i\r\n")]
+        [TestCase("\n1. i\r\n2. i\r\n")]
+        [TestCase("\r1. i\r\n2. i\r\n")]
+        [TestCase("\r\n1. i\r\n2. i\r\n")]
+        public void TestNewline(string value)
+        {
+            RoundTrip(value);
+        }
 
-    [TestCase("1. i\n  1. i")]
-    [TestCase("1. i\n  1. i\n")]
-    [TestCase("1. i\n  1. i\n  2. i")]
-    [TestCase("1. i\n  2. i\n  3. i")]
+        [TestCase("1. i\n  1. i")]
+        [TestCase("1. i\n  1. i\n")]
+        [TestCase("1. i\n  1. i\n  2. i")]
+        [TestCase("1. i\n  2. i\n  3. i")]
 
-    [TestCase("1. i\n\t1. i")]
-    [TestCase("1. i\n\t1. i\n2. i")]
-    public void TestMultipleLevels(string value)
-    {
-        RoundTrip(value);
-    }
+        [TestCase("1. i\n\t1. i")]
+        [TestCase("1. i\n\t1. i\n2. i")]
+        public void TestMultipleLevels(string value)
+        {
+            RoundTrip(value);
+        }
 
-    [TestCase("1.     c")]
-    [TestCase("1.      c")]
-    public void Test_IndentedCodeBlock(string value)
-    {
-        RoundTrip(value);
+        [TestCase("1.     c")]
+        [TestCase("1.      c")]
+        public void Test_IndentedCodeBlock(string value)
+        {
+            RoundTrip(value);
+        }
     }
 }

src/Markdig.Tests/RoundtripSpecs/TestParagraph.cs

@@ -1,245 +1,247 @@
+using NUnit.Framework;
 using static Markdig.Tests.TestRoundtrip;
 
-namespace Markdig.Tests.RoundtripSpecs;
-
-[TestFixture]
-public class TestParagraph
+namespace Markdig.Tests.RoundtripSpecs
 {
-    [TestCase("p")]
-    [TestCase(" p")]
-    [TestCase("p ")]
-    [TestCase(" p ")]
-
-    [TestCase("p\np")]
-    [TestCase(" p\np")]
-    [TestCase("p \np")]
-    [TestCase(" p \np")]
-
-    [TestCase("p\n p")]
-    [TestCase(" p\n p")]
-    [TestCase("p \n p")]
-    [TestCase(" p \n p")]
-
-    [TestCase("p\np ")]
-    [TestCase(" p\np ")]
-    [TestCase("p \np ")]
-    [TestCase(" p \np ")]
-
-    [TestCase("p\n\n p ")]
-    [TestCase(" p\n\n p ")]
-    [TestCase("p \n\n p ")]
-    [TestCase(" p \n\n p ")]
-
-    [TestCase("p\n\np")]
-    [TestCase(" p\n\np")]
-    [TestCase("p \n\np")]
-    [TestCase(" p \n\np")]
-
-    [TestCase("p\n\n p")]
-    [TestCase(" p\n\n p")]
-    [TestCase("p \n\n p")]
-    [TestCase(" p \n\n p")]
-
-    [TestCase("p\n\np ")]
-    [TestCase(" p\n\np ")]
-    [TestCase("p \n\np ")]
-    [TestCase(" p \n\np ")]
-
-    [TestCase("p\n\n p ")]
-    [TestCase(" p\n\n p ")]
-    [TestCase("p \n\n p ")]
-    [TestCase(" p \n\n p ")]
-
-    [TestCase("\np")]
-    [TestCase("\n p")]
-    [TestCase("\np ")]
-    [TestCase("\n p ")]
-
-    [TestCase("\np\np")]
-    [TestCase("\n p\np")]
-    [TestCase("\np \np")]
-    [TestCase("\n p \np")]
-
-    [TestCase("\np\n p")]
-    [TestCase("\n p\n p")]
-    [TestCase("\np \n p")]
-    [TestCase("\n p \n p")]
-
-    [TestCase("\np\np ")]
-    [TestCase("\n p\np ")]
-    [TestCase("\np \np ")]
-    [TestCase("\n p \np ")]
-
-    [TestCase("\np\n\n p ")]
-    [TestCase("\n p\n\n p ")]
-    [TestCase("\np \n\n p ")]
-    [TestCase("\n p \n\n p ")]
-
-    [TestCase("\np\n\np")]
-    [TestCase("\n p\n\np")]
-    [TestCase("\np \n\np")]
-    [TestCase("\n p \n\np")]
-
-    [TestCase("\np\n\n p")]
-    [TestCase("\n p\n\n p")]
-    [TestCase("\np \n\n p")]
-    [TestCase("\n p \n\n p")]
-
-    [TestCase("\np\n\np ")]
-    [TestCase("\n p\n\np ")]
-    [TestCase("\np \n\np ")]
-    [TestCase("\n p \n\np ")]
-
-    [TestCase("\np\n\n p ")]
-    [TestCase("\n p\n\n p ")]
-    [TestCase("\np \n\n p ")]
-    [TestCase("\n p \n\n p ")]
-
-    [TestCase("p  p")]
-    [TestCase("p\tp")]
-    [TestCase("p \tp")]
-    [TestCase("p \t p")]
-    [TestCase("p \tp")]
-
-    // special cases
-    [TestCase(" p \n\n\n\n p \n\n")]
-    [TestCase("\n\np")]
-    [TestCase("p\n")]
-    [TestCase("p\n\n")]
-    [TestCase("p\np\n p")]
-    [TestCase("p\np\n p\n p")]
-    public void Test(string value)
+    [TestFixture]
+    public class TestParagraph
     {
-        RoundTrip(value);
-    }
+        [TestCase("p")]
+        [TestCase(" p")]
+        [TestCase("p ")]
+        [TestCase(" p ")]
+
+        [TestCase("p\np")]
+        [TestCase(" p\np")]
+        [TestCase("p \np")]
+        [TestCase(" p \np")]
+
+        [TestCase("p\n p")]
+        [TestCase(" p\n p")]
+        [TestCase("p \n p")]
+        [TestCase(" p \n p")]
+
+        [TestCase("p\np ")]
+        [TestCase(" p\np ")]
+        [TestCase("p \np ")]
+        [TestCase(" p \np ")]
+
+        [TestCase("p\n\n p ")]
+        [TestCase(" p\n\n p ")]
+        [TestCase("p \n\n p ")]
+        [TestCase(" p \n\n p ")]
+
+        [TestCase("p\n\np")]
+        [TestCase(" p\n\np")]
+        [TestCase("p \n\np")]
+        [TestCase(" p \n\np")]
+
+        [TestCase("p\n\n p")]
+        [TestCase(" p\n\n p")]
+        [TestCase("p \n\n p")]
+        [TestCase(" p \n\n p")]
+
+        [TestCase("p\n\np ")]
+        [TestCase(" p\n\np ")]
+        [TestCase("p \n\np ")]
+        [TestCase(" p \n\np ")]
+
+        [TestCase("p\n\n p ")]
+        [TestCase(" p\n\n p ")]
+        [TestCase("p \n\n p ")]
+        [TestCase(" p \n\n p ")]
+
+        [TestCase("\np")]
+        [TestCase("\n p")]
+        [TestCase("\np ")]
+        [TestCase("\n p ")]
+
+        [TestCase("\np\np")]
+        [TestCase("\n p\np")]
+        [TestCase("\np \np")]
+        [TestCase("\n p \np")]
+
+        [TestCase("\np\n p")]
+        [TestCase("\n p\n p")]
+        [TestCase("\np \n p")]
+        [TestCase("\n p \n p")]
+
+        [TestCase("\np\np ")]
+        [TestCase("\n p\np ")]
+        [TestCase("\np \np ")]
+        [TestCase("\n p \np ")]
+
+        [TestCase("\np\n\n p ")]
+        [TestCase("\n p\n\n p ")]
+        [TestCase("\np \n\n p ")]
+        [TestCase("\n p \n\n p ")]
+
+        [TestCase("\np\n\np")]
+        [TestCase("\n p\n\np")]
+        [TestCase("\np \n\np")]
+        [TestCase("\n p \n\np")]
+
+        [TestCase("\np\n\n p")]
+        [TestCase("\n p\n\n p")]
+        [TestCase("\np \n\n p")]
+        [TestCase("\n p \n\n p")]
+
+        [TestCase("\np\n\np ")]
+        [TestCase("\n p\n\np ")]
+        [TestCase("\np \n\np ")]
+        [TestCase("\n p \n\np ")]
+
+        [TestCase("\np\n\n p ")]
+        [TestCase("\n p\n\n p ")]
+        [TestCase("\np \n\n p ")]
+        [TestCase("\n p \n\n p ")]
+
+        [TestCase("p  p")]
+        [TestCase("p\tp")]
+        [TestCase("p \tp")]
+        [TestCase("p \t p")]
+        [TestCase("p \tp")]
+
+        // special cases
+        [TestCase(" p \n\n\n\n p \n\n")]
+        [TestCase("\n\np")]
+        [TestCase("p\n")]
+        [TestCase("p\n\n")]
+        [TestCase("p\np\n p")]
+        [TestCase("p\np\n p\n p")]
+        public void Test(string value)
+        {
+            RoundTrip(value);
+        }
 
 
-    [TestCase("\n")]
-    [TestCase("\r\n")]
-    [TestCase("\r")]
+        //[TestCase("\n")]
+        //[TestCase("\r\n")]
+        //[TestCase("\r")]
 
-    [TestCase("p\n")]
-    [TestCase("p\r")]
-    [TestCase("p\r\n")]
+        [TestCase("p\n")]
+        [TestCase("p\r")]
+        [TestCase("p\r\n")]
 
-    [TestCase("p\np")]
-    [TestCase("p\rp")]
-    [TestCase("p\r\np")]
+        [TestCase("p\np")]
+        [TestCase("p\rp")]
+        [TestCase("p\r\np")]
 
-    [TestCase("p\np\n")]
-    [TestCase("p\rp\n")]
-    [TestCase("p\r\np\n")]
+        [TestCase("p\np\n")]
+        [TestCase("p\rp\n")]
+        [TestCase("p\r\np\n")]
 
-    [TestCase("p\np\r")]
-    [TestCase("p\rp\r")]
-    [TestCase("p\r\np\r")]
+        [TestCase("p\np\r")]
+        [TestCase("p\rp\r")]
+        [TestCase("p\r\np\r")]
 
-    [TestCase("p\np\r\n")]
-    [TestCase("p\rp\r\n")]
-    [TestCase("p\r\np\r\n")]
+        [TestCase("p\np\r\n")]
+        [TestCase("p\rp\r\n")]
+        [TestCase("p\r\np\r\n")]
 
-    [TestCase("\np\n")]
-    [TestCase("\np\r")]
-    [TestCase("\np\r\n")]
+        [TestCase("\np\n")]
+        [TestCase("\np\r")]
+        [TestCase("\np\r\n")]
 
-    [TestCase("\np\np")]
-    [TestCase("\np\rp")]
-    [TestCase("\np\r\np")]
+        [TestCase("\np\np")]
+        [TestCase("\np\rp")]
+        [TestCase("\np\r\np")]
 
-    [TestCase("\np\np\n")]
-    [TestCase("\np\rp\n")]
-    [TestCase("\np\r\np\n")]
+        [TestCase("\np\np\n")]
+        [TestCase("\np\rp\n")]
+        [TestCase("\np\r\np\n")]
 
-    [TestCase("\np\np\r")]
-    [TestCase("\np\rp\r")]
-    [TestCase("\np\r\np\r")]
+        [TestCase("\np\np\r")]
+        [TestCase("\np\rp\r")]
+        [TestCase("\np\r\np\r")]
 
-    [TestCase("\np\np\r\n")]
-    [TestCase("\np\rp\r\n")]
-    [TestCase("\np\r\np\r\n")]
+        [TestCase("\np\np\r\n")]
+        [TestCase("\np\rp\r\n")]
+        [TestCase("\np\r\np\r\n")]
 
-    [TestCase("\rp\n")]
-    [TestCase("\rp\r")]
-    [TestCase("\rp\r\n")]
+        [TestCase("\rp\n")]
+        [TestCase("\rp\r")]
+        [TestCase("\rp\r\n")]
 
-    [TestCase("\rp\np")]
-    [TestCase("\rp\rp")]
-    [TestCase("\rp\r\np")]
+        [TestCase("\rp\np")]
+        [TestCase("\rp\rp")]
+        [TestCase("\rp\r\np")]
 
-    [TestCase("\rp\np\n")]
-    [TestCase("\rp\rp\n")]
-    [TestCase("\rp\r\np\n")]
+        [TestCase("\rp\np\n")]
+        [TestCase("\rp\rp\n")]
+        [TestCase("\rp\r\np\n")]
 
-    [TestCase("\rp\np\r")]
-    [TestCase("\rp\rp\r")]
-    [TestCase("\rp\r\np\r")]
+        [TestCase("\rp\np\r")]
+        [TestCase("\rp\rp\r")]
+        [TestCase("\rp\r\np\r")]
 
-    [TestCase("\rp\np\r\n")]
-    [TestCase("\rp\rp\r\n")]
-    [TestCase("\rp\r\np\r\n")]
+        [TestCase("\rp\np\r\n")]
+        [TestCase("\rp\rp\r\n")]
+        [TestCase("\rp\r\np\r\n")]
 
-    [TestCase("\r\np\n")]
-    [TestCase("\r\np\r")]
-    [TestCase("\r\np\r\n")]
+        [TestCase("\r\np\n")]
+        [TestCase("\r\np\r")]
+        [TestCase("\r\np\r\n")]
 
-    [TestCase("\r\np\np")]
-    [TestCase("\r\np\rp")]
-    [TestCase("\r\np\r\np")]
+        [TestCase("\r\np\np")]
+        [TestCase("\r\np\rp")]
+        [TestCase("\r\np\r\np")]
 
-    [TestCase("\r\np\np\n")]
-    [TestCase("\r\np\rp\n")]
-    [TestCase("\r\np\r\np\n")]
+        [TestCase("\r\np\np\n")]
+        [TestCase("\r\np\rp\n")]
+        [TestCase("\r\np\r\np\n")]
 
-    [TestCase("\r\np\np\r")]
-    [TestCase("\r\np\rp\r")]
-    [TestCase("\r\np\r\np\r")]
+        [TestCase("\r\np\np\r")]
+        [TestCase("\r\np\rp\r")]
+        [TestCase("\r\np\r\np\r")]
 
-    [TestCase("\r\np\np\r\n")]
-    [TestCase("\r\np\rp\r\n")]
-    [TestCase("\r\np\r\np\r\n")]
+        [TestCase("\r\np\np\r\n")]
+        [TestCase("\r\np\rp\r\n")]
+        [TestCase("\r\np\r\np\r\n")]
 
-    [TestCase("p\n")]
-    [TestCase("p\n\n")]
-    [TestCase("p\n\n\n")]
-    [TestCase("p\n\n\n\n")]
-    public void TestNewline(string value)
-    {
-        RoundTrip(value);
-    }
+        [TestCase("p\n")]
+        [TestCase("p\n\n")]
+        [TestCase("p\n\n\n")]
+        [TestCase("p\n\n\n\n")]
+        public void TestNewline(string value)
+        {
+            RoundTrip(value);
+        }
 
-    [TestCase(" \n")]
-    [TestCase(" \r")]
-    [TestCase(" \r\n")]
+        [TestCase(" \n")]
+        [TestCase(" \r")]
+        [TestCase(" \r\n")]
 
-    [TestCase(" \np")]
-    [TestCase(" \rp")]
-    [TestCase(" \r\np")]
+        [TestCase(" \np")]
+        [TestCase(" \rp")]
+        [TestCase(" \r\np")]
 
-    [TestCase("  \np")]
-    [TestCase("  \rp")]
-    [TestCase("  \r\np")]
+        [TestCase("  \np")]
+        [TestCase("  \rp")]
+        [TestCase("  \r\np")]
 
-    [TestCase("   \np")]
-    [TestCase("   \rp")]
-    [TestCase("   \r\np")]
+        [TestCase("   \np")]
+        [TestCase("   \rp")]
+        [TestCase("   \r\np")]
 
-    [TestCase(" \n ")]
-    [TestCase(" \r ")]
-    [TestCase(" \r\n ")]
+        [TestCase(" \n ")]
+        [TestCase(" \r ")]
+        [TestCase(" \r\n ")]
 
-    [TestCase(" \np ")]
-    [TestCase(" \rp ")]
-    [TestCase(" \r\np ")]
+        [TestCase(" \np ")]
+        [TestCase(" \rp ")]
+        [TestCase(" \r\np ")]
 
-    [TestCase("  \np ")]
-    [TestCase("  \rp ")]
-    [TestCase("  \r\np ")]
+        [TestCase("  \np ")]
+        [TestCase("  \rp ")]
+        [TestCase("  \r\np ")]
 
-    [TestCase("   \np ")]
-    [TestCase("   \rp ")]
-    [TestCase("   \r\np ")]
-    public void Test_WhitespaceWithNewline(string value)
-    {
-        RoundTrip(value);
+        [TestCase("   \np ")]
+        [TestCase("   \rp ")]
+        [TestCase("   \r\np ")]
+        public void Test_WhitespaceWithNewline(string value)
+        {
+            RoundTrip(value);
+        }
     }
 }

src/Markdig.Tests/RoundtripSpecs/TestQuoteBlock.cs

@@ -1,284 +1,286 @@
+using NUnit.Framework;
 using static Markdig.Tests.TestRoundtrip;
 
-namespace Markdig.Tests.RoundtripSpecs;
-
-[TestFixture]
-public class TestQuoteBlock
+namespace Markdig.Tests.RoundtripSpecs
 {
-    [TestCase(">q")]
-    [TestCase(" >q")]
-    [TestCase("  >q")]
-    [TestCase("   >q")]
-    [TestCase("> q")]
-    [TestCase(" > q")]
-    [TestCase("  > q")]
-    [TestCase("   > q")]
-    [TestCase(">  q")]
-    [TestCase(" >  q")]
-    [TestCase("  >  q")]
-    [TestCase("   >  q")]
-
-    [TestCase(">q\n>q")]
-    [TestCase(">q\n >q")]
-    [TestCase(">q\n  >q")]
-    [TestCase(">q\n   >q")]
-    [TestCase(">q\n> q")]
-    [TestCase(">q\n > q")]
-    [TestCase(">q\n  > q")]
-    [TestCase(">q\n   > q")]
-    [TestCase(">q\n>  q")]
-    [TestCase(">q\n >  q")]
-    [TestCase(">q\n  >  q")]
-    [TestCase(">q\n   >  q")]
-
-    [TestCase(" >q\n>q")]
-    [TestCase(" >q\n >q")]
-    [TestCase(" >q\n  >q")]
-    [TestCase(" >q\n   >q")]
-    [TestCase(" >q\n> q")]
-    [TestCase(" >q\n > q")]
-    [TestCase(" >q\n  > q")]
-    [TestCase(" >q\n   > q")]
-    [TestCase(" >q\n>  q")]
-    [TestCase(" >q\n >  q")]
-    [TestCase(" >q\n  >  q")]
-    [TestCase(" >q\n   >  q")]
-
-    [TestCase("  >q\n>q")]
-    [TestCase("  >q\n >q")]
-    [TestCase("  >q\n  >q")]
-    [TestCase("  >q\n   >q")]
-    [TestCase("  >q\n> q")]
-    [TestCase("  >q\n > q")]
-    [TestCase("  >q\n  > q")]
-    [TestCase("  >q\n   > q")]
-    [TestCase("  >q\n>  q")]
-    [TestCase("  >q\n >  q")]
-    [TestCase("  >q\n  >  q")]
-    [TestCase("  >q\n   >  q")]
-
-    [TestCase("> q\n>q")]
-    [TestCase("> q\n >q")]
-    [TestCase("> q\n  >q")]
-    [TestCase("> q\n   >q")]
-    [TestCase("> q\n> q")]
-    [TestCase("> q\n > q")]
-    [TestCase("> q\n  > q")]
-    [TestCase("> q\n   > q")]
-    [TestCase("> q\n>  q")]
-    [TestCase("> q\n >  q")]
-    [TestCase("> q\n  >  q")]
-    [TestCase("> q\n   >  q")]
-
-    [TestCase(" > q\n>q")]
-    [TestCase(" > q\n >q")]
-    [TestCase(" > q\n  >q")]
-    [TestCase(" > q\n   >q")]
-    [TestCase(" > q\n> q")]
-    [TestCase(" > q\n > q")]
-    [TestCase(" > q\n  > q")]
-    [TestCase(" > q\n   > q")]
-    [TestCase(" > q\n>  q")]
-    [TestCase(" > q\n >  q")]
-    [TestCase(" > q\n  >  q")]
-    [TestCase(" > q\n   >  q")]
-
-    [TestCase("  > q\n>q")]
-    [TestCase("  > q\n >q")]
-    [TestCase("  > q\n  >q")]
-    [TestCase("  > q\n   >q")]
-    [TestCase("  > q\n> q")]
-    [TestCase("  > q\n > q")]
-    [TestCase("  > q\n  > q")]
-    [TestCase("  > q\n   > q")]
-    [TestCase("  > q\n>  q")]
-    [TestCase("  > q\n >  q")]
-    [TestCase("  > q\n  >  q")]
-    [TestCase("  > q\n   >  q")]
-
-    [TestCase("   > q\n>q")]
-    [TestCase("   > q\n >q")]
-    [TestCase("   > q\n  >q")]
-    [TestCase("   > q\n   >q")]
-    [TestCase("   > q\n> q")]
-    [TestCase("   > q\n > q")]
-    [TestCase("   > q\n  > q")]
-    [TestCase("   > q\n   > q")]
-    [TestCase("   > q\n>  q")]
-    [TestCase("   > q\n >  q")]
-    [TestCase("   > q\n  >  q")]
-    [TestCase("   > q\n   >  q")]
-
-    [TestCase(">  q\n>q")]
-    [TestCase(">  q\n >q")]
-    [TestCase(">  q\n  >q")]
-    [TestCase(">  q\n   >q")]
-    [TestCase(">  q\n> q")]
-    [TestCase(">  q\n > q")]
-    [TestCase(">  q\n  > q")]
-    [TestCase(">  q\n   > q")]
-    [TestCase(">  q\n>  q")]
-    [TestCase(">  q\n >  q")]
-    [TestCase(">  q\n  >  q")]
-    [TestCase(">  q\n   >  q")]
-
-    [TestCase(" >  q\n>q")]
-    [TestCase(" >  q\n >q")]
-    [TestCase(" >  q\n  >q")]
-    [TestCase(" >  q\n   >q")]
-    [TestCase(" >  q\n> q")]
-    [TestCase(" >  q\n > q")]
-    [TestCase(" >  q\n  > q")]
-    [TestCase(" >  q\n   > q")]
-    [TestCase(" >  q\n>  q")]
-    [TestCase(" >  q\n >  q")]
-    [TestCase(" >  q\n  >  q")]
-    [TestCase(" >  q\n   >  q")]
-
-    [TestCase("  >  q\n>q")]
-    [TestCase("  >  q\n >q")]
-    [TestCase("  >  q\n  >q")]
-    [TestCase("  >  q\n   >q")]
-    [TestCase("  >  q\n> q")]
-    [TestCase("  >  q\n > q")]
-    [TestCase("  >  q\n  > q")]
-    [TestCase("  >  q\n   > q")]
-    [TestCase("  >  q\n>  q")]
-    [TestCase("  >  q\n >  q")]
-    [TestCase("  >  q\n  >  q")]
-    [TestCase("  >  q\n   >  q")]
-
-    [TestCase("   >  q\n>q")]
-    [TestCase("   >  q\n >q")]
-    [TestCase("   >  q\n  >q")]
-    [TestCase("   >  q\n   >q")]
-    [TestCase("   >  q\n> q")]
-    [TestCase("   >  q\n > q")]
-    [TestCase("   >  q\n  > q")]
-    [TestCase("   >  q\n   > q")]
-    [TestCase("   >  q\n>  q")]
-    [TestCase("   >  q\n >  q")]
-    [TestCase("   >  q\n  >  q")]
-    [TestCase("   >  q\n   >  q")]
-
-    [TestCase(">q\n>q\n>q")]
-    [TestCase(">q\n>\n>q")]
-    [TestCase(">q\np\n>q")]
-    [TestCase(">q\n>\n>\n>q")]
-    [TestCase(">q\n>\n>\n>\n>q")]
-    [TestCase(">q\n>\n>q\n>\n>q")]
-    [TestCase("p\n\n> **q**\n>p\n")]
-
-    [TestCase("> q\np\n> q")] // lazy
-    [TestCase("> q\n> q\np")] // lazy
-
-    [TestCase(">>q")]
-    [TestCase(" >  >   q")]
-
-    [TestCase("> **q**\n>p\n")]
-    [TestCase("> **q**")]
-    public void Test(string value)
+    [TestFixture]
+    public class TestQuoteBlock
     {
-        RoundTrip(value);
-    }
+        [TestCase(">q")]
+        [TestCase(" >q")]
+        [TestCase("  >q")]
+        [TestCase("   >q")]
+        [TestCase("> q")]
+        [TestCase(" > q")]
+        [TestCase("  > q")]
+        [TestCase("   > q")]
+        [TestCase(">  q")]
+        [TestCase(" >  q")]
+        [TestCase("  >  q")]
+        [TestCase("   >  q")]
 
-    [TestCase(">     q")] // 5
-    [TestCase(">      q")] // 6
-    [TestCase(" >     q")] //5
-    [TestCase(" >      q")] //6
-    [TestCase(" > \tq")]
-    [TestCase(">     q\n>     q")] // 5, 5
-    [TestCase(">     q\n>      q")] // 5, 6
-    [TestCase(">      q\n>     q")] // 6, 5
-    [TestCase(">      q\n>      q")] // 6, 6
-    [TestCase(">     q\n\n>     5")] // 5, 5
-    public void TestIndentedCodeBlock(string value)
-    {
-        RoundTrip(value);
-    }
+        [TestCase(">q\n>q")]
+        [TestCase(">q\n >q")]
+        [TestCase(">q\n  >q")]
+        [TestCase(">q\n   >q")]
+        [TestCase(">q\n> q")]
+        [TestCase(">q\n > q")]
+        [TestCase(">q\n  > q")]
+        [TestCase(">q\n   > q")]
+        [TestCase(">q\n>  q")]
+        [TestCase(">q\n >  q")]
+        [TestCase(">q\n  >  q")]
+        [TestCase(">q\n   >  q")]
 
-    [TestCase("\n> q")]
-    [TestCase("\n> q\n")]
-    [TestCase("\n> q\n\n")]
-    [TestCase("> q\n\np")]
-    [TestCase("p\n\n> q\n\n# h")]
+        [TestCase(" >q\n>q")]
+        [TestCase(" >q\n >q")]
+        [TestCase(" >q\n  >q")]
+        [TestCase(" >q\n   >q")]
+        [TestCase(" >q\n> q")]
+        [TestCase(" >q\n > q")]
+        [TestCase(" >q\n  > q")]
+        [TestCase(" >q\n   > q")]
+        [TestCase(" >q\n>  q")]
+        [TestCase(" >q\n >  q")]
+        [TestCase(" >q\n  >  q")]
+        [TestCase(" >q\n   >  q")]
 
-    //https://github.com/lunet-io/markdig/issues/480
-    //[TestCase(">\np")]
-    //[TestCase(">**b**\n>\n>p\n>\np\n")]
-    public void TestParagraph(string value)
-    {
-        RoundTrip(value);
-    }
+        [TestCase("  >q\n>q")]
+        [TestCase("  >q\n >q")]
+        [TestCase("  >q\n  >q")]
+        [TestCase("  >q\n   >q")]
+        [TestCase("  >q\n> q")]
+        [TestCase("  >q\n > q")]
+        [TestCase("  >q\n  > q")]
+        [TestCase("  >q\n   > q")]
+        [TestCase("  >q\n>  q")]
+        [TestCase("  >q\n >  q")]
+        [TestCase("  >q\n  >  q")]
+        [TestCase("  >q\n   >  q")]
 
-    [TestCase("> q\n\n# h\n")]
-    public void TestAtxHeader(string value)
-    {
-        RoundTrip(value);
-    }
+        [TestCase("> q\n>q")]
+        [TestCase("> q\n >q")]
+        [TestCase("> q\n  >q")]
+        [TestCase("> q\n   >q")]
+        [TestCase("> q\n> q")]
+        [TestCase("> q\n > q")]
+        [TestCase("> q\n  > q")]
+        [TestCase("> q\n   > q")]
+        [TestCase("> q\n>  q")]
+        [TestCase("> q\n >  q")]
+        [TestCase("> q\n  >  q")]
+        [TestCase("> q\n   >  q")]
 
-    [TestCase(">- i")]
-    [TestCase("> - i")]
-    [TestCase(">- i\n>- i")]
-    [TestCase(">- >p")]
-    [TestCase("> - >p")]
-    [TestCase(">- i1\n>- i2\n")]
-    [TestCase("> **p** p\n>- i1\n>- i2\n")]
-    public void TestUnorderedList(string value)
-    {
-        RoundTrip(value);
-    }
+        [TestCase(" > q\n>q")]
+        [TestCase(" > q\n >q")]
+        [TestCase(" > q\n  >q")]
+        [TestCase(" > q\n   >q")]
+        [TestCase(" > q\n> q")]
+        [TestCase(" > q\n > q")]
+        [TestCase(" > q\n  > q")]
+        [TestCase(" > q\n   > q")]
+        [TestCase(" > q\n>  q")]
+        [TestCase(" > q\n >  q")]
+        [TestCase(" > q\n  >  q")]
+        [TestCase(" > q\n   >  q")]
 
-    [TestCase("> *q*\n>p\n")]
-    [TestCase("> *q*")]
-    public void TestEmphasis(string value)
-    {
-        RoundTrip(value);
-    }
+        [TestCase("  > q\n>q")]
+        [TestCase("  > q\n >q")]
+        [TestCase("  > q\n  >q")]
+        [TestCase("  > q\n   >q")]
+        [TestCase("  > q\n> q")]
+        [TestCase("  > q\n > q")]
+        [TestCase("  > q\n  > q")]
+        [TestCase("  > q\n   > q")]
+        [TestCase("  > q\n>  q")]
+        [TestCase("  > q\n >  q")]
+        [TestCase("  > q\n  >  q")]
+        [TestCase("  > q\n   >  q")]
 
-    [TestCase("> **q**\n>p\n")]
-    [TestCase("> **q**")]
-    public void TestStrongEmphasis(string value)
-    {
-        RoundTrip(value);
-    }
+        [TestCase("   > q\n>q")]
+        [TestCase("   > q\n >q")]
+        [TestCase("   > q\n  >q")]
+        [TestCase("   > q\n   >q")]
+        [TestCase("   > q\n> q")]
+        [TestCase("   > q\n > q")]
+        [TestCase("   > q\n  > q")]
+        [TestCase("   > q\n   > q")]
+        [TestCase("   > q\n>  q")]
+        [TestCase("   > q\n >  q")]
+        [TestCase("   > q\n  >  q")]
+        [TestCase("   > q\n   >  q")]
 
-    [TestCase(">p\n")]
-    [TestCase(">p\r")]
-    [TestCase(">p\r\n")]
+        [TestCase(">  q\n>q")]
+        [TestCase(">  q\n >q")]
+        [TestCase(">  q\n  >q")]
+        [TestCase(">  q\n   >q")]
+        [TestCase(">  q\n> q")]
+        [TestCase(">  q\n > q")]
+        [TestCase(">  q\n  > q")]
+        [TestCase(">  q\n   > q")]
+        [TestCase(">  q\n>  q")]
+        [TestCase(">  q\n >  q")]
+        [TestCase(">  q\n  >  q")]
+        [TestCase(">  q\n   >  q")]
 
-    [TestCase(">p\n>p")]
-    [TestCase(">p\r>p")]
-    [TestCase(">p\r\n>p")]
+        [TestCase(" >  q\n>q")]
+        [TestCase(" >  q\n >q")]
+        [TestCase(" >  q\n  >q")]
+        [TestCase(" >  q\n   >q")]
+        [TestCase(" >  q\n> q")]
+        [TestCase(" >  q\n > q")]
+        [TestCase(" >  q\n  > q")]
+        [TestCase(" >  q\n   > q")]
+        [TestCase(" >  q\n>  q")]
+        [TestCase(" >  q\n >  q")]
+        [TestCase(" >  q\n  >  q")]
+        [TestCase(" >  q\n   >  q")]
 
-    [TestCase(">p\n>p\n")]
-    [TestCase(">p\r>p\n")]
-    [TestCase(">p\r\n>p\n")]
+        [TestCase("  >  q\n>q")]
+        [TestCase("  >  q\n >q")]
+        [TestCase("  >  q\n  >q")]
+        [TestCase("  >  q\n   >q")]
+        [TestCase("  >  q\n> q")]
+        [TestCase("  >  q\n > q")]
+        [TestCase("  >  q\n  > q")]
+        [TestCase("  >  q\n   > q")]
+        [TestCase("  >  q\n>  q")]
+        [TestCase("  >  q\n >  q")]
+        [TestCase("  >  q\n  >  q")]
+        [TestCase("  >  q\n   >  q")]
 
-    [TestCase(">p\n>p\r")]
-    [TestCase(">p\r>p\r")]
-    [TestCase(">p\r\n>p\r")]
+        [TestCase("   >  q\n>q")]
+        [TestCase("   >  q\n >q")]
+        [TestCase("   >  q\n  >q")]
+        [TestCase("   >  q\n   >q")]
+        [TestCase("   >  q\n> q")]
+        [TestCase("   >  q\n > q")]
+        [TestCase("   >  q\n  > q")]
+        [TestCase("   >  q\n   > q")]
+        [TestCase("   >  q\n>  q")]
+        [TestCase("   >  q\n >  q")]
+        [TestCase("   >  q\n  >  q")]
+        [TestCase("   >  q\n   >  q")]
 
-    [TestCase(">p\n>p\r\n")]
-    [TestCase(">p\r>p\r\n")]
-    [TestCase(">p\r\n>p\r\n")]
-    public void TestNewline(string value)
-    {
-        RoundTrip(value);
-    }
+        [TestCase(">q\n>q\n>q")]
+        [TestCase(">q\n>\n>q")]
+        [TestCase(">q\np\n>q")]
+        [TestCase(">q\n>\n>\n>q")]
+        [TestCase(">q\n>\n>\n>\n>q")]
+        [TestCase(">q\n>\n>q\n>\n>q")]
+        [TestCase("p\n\n> **q**\n>p\n")]
 
-    [TestCase(">\n>q")]
-    [TestCase(">\n>\n>q")]
-    [TestCase(">q\n>\n>q")]
-    [TestCase(">q\n>\n>\n>q")]
-    [TestCase(">q\n> \n>q")]
-    [TestCase(">q\n>  \n>q")]
-    [TestCase(">q\n>   \n>q")]
-    [TestCase(">q\n>\t\n>q")]
-    [TestCase(">q\n>\v\n>q")]
-    [TestCase(">q\n>\f\n>q")]
-    public void TestEmptyLines(string value)
-    {
-        RoundTrip(value);
+        [TestCase("> q\np\n> q")] // lazy
+        [TestCase("> q\n> q\np")] // lazy
+
+        [TestCase(">>q")]
+        [TestCase(" >  >   q")]
+
+        [TestCase("> **q**\n>p\n")]
+        [TestCase("> **q**")]
+        public void Test(string value)
+        {
+            RoundTrip(value);
+        }
+
+        [TestCase(">     q")] // 5
+        [TestCase(">      q")] // 6
+        [TestCase(" >     q")] //5
+        [TestCase(" >      q")] //6
+        [TestCase(" > \tq")]
+        [TestCase(">     q\n>     q")] // 5, 5
+        [TestCase(">     q\n>      q")] // 5, 6
+        [TestCase(">      q\n>     q")] // 6, 5
+        [TestCase(">      q\n>      q")] // 6, 6
+        [TestCase(">     q\n\n>     5")] // 5, 5
+        public void TestIndentedCodeBlock(string value)
+        {
+            RoundTrip(value);
+        }
+
+        [TestCase("\n> q")]
+        [TestCase("\n> q\n")]
+        [TestCase("\n> q\n\n")]
+        [TestCase("> q\n\np")]
+        [TestCase("p\n\n> q\n\n# h")]
+
+        //https://github.com/lunet-io/markdig/issues/480
+        //[TestCase(">\np")]
+        //[TestCase(">**b**\n>\n>p\n>\np\n")]
+        public void TestParagraph(string value)
+        {
+            RoundTrip(value);
+        }
+
+        [TestCase("> q\n\n# h\n")]
+        public void TestAtxHeader(string value)
+        {
+            RoundTrip(value);
+        }
+
+        [TestCase(">- i")]
+        [TestCase("> - i")]
+        [TestCase(">- i\n>- i")]
+        [TestCase(">- >p")]
+        [TestCase("> - >p")]
+        [TestCase(">- i1\n>- i2\n")]
+        [TestCase("> **p** p\n>- i1\n>- i2\n")]
+        public void TestUnorderedList(string value)
+        {
+            RoundTrip(value);
+        }
+
+        [TestCase("> *q*\n>p\n")]
+        [TestCase("> *q*")]
+        public void TestEmphasis(string value)
+        {
+            RoundTrip(value);
+        }
+
+        [TestCase("> **q**\n>p\n")]
+        [TestCase("> **q**")]
+        public void TestStrongEmphasis(string value)
+        {
+            RoundTrip(value);
+        }
+
+        [TestCase(">p\n")]
+        [TestCase(">p\r")]
+        [TestCase(">p\r\n")]
+
+        [TestCase(">p\n>p")]
+        [TestCase(">p\r>p")]
+        [TestCase(">p\r\n>p")]
+
+        [TestCase(">p\n>p\n")]
+        [TestCase(">p\r>p\n")]
+        [TestCase(">p\r\n>p\n")]
+
+        [TestCase(">p\n>p\r")]
+        [TestCase(">p\r>p\r")]
+        [TestCase(">p\r\n>p\r")]
+
+        [TestCase(">p\n>p\r\n")]
+        [TestCase(">p\r>p\r\n")]
+        [TestCase(">p\r\n>p\r\n")]
+        public void TestNewline(string value)
+        {
+            RoundTrip(value);
+        }
+
+        [TestCase(">\n>q")]
+        [TestCase(">\n>\n>q")]
+        [TestCase(">q\n>\n>q")]
+        [TestCase(">q\n>\n>\n>q")]
+        [TestCase(">q\n> \n>q")]
+        [TestCase(">q\n>  \n>q")]
+        [TestCase(">q\n>   \n>q")]
+        [TestCase(">q\n>\t\n>q")]
+        [TestCase(">q\n>\v\n>q")]
+        [TestCase(">q\n>\f\n>q")]
+        public void TestEmptyLines(string value)
+        {
+            RoundTrip(value);
+        }
     }
 }

src/Markdig.Tests/RoundtripSpecs/TestSetextHeading.cs

@@ -1,51 +1,53 @@
+using NUnit.Framework;
 using static Markdig.Tests.TestRoundtrip;
 
-namespace Markdig.Tests.RoundtripSpecs;
-
-[TestFixture]
-public class TestSetextHeading
+namespace Markdig.Tests.RoundtripSpecs
 {
-    [TestCase("h1\n===")] //3
-    [TestCase("h1\n ===")] //3
-    [TestCase("h1\n  ===")] //3
-    [TestCase("h1\n   ===")] //3
-    [TestCase("h1\n=== ")] //3
-    [TestCase("h1 \n===")] //3
-    [TestCase("h1\\\n===")] //3
-    [TestCase("h1\n === ")] //3
-    [TestCase("h1\nh1 l2\n===")] //3
-    [TestCase("h1\n====")] // 4
-    [TestCase("h1\n ====")] // 4
-    [TestCase("h1\n==== ")] // 4
-    [TestCase("h1\n ==== ")] // 4
-    [TestCase("h1\n===\nh1\n===")] //3
-    [TestCase("\\>h1\n===")] //3
-    public void Test(string value)
+    [TestFixture]
+    public class TestSetextHeading
     {
-        RoundTrip(value);
-    }
+        [TestCase("h1\n===")] //3
+        [TestCase("h1\n ===")] //3
+        [TestCase("h1\n  ===")] //3
+        [TestCase("h1\n   ===")] //3
+        [TestCase("h1\n=== ")] //3
+        [TestCase("h1 \n===")] //3
+        [TestCase("h1\\\n===")] //3
+        [TestCase("h1\n === ")] //3
+        [TestCase("h1\nh1 l2\n===")] //3
+        [TestCase("h1\n====")] // 4
+        [TestCase("h1\n ====")] // 4
+        [TestCase("h1\n==== ")] // 4
+        [TestCase("h1\n ==== ")] // 4
+        [TestCase("h1\n===\nh1\n===")] //3
+        [TestCase("\\>h1\n===")] //3
+        public void Test(string value)
+        {
+            RoundTrip(value);
+        }
 
-    [TestCase("h1\r===")]
-    [TestCase("h1\n===")]
-    [TestCase("h1\r\n===")]
+        [TestCase("h1\r===")]
+        [TestCase("h1\n===")]
+        [TestCase("h1\r\n===")]
 
-    [TestCase("h1\r===\r")]
-    [TestCase("h1\n===\r")]
-    [TestCase("h1\r\n===\r")]
+        [TestCase("h1\r===\r")]
+        [TestCase("h1\n===\r")]
+        [TestCase("h1\r\n===\r")]
 
-    [TestCase("h1\r===\n")]
-    [TestCase("h1\n===\n")]
-    [TestCase("h1\r\n===\n")]
+        [TestCase("h1\r===\n")]
+        [TestCase("h1\n===\n")]
+        [TestCase("h1\r\n===\n")]
 
-    [TestCase("h1\r===\r\n")]
-    [TestCase("h1\n===\r\n")]
-    [TestCase("h1\r\n===\r\n")]
+        [TestCase("h1\r===\r\n")]
+        [TestCase("h1\n===\r\n")]
+        [TestCase("h1\r\n===\r\n")]
 
-    [TestCase("h1\n===\n\n\nh2---\n\n")]
-    [TestCase("h1\r===\r\r\rh2---\r\r")]
-    [TestCase("h1\r\n===\r\n\r\n\r\nh2---\r\n\r\n")]
-    public void TestNewline(string value)
-    {
-        RoundTrip(value);
+        [TestCase("h1\n===\n\n\nh2---\n\n")]
+        [TestCase("h1\r===\r\r\rh2---\r\r")]
+        [TestCase("h1\r\n===\r\n\r\n\r\nh2---\r\n\r\n")]
+        public void TestNewline(string value)
+        {
+            RoundTrip(value);
+        }
     }
 }

src/Markdig.Tests/RoundtripSpecs/TestThematicBreak.cs

@@ -1,51 +1,53 @@
+using NUnit.Framework;
 using static Markdig.Tests.TestRoundtrip;
 
-namespace Markdig.Tests.RoundtripSpecs;
-
-[TestFixture]
-public class TestThematicBreak
+namespace Markdig.Tests.RoundtripSpecs
 {
-    [TestCase("---")]
-    [TestCase(" ---")]
-    [TestCase("  ---")]
-    [TestCase("   ---")]
-    [TestCase("--- ")]
-    [TestCase(" --- ")]
-    [TestCase("  --- ")]
-    [TestCase("   --- ")]
-    [TestCase("- - -")]
-    [TestCase(" - - -")]
-    [TestCase(" - - - ")]
-    [TestCase("-- -")]
-    [TestCase("---\n")]
-    [TestCase("---\n\n")]
-    [TestCase("---\np")]
-    [TestCase("---\n\np")]
-    [TestCase("---\n# h")]
-    [TestCase("p\n\n---")]
-    // Note: "p\n---" is parsed as setext heading
-    public void Test(string value)
+    [TestFixture]
+    public class TestThematicBreak
     {
-        RoundTrip(value);
-    }
+        [TestCase("---")]
+        [TestCase(" ---")]
+        [TestCase("  ---")]
+        [TestCase("   ---")]
+        [TestCase("--- ")]
+        [TestCase(" --- ")]
+        [TestCase("  --- ")]
+        [TestCase("   --- ")]
+        [TestCase("- - -")]
+        [TestCase(" - - -")]
+        [TestCase(" - - - ")]
+        [TestCase("-- -")]
+        [TestCase("---\n")]
+        [TestCase("---\n\n")]
+        [TestCase("---\np")]
+        [TestCase("---\n\np")]
+        [TestCase("---\n# h")]
+        [TestCase("p\n\n---")]
+        // Note: "p\n---" is parsed as setext heading
+        public void Test(string value)
+        {
+            RoundTrip(value);
+        }
 
-    [TestCase("\n---")]
-    [TestCase("\r---")]
-    [TestCase("\r\n---")]
+        [TestCase("\n---")]
+        [TestCase("\r---")]
+        [TestCase("\r\n---")]
 
-    [TestCase("\n---\n")]
-    [TestCase("\r---\n")]
-    [TestCase("\r\n---\n")]
+        [TestCase("\n---\n")]
+        [TestCase("\r---\n")]
+        [TestCase("\r\n---\n")]
 
-    [TestCase("\n---\r")]
-    [TestCase("\r---\r")]
-    [TestCase("\r\n---\r")]
+        [TestCase("\n---\r")]
+        [TestCase("\r---\r")]
+        [TestCase("\r\n---\r")]
 
-    [TestCase("\n---\r\n")]
-    [TestCase("\r---\r\n")]
-    [TestCase("\r\n---\r\n")]
-    public void TestNewline(string value)
-    {
-        RoundTrip(value);
+        [TestCase("\n---\r\n")]
+        [TestCase("\r---\r\n")]
+        [TestCase("\r\n---\r\n")]
+        public void TestNewline(string value)
+        {
+            RoundTrip(value);
+        }
     }
 }

src/Markdig.Tests/RoundtripSpecs/TestUnorderedList.cs

@@ -1,182 +1,183 @@
+using NUnit.Framework;
 using static Markdig.Tests.TestRoundtrip;
 
-namespace Markdig.Tests.RoundtripSpecs;
-
-[TestFixture]
-public class TestUnorderedList
+namespace Markdig.Tests.RoundtripSpecs
 {
-    // i = item
-    [TestCase("- i1")]
-    [TestCase("- i1 ")]
-    [TestCase("- i1\n")]
-    [TestCase("- i1\n\n")]
-    [TestCase("- i1\n- i2")]
-    [TestCase("- i1\n    - i2")]
-    [TestCase("- i1\n    - i1.1\n    - i1.2")]
-    [TestCase("- i1 \n- i2 \n")]
-    [TestCase("- i1  \n- i2  \n")]
-    [TestCase(" - i1")]
-    [TestCase("  - i1")]
-    [TestCase("   - i1")]
-    [TestCase("- i1\n\n- i1")]
-    [TestCase("- i1\n\n\n- i1")]
-    [TestCase("- i1\n    - i1.1\n        - i1.1.1\n")]
-
-    [TestCase("-\ti1")]
-    [TestCase("-\ti1\n-\ti2")]
-    [TestCase("-\ti1\n-  i2\n-\ti3")]
-    [TestCase("- 1.\n- 2.")]
-    public void Test(string value)
+    [TestFixture]
+    public class TestUnorderedList
     {
-        RoundTrip(value);
-    }
+        // i = item
+        [TestCase("- i1")]
+        [TestCase("- i1 ")]
+        [TestCase("- i1\n")]
+        [TestCase("- i1\n\n")]
+        [TestCase("- i1\n- i2")]
+        [TestCase("- i1\n    - i2")]
+        [TestCase("- i1\n    - i1.1\n    - i1.2")]
+        [TestCase("- i1 \n- i2 \n")]
+        [TestCase("- i1  \n- i2  \n")]
+        [TestCase(" - i1")]
+        [TestCase("  - i1")]
+        [TestCase("   - i1")]
+        [TestCase("- i1\n\n- i1")]
+        [TestCase("- i1\n\n\n- i1")]
+        [TestCase("- i1\n    - i1.1\n        - i1.1.1\n")]
 
-    [TestCase("- > q")]
-    [TestCase(" - > q")]
-    [TestCase("  - > q")]
-    [TestCase("   - > q")]
-    [TestCase("-  > q")]
-    [TestCase(" -  > q")]
-    [TestCase("  -  > q")]
-    [TestCase("   -  > q")]
-    [TestCase("-   > q")]
-    [TestCase(" -   > q")]
-    [TestCase("  -   > q")]
-    [TestCase("   -   > q")]
-    [TestCase("-    > q")]
-    [TestCase(" -    > q")]
-    [TestCase("  -    > q")]
-    [TestCase("   -    > q")]
-    [TestCase("   -    > q1\n   -    > q2")]
-    public void TestBlockQuote(string value)
-    {
-        RoundTrip(value);
-    }
+        [TestCase("-\ti1")]
+        [TestCase("-\ti1\n-\ti2")]
+        [TestCase("-\ti1\n-  i2\n-\ti3")]
+        public void Test(string value)
+        {
+            RoundTrip(value);
+        }
 
-    [TestCase("-     i1\n\np\n")] // TODO: listblock should render newline, apparently last paragraph of last listitem dont have newline
-    [TestCase("-     i1\n\n\np\n")]
-    [TestCase("- i1\n\np")]
-    [TestCase("- i1\n\np\n")]
-    public void TestParagraph(string value)
-    {
-        RoundTrip(value);
-    }
+        [TestCase("- > q")]
+        [TestCase(" - > q")]
+        [TestCase("  - > q")]
+        [TestCase("   - > q")]
+        [TestCase("-  > q")]
+        [TestCase(" -  > q")]
+        [TestCase("  -  > q")]
+        [TestCase("   -  > q")]
+        [TestCase("-   > q")]
+        [TestCase(" -   > q")]
+        [TestCase("  -   > q")]
+        [TestCase("   -   > q")]
+        [TestCase("-    > q")]
+        [TestCase(" -    > q")]
+        [TestCase("  -    > q")]
+        [TestCase("   -    > q")]
+        [TestCase("   -    > q1\n   -    > q2")]
+        public void TestBlockQuote(string value)
+        {
+            RoundTrip(value);
+        }
 
-    [TestCase("- i1\n\n---\n")]
-    [TestCase("- i1\n\n\n---\n")]
-    public void TestThematicBreak(string value)
-    {
-        RoundTrip(value);
-    }
+        [TestCase("-     i1\n\np\n")] // TODO: listblock should render newline, apparently last paragraph of last listitem dont have newline
+        [TestCase("-     i1\n\n\np\n")]
+        [TestCase("- i1\n\np")]
+        [TestCase("- i1\n\np\n")]
+        public void TestParagraph(string value)
+        {
+            RoundTrip(value);
+        }
 
-    [TestCase("-     c")] // 5
-    [TestCase("-     c\n      c")] // 5, 6
-    [TestCase(" -     c\n      c")] // 5, 6
-    [TestCase(" -     c\n       c")] // 5, 7
-    [TestCase("-      c\n      c")] // 6, 6
-    [TestCase(" -      c\n      c")] // 6, 6
-    [TestCase(" -      c\n       c")] // 6, 7
-    public void TestIndentedCodeBlock(string value)
-    {
-        RoundTrip(value);
-    }
+        [TestCase("- i1\n\n---\n")]
+        [TestCase("- i1\n\n\n---\n")]
+        public void TestThematicBreak(string value)
+        {
+            RoundTrip(value);
+        }
 
-    [TestCase("- ```a```")]
-    [TestCase("- ```\n  a\n```")]
-    [TestCase("- i1\n    - i1.1\n    ```\n    c\n    ```")]
-    [TestCase("- i1\n    - i1.1\n    ```\nc\n```")]
-    [TestCase("- i1\n    - i1.1\n    ```\nc\n```\n")]
-    public void TestFencedCodeBlock(string value)
-    {
-        RoundTrip(value);
-    }
+        [TestCase("-     c")] // 5
+        [TestCase("-     c\n      c")] // 5, 6
+        [TestCase(" -     c\n      c")] // 5, 6
+        [TestCase(" -     c\n       c")] // 5, 7
+        [TestCase("-      c\n      c")] // 6, 6
+        [TestCase(" -      c\n      c")] // 6, 6
+        [TestCase(" -      c\n       c")] // 6, 7
+        public void TestIndentedCodeBlock(string value)
+        {
+            RoundTrip(value);
+        }
 
-    [TestCase("\n- i")]
-    [TestCase("\r- i")]
-    [TestCase("\r\n- i")]
+        [TestCase("- ```a```")]
+        [TestCase("- ```\n  a\n```")]
+        [TestCase("- i1\n    - i1.1\n    ```\n    c\n    ```")]
+        [TestCase("- i1\n    - i1.1\n    ```\nc\n```")]
+        [TestCase("- i1\n    - i1.1\n    ```\nc\n```\n")]
+        public void TestFencedCodeBlock(string value)
+        {
+            RoundTrip(value);
+        }
 
-    [TestCase("\n- i\n")]
-    [TestCase("\r- i\n")]
-    [TestCase("\r\n- i\n")]
+        [TestCase("\n- i")]
+        [TestCase("\r- i")]
+        [TestCase("\r\n- i")]
 
-    [TestCase("\n- i\r")]
-    [TestCase("\r- i\r")]
-    [TestCase("\r\n- i\r")]
+        [TestCase("\n- i\n")]
+        [TestCase("\r- i\n")]
+        [TestCase("\r\n- i\n")]
 
-    [TestCase("\n- i\r\n")]
-    [TestCase("\r- i\r\n")]
-    [TestCase("\r\n- i\r\n")]
+        [TestCase("\n- i\r")]
+        [TestCase("\r- i\r")]
+        [TestCase("\r\n- i\r")]
 
-    [TestCase("- i\n- j")]
-    [TestCase("- i\r- j")]
-    [TestCase("- i\r\n- j")]
+        [TestCase("\n- i\r\n")]
+        [TestCase("\r- i\r\n")]
+        [TestCase("\r\n- i\r\n")]
 
-    [TestCase("\n- i\n- j")]
-    [TestCase("\n- i\r- j")]
-    [TestCase("\n- i\r\n- j")]
+        [TestCase("- i\n- j")]
+        [TestCase("- i\r- j")]
+        [TestCase("- i\r\n- j")]
 
-    [TestCase("\r- i\n- j")]
-    [TestCase("\r- i\r- j")]
-    [TestCase("\r- i\r\n- j")]
+        [TestCase("\n- i\n- j")]
+        [TestCase("\n- i\r- j")]
+        [TestCase("\n- i\r\n- j")]
 
-    [TestCase("\r\n- i\n- j")]
-    [TestCase("\r\n- i\r- j")]
-    [TestCase("\r\n- i\r\n- j")]
+        [TestCase("\r- i\n- j")]
+        [TestCase("\r- i\r- j")]
+        [TestCase("\r- i\r\n- j")]
 
-    [TestCase("- i\n- j\n")]
-    [TestCase("- i\r- j\n")]
-    [TestCase("- i\r\n- j\n")]
+        [TestCase("\r\n- i\n- j")]
+        [TestCase("\r\n- i\r- j")]
+        [TestCase("\r\n- i\r\n- j")]
 
-    [TestCase("\n- i\n- j\n")]
-    [TestCase("\n- i\r- j\n")]
-    [TestCase("\n- i\r\n- j\n")]
+        [TestCase("- i\n- j\n")]
+        [TestCase("- i\r- j\n")]
+        [TestCase("- i\r\n- j\n")]
 
-    [TestCase("\r- i\n- j\n")]
-    [TestCase("\r- i\r- j\n")]
-    [TestCase("\r- i\r\n- j\n")]
+        [TestCase("\n- i\n- j\n")]
+        [TestCase("\n- i\r- j\n")]
+        [TestCase("\n- i\r\n- j\n")]
 
-    [TestCase("\r\n- i\n- j\n")]
-    [TestCase("\r\n- i\r- j\n")]
-    [TestCase("\r\n- i\r\n- j\n")]
+        [TestCase("\r- i\n- j\n")]
+        [TestCase("\r- i\r- j\n")]
+        [TestCase("\r- i\r\n- j\n")]
 
-    [TestCase("- i\n- j\r")]
-    [TestCase("- i\r- j\r")]
-    [TestCase("- i\r\n- j\r")]
+        [TestCase("\r\n- i\n- j\n")]
+        [TestCase("\r\n- i\r- j\n")]
+        [TestCase("\r\n- i\r\n- j\n")]
 
-    [TestCase("\n- i\n- j\r")]
-    [TestCase("\n- i\r- j\r")]
-    [TestCase("\n- i\r\n- j\r")]
+        [TestCase("- i\n- j\r")]
+        [TestCase("- i\r- j\r")]
+        [TestCase("- i\r\n- j\r")]
 
-    [TestCase("\r- i\n- j\r")]
-    [TestCase("\r- i\r- j\r")]
-    [TestCase("\r- i\r\n- j\r")]
+        [TestCase("\n- i\n- j\r")]
+        [TestCase("\n- i\r- j\r")]
+        [TestCase("\n- i\r\n- j\r")]
 
-    [TestCase("\r\n- i\n- j\r")]
-    [TestCase("\r\n- i\r- j\r")]
-    [TestCase("\r\n- i\r\n- j\r")]
+        [TestCase("\r- i\n- j\r")]
+        [TestCase("\r- i\r- j\r")]
+        [TestCase("\r- i\r\n- j\r")]
 
-    [TestCase("- i\n- j\r\n")]
-    [TestCase("- i\r- j\r\n")]
-    [TestCase("- i\r\n- j\r\n")]
+        [TestCase("\r\n- i\n- j\r")]
+        [TestCase("\r\n- i\r- j\r")]
+        [TestCase("\r\n- i\r\n- j\r")]
 
-    [TestCase("\n- i\n- j\r\n")]
-    [TestCase("\n- i\r- j\r\n")]
-    [TestCase("\n- i\r\n- j\r\n")]
+        [TestCase("- i\n- j\r\n")]
+        [TestCase("- i\r- j\r\n")]
+        [TestCase("- i\r\n- j\r\n")]
 
-    [TestCase("\r- i\n- j\r\n")]
-    [TestCase("\r- i\r- j\r\n")]
-    [TestCase("\r- i\r\n- j\r\n")]
+        [TestCase("\n- i\n- j\r\n")]
+        [TestCase("\n- i\r- j\r\n")]
+        [TestCase("\n- i\r\n- j\r\n")]
 
-    [TestCase("\r\n- i\n- j\r\n")]
-    [TestCase("\r\n- i\r- j\r\n")]
-    [TestCase("\r\n- i\r\n- j\r\n")]
+        [TestCase("\r- i\n- j\r\n")]
+        [TestCase("\r- i\r- j\r\n")]
+        [TestCase("\r- i\r\n- j\r\n")]
 
-    [TestCase("- i\n")]
-    [TestCase("- i\n\n")]
-    [TestCase("- i\n\n\n")]
-    [TestCase("- i\n\n\n\n")]
-    public void TestNewline(string value)
-    {
-        RoundTrip(value);
+        [TestCase("\r\n- i\n- j\r\n")]
+        [TestCase("\r\n- i\r- j\r\n")]
+        [TestCase("\r\n- i\r\n- j\r\n")]
+
+        [TestCase("- i\n")]
+        [TestCase("- i\n\n")]
+        [TestCase("- i\n\n\n")]
+        [TestCase("- i\n\n\n\n")]
+        public void TestNewline(string value)
+        {
+            RoundTrip(value);
+        }
     }
 }

src/Markdig.Tests/RoundtripSpecs/TestYamlFrontMatterBlock.cs

@@ -1,15 +0,0 @@
-using static Markdig.Tests.TestRoundtrip;
-
-namespace Markdig.Tests.RoundtripSpecs;
-
-[TestFixture]
-public class TestYamlFrontMatterBlock
-{
-    [TestCase("---\nkey1: value1\nkey2: value2\n---\n\nContent\n")]
-    [TestCase("No front matter")]
-    [TestCase("Looks like front matter but actually is not\n---\nkey1: value1\nkey2: value2\n---")]
-    public void FrontMatterBlockIsPreserved(string value)
-    {
-        RoundTrip(value);
-    }
-}

src/Markdig.Tests/Specs/AbbreviationSpecs.generated.cs

@@ -34,7 +34,8 @@ namespace Markdig.Tests.Specs.Abbreviations
             // Should be rendered as:
             //     <p>Later in a text we are using <abbr title="Hypertext Markup Language">HTML</abbr> and it becomes an abbr tag <abbr title="Hypertext Markup Language">HTML</abbr></p>
 
-            TestParser.TestSpec("*[HTML]: Hypertext Markup Language\n\nLater in a text we are using HTML and it becomes an abbr tag HTML", "<p>Later in a text we are using <abbr title=\"Hypertext Markup Language\">HTML</abbr> and it becomes an abbr tag <abbr title=\"Hypertext Markup Language\">HTML</abbr></p>", "abbreviations|advanced", context: "Example 1\nSection Extensions / Abbreviation\n");
+            Console.WriteLine("Example 1\nSection Extensions / Abbreviation\n");
+            TestParser.TestSpec("*[HTML]: Hypertext Markup Language\n\nLater in a text we are using HTML and it becomes an abbr tag HTML", "<p>Later in a text we are using <abbr title=\"Hypertext Markup Language\">HTML</abbr> and it becomes an abbr tag <abbr title=\"Hypertext Markup Language\">HTML</abbr></p>", "abbreviations|advanced");
         }
 
         // An abbreviation definition can be indented at most 3 spaces
@@ -52,7 +53,8 @@ namespace Markdig.Tests.Specs.Abbreviations
             //     <pre><code>*[This]: is not an abbreviation
             //     </code></pre>
 
-            TestParser.TestSpec("*[HTML]: Hypertext Markup Language\n    *[This]: is not an abbreviation", "<pre><code>*[This]: is not an abbreviation\n</code></pre>", "abbreviations|advanced", context: "Example 2\nSection Extensions / Abbreviation\n");
+            Console.WriteLine("Example 2\nSection Extensions / Abbreviation\n");
+            TestParser.TestSpec("*[HTML]: Hypertext Markup Language\n    *[This]: is not an abbreviation", "<pre><code>*[This]: is not an abbreviation\n</code></pre>", "abbreviations|advanced");
         }
 
         // An abbreviation may contain spaces:
@@ -70,7 +72,8 @@ namespace Markdig.Tests.Specs.Abbreviations
             // Should be rendered as:
             //     <p>This is a <abbr title="Super Hypertext Markup Language">SUPER HTML</abbr> document</p>
 
-            TestParser.TestSpec("*[SUPER HTML]: Super Hypertext Markup Language\n\nThis is a SUPER HTML document    ", "<p>This is a <abbr title=\"Super Hypertext Markup Language\">SUPER HTML</abbr> document</p>", "abbreviations|advanced", context: "Example 3\nSection Extensions / Abbreviation\n");
+            Console.WriteLine("Example 3\nSection Extensions / Abbreviation\n");
+            TestParser.TestSpec("*[SUPER HTML]: Super Hypertext Markup Language\n\nThis is a SUPER HTML document    ", "<p>This is a <abbr title=\"Super Hypertext Markup Language\">SUPER HTML</abbr> document</p>", "abbreviations|advanced");
         }
 
         // Abbreviation may contain any unicode characters:
@@ -88,7 +91,8 @@ namespace Markdig.Tests.Specs.Abbreviations
             // Should be rendered as:
             //     <p>This is a <abbr title="Hypertext Markup Language">😃 HTML</abbr> document</p>
 
-            TestParser.TestSpec("*[😃 HTML]: Hypertext Markup Language\n\nThis is a 😃 HTML document    ", "<p>This is a <abbr title=\"Hypertext Markup Language\">😃 HTML</abbr> document</p>", "abbreviations|advanced", context: "Example 4\nSection Extensions / Abbreviation\n");
+            Console.WriteLine("Example 4\nSection Extensions / Abbreviation\n");
+            TestParser.TestSpec("*[😃 HTML]: Hypertext Markup Language\n\nThis is a 😃 HTML document    ", "<p>This is a <abbr title=\"Hypertext Markup Language\">😃 HTML</abbr> document</p>", "abbreviations|advanced");
         }
 
         // Abbreviations may be similar:
@@ -108,7 +112,8 @@ namespace Markdig.Tests.Specs.Abbreviations
             // Should be rendered as:
             //     <p>We can abbreviate <abbr title="First">1A</abbr>, <abbr title="Second">1A1</abbr> and <abbr title="Third">1A2</abbr>!</p>
 
-            TestParser.TestSpec("*[1A]: First\n*[1A1]: Second\n*[1A2]: Third\n\nWe can abbreviate 1A, 1A1 and 1A2!", "<p>We can abbreviate <abbr title=\"First\">1A</abbr>, <abbr title=\"Second\">1A1</abbr> and <abbr title=\"Third\">1A2</abbr>!</p>", "abbreviations|advanced", context: "Example 5\nSection Extensions / Abbreviation\n");
+            Console.WriteLine("Example 5\nSection Extensions / Abbreviation\n");
+            TestParser.TestSpec("*[1A]: First\n*[1A1]: Second\n*[1A2]: Third\n\nWe can abbreviate 1A, 1A1 and 1A2!", "<p>We can abbreviate <abbr title=\"First\">1A</abbr>, <abbr title=\"Second\">1A1</abbr> and <abbr title=\"Third\">1A2</abbr>!</p>", "abbreviations|advanced");
         }
 
         // Abbreviations should match whole word only:
@@ -126,7 +131,8 @@ namespace Markdig.Tests.Specs.Abbreviations
             // Should be rendered as:
             //     <p>We should not abbreviate 1.1A or 11A!</p>
 
-            TestParser.TestSpec("*[1A]: First\n\nWe should not abbreviate 1.1A or 11A!", "<p>We should not abbreviate 1.1A or 11A!</p>", "abbreviations|advanced", context: "Example 6\nSection Extensions / Abbreviation\n");
+            Console.WriteLine("Example 6\nSection Extensions / Abbreviation\n");
+            TestParser.TestSpec("*[1A]: First\n\nWe should not abbreviate 1.1A or 11A!", "<p>We should not abbreviate 1.1A or 11A!</p>", "abbreviations|advanced");
         }
 
         // Abbreviations should match whole word only, even if the word is the entire content:
@@ -144,7 +150,8 @@ namespace Markdig.Tests.Specs.Abbreviations
             // Should be rendered as:
             //     <p>1.1A</p>
 
-            TestParser.TestSpec("*[1A]: First\n\n1.1A", "<p>1.1A</p>", "abbreviations|advanced", context: "Example 7\nSection Extensions / Abbreviation\n");
+            Console.WriteLine("Example 7\nSection Extensions / Abbreviation\n");
+            TestParser.TestSpec("*[1A]: First\n\n1.1A", "<p>1.1A</p>", "abbreviations|advanced");
         }
 
         // Abbreviations should match whole word only, even if there is another glossary term:
@@ -163,7 +170,8 @@ namespace Markdig.Tests.Specs.Abbreviations
             // Should be rendered as:
             //     <p><abbr title="Second">SCOM</abbr></p>
 
-            TestParser.TestSpec("*[SCO]: First\n*[SCOM]: Second\n\nSCOM", "<p><abbr title=\"Second\">SCOM</abbr></p>", "abbreviations|advanced", context: "Example 8\nSection Extensions / Abbreviation\n");
+            Console.WriteLine("Example 8\nSection Extensions / Abbreviation\n");
+            TestParser.TestSpec("*[SCO]: First\n*[SCOM]: Second\n\nSCOM", "<p><abbr title=\"Second\">SCOM</abbr></p>", "abbreviations|advanced");
         }
 
         // Abbreviations should only match when surrounded by whitespace:
@@ -181,7 +189,8 @@ namespace Markdig.Tests.Specs.Abbreviations
             // Should be rendered as:
             //     <p>PRAA</p>
 
-            TestParser.TestSpec("*[PR]: Pull Request\n\nPRAA", "<p>PRAA</p>", "abbreviations|advanced", context: "Example 9\nSection Extensions / Abbreviation\n");
+            Console.WriteLine("Example 9\nSection Extensions / Abbreviation\n");
+            TestParser.TestSpec("*[PR]: Pull Request\n\nPRAA", "<p>PRAA</p>", "abbreviations|advanced");
         }
 
         // Single character abbreviations should be matched
@@ -199,7 +208,8 @@ namespace Markdig.Tests.Specs.Abbreviations
             // Should be rendered as:
             //     <p><abbr title="Foo">A</abbr></p>
 
-            TestParser.TestSpec("*[A]: Foo\n\nA", "<p><abbr title=\"Foo\">A</abbr></p>", "abbreviations|advanced", context: "Example 10\nSection Extensions / Abbreviation\n");
+            Console.WriteLine("Example 10\nSection Extensions / Abbreviation\n");
+            TestParser.TestSpec("*[A]: Foo\n\nA", "<p><abbr title=\"Foo\">A</abbr></p>", "abbreviations|advanced");
         }
 
         // The longest matching abbreviation should be used
@@ -218,7 +228,8 @@ namespace Markdig.Tests.Specs.Abbreviations
             // Should be rendered as:
             //     <p><abbr title="foo">Foo</abbr> B</p>
 
-            TestParser.TestSpec("*[Foo]: foo\n*[Foo Bar]: foobar\n\nFoo B", "<p><abbr title=\"foo\">Foo</abbr> B</p>", "abbreviations|advanced", context: "Example 11\nSection Extensions / Abbreviation\n");
+            Console.WriteLine("Example 11\nSection Extensions / Abbreviation\n");
+            TestParser.TestSpec("*[Foo]: foo\n*[Foo Bar]: foobar\n\nFoo B", "<p><abbr title=\"foo\">Foo</abbr> B</p>", "abbreviations|advanced");
         }
     }
 }

src/Markdig.Tests/Specs/AlertBlockSpecs.generated.cs

@@ -1,179 +0,0 @@
-
-// --------------------------------
-//           Alert Blocks
-// --------------------------------
-
-using System;
-using NUnit.Framework;
-
-namespace Markdig.Tests.Specs.AlertBlocks
-{
-    [TestFixture]
-    public class TestExtensionsAlertBlocks
-    {
-        // # Extensions
-        // 
-        // This section describes the different extensions supported:
-        // 
-        // ## Alert Blocks
-        // 
-        // This is supporting the [GitHub Alert blocks](https://github.com/orgs/community/discussions/16925)
-        [Test]
-        public void ExtensionsAlertBlocks_Example001()
-        {
-            // Example 1
-            // Section: Extensions / Alert Blocks
-            //
-            // The following Markdown:
-            //     > [!NOTE]  
-            //     > Highlights information that users should take into account, even when skimming.
-            //     
-            //     > [!TIP]
-            //     > Optional information to help a user be more successful.
-            //     
-            //     > [!IMPORTANT]  
-            //     > Crucial information necessary for users to succeed.
-            //     
-            //     > [!WARNING]  
-            //     > Critical content demanding immediate user attention due to potential risks.
-            //     
-            //     > [!CAUTION]
-            //     > Negative potential consequences of an action.
-            //
-            // Should be rendered as:
-            //     <div class="markdown-alert markdown-alert-note">
-            //     <p class="markdown-alert-title"><svg viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="M0 8a8 8 0 1 1 16 0A8 8 0 0 1 0 8Zm8-6.5a6.5 6.5 0 1 0 0 13 6.5 6.5 0 0 0 0-13ZM6.5 7.75A.75.75 0 0 1 7.25 7h1a.75.75 0 0 1 .75.75v2.75h.25a.75.75 0 0 1 0 1.5h-2a.75.75 0 0 1 0-1.5h.25v-2h-.25a.75.75 0 0 1-.75-.75ZM8 6a1 1 0 1 1 0-2 1 1 0 0 1 0 2Z"></path></svg>Note</p>
-            //     <p>Highlights information that users should take into account, even when skimming.</p>
-            //     </div>
-            //     <div class="markdown-alert markdown-alert-tip">
-            //     <p class="markdown-alert-title"><svg viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="M8 1.5c-2.363 0-4 1.69-4 3.75 0 .984.424 1.625.984 2.304l.214.253c.223.264.47.556.673.848.284.411.537.896.621 1.49a.75.75 0 0 1-1.484.211c-.04-.282-.163-.547-.37-.847a8.456 8.456 0 0 0-.542-.68c-.084-.1-.173-.205-.268-.32C3.201 7.75 2.5 6.766 2.5 5.25 2.5 2.31 4.863 0 8 0s5.5 2.31 5.5 5.25c0 1.516-.701 2.5-1.328 3.259-.095.115-.184.22-.268.319-.207.245-.383.453-.541.681-.208.3-.33.565-.37.847a.751.751 0 0 1-1.485-.212c.084-.593.337-1.078.621-1.489.203-.292.45-.584.673-.848.075-.088.147-.173.213-.253.561-.679.985-1.32.985-2.304 0-2.06-1.637-3.75-4-3.75ZM5.75 12h4.5a.75.75 0 0 1 0 1.5h-4.5a.75.75 0 0 1 0-1.5ZM6 15.25a.75.75 0 0 1 .75-.75h2.5a.75.75 0 0 1 0 1.5h-2.5a.75.75 0 0 1-.75-.75Z"></path></svg>Tip</p>
-            //     <p>Optional information to help a user be more successful.</p>
-            //     </div>
-            //     <div class="markdown-alert markdown-alert-important">
-            //     <p class="markdown-alert-title"><svg viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="M0 1.75C0 .784.784 0 1.75 0h12.5C15.216 0 16 .784 16 1.75v9.5A1.75 1.75 0 0 1 14.25 13H8.06l-2.573 2.573A1.458 1.458 0 0 1 3 14.543V13H1.75A1.75 1.75 0 0 1 0 11.25Zm1.75-.25a.25.25 0 0 0-.25.25v9.5c0 .138.112.25.25.25h2a.75.75 0 0 1 .75.75v2.19l2.72-2.72a.749.749 0 0 1 .53-.22h6.5a.25.25 0 0 0 .25-.25v-9.5a.25.25 0 0 0-.25-.25Zm7 2.25v2.5a.75.75 0 0 1-1.5 0v-2.5a.75.75 0 0 1 1.5 0ZM9 9a1 1 0 1 1-2 0 1 1 0 0 1 2 0Z"></path></svg>Important</p>
-            //     <p>Crucial information necessary for users to succeed.</p>
-            //     </div>
-            //     <div class="markdown-alert markdown-alert-warning">
-            //     <p class="markdown-alert-title"><svg viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="M6.457 1.047c.659-1.234 2.427-1.234 3.086 0l6.082 11.378A1.75 1.75 0 0 1 14.082 15H1.918a1.75 1.75 0 0 1-1.543-2.575Zm1.763.707a.25.25 0 0 0-.44 0L1.698 13.132a.25.25 0 0 0 .22.368h12.164a.25.25 0 0 0 .22-.368Zm.53 3.996v2.5a.75.75 0 0 1-1.5 0v-2.5a.75.75 0 0 1 1.5 0ZM9 11a1 1 0 1 1-2 0 1 1 0 0 1 2 0Z"></path></svg>Warning</p>
-            //     <p>Critical content demanding immediate user attention due to potential risks.</p>
-            //     </div>
-            //     <div class="markdown-alert markdown-alert-caution">
-            //     <p class="markdown-alert-title"><svg viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="M4.47.22A.749.749 0 0 1 5 0h6c.199 0 .389.079.53.22l4.25 4.25c.141.14.22.331.22.53v6a.749.749 0 0 1-.22.53l-4.25 4.25A.749.749 0 0 1 11 16H5a.749.749 0 0 1-.53-.22L.22 11.53A.749.749 0 0 1 0 11V5c0-.199.079-.389.22-.53Zm.84 1.28L1.5 5.31v5.38l3.81 3.81h5.38l3.81-3.81V5.31L10.69 1.5ZM8 4a.75.75 0 0 1 .75.75v3.5a.75.75 0 0 1-1.5 0v-3.5A.75.75 0 0 1 8 4Zm0 8a1 1 0 1 1 0-2 1 1 0 0 1 0 2Z"></path></svg>Caution</p>
-            //     <p>Negative potential consequences of an action.</p>
-            //     </div>
-
-            TestParser.TestSpec("> [!NOTE]  \n> Highlights information that users should take into account, even when skimming.\n\n> [!TIP]\n> Optional information to help a user be more successful.\n\n> [!IMPORTANT]  \n> Crucial information necessary for users to succeed.\n\n> [!WARNING]  \n> Critical content demanding immediate user attention due to potential risks.\n\n> [!CAUTION]\n> Negative potential consequences of an action.", "<div class=\"markdown-alert markdown-alert-note\">\n<p class=\"markdown-alert-title\"><svg viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"><path d=\"M0 8a8 8 0 1 1 16 0A8 8 0 0 1 0 8Zm8-6.5a6.5 6.5 0 1 0 0 13 6.5 6.5 0 0 0 0-13ZM6.5 7.75A.75.75 0 0 1 7.25 7h1a.75.75 0 0 1 .75.75v2.75h.25a.75.75 0 0 1 0 1.5h-2a.75.75 0 0 1 0-1.5h.25v-2h-.25a.75.75 0 0 1-.75-.75ZM8 6a1 1 0 1 1 0-2 1 1 0 0 1 0 2Z\"></path></svg>Note</p>\n<p>Highlights information that users should take into account, even when skimming.</p>\n</div>\n<div class=\"markdown-alert markdown-alert-tip\">\n<p class=\"markdown-alert-title\"><svg viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"><path d=\"M8 1.5c-2.363 0-4 1.69-4 3.75 0 .984.424 1.625.984 2.304l.214.253c.223.264.47.556.673.848.284.411.537.896.621 1.49a.75.75 0 0 1-1.484.211c-.04-.282-.163-.547-.37-.847a8.456 8.456 0 0 0-.542-.68c-.084-.1-.173-.205-.268-.32C3.201 7.75 2.5 6.766 2.5 5.25 2.5 2.31 4.863 0 8 0s5.5 2.31 5.5 5.25c0 1.516-.701 2.5-1.328 3.259-.095.115-.184.22-.268.319-.207.245-.383.453-.541.681-.208.3-.33.565-.37.847a.751.751 0 0 1-1.485-.212c.084-.593.337-1.078.621-1.489.203-.292.45-.584.673-.848.075-.088.147-.173.213-.253.561-.679.985-1.32.985-2.304 0-2.06-1.637-3.75-4-3.75ZM5.75 12h4.5a.75.75 0 0 1 0 1.5h-4.5a.75.75 0 0 1 0-1.5ZM6 15.25a.75.75 0 0 1 .75-.75h2.5a.75.75 0 0 1 0 1.5h-2.5a.75.75 0 0 1-.75-.75Z\"></path></svg>Tip</p>\n<p>Optional information to help a user be more successful.</p>\n</div>\n<div class=\"markdown-alert markdown-alert-important\">\n<p class=\"markdown-alert-title\"><svg viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"><path d=\"M0 1.75C0 .784.784 0 1.75 0h12.5C15.216 0 16 .784 16 1.75v9.5A1.75 1.75 0 0 1 14.25 13H8.06l-2.573 2.573A1.458 1.458 0 0 1 3 14.543V13H1.75A1.75 1.75 0 0 1 0 11.25Zm1.75-.25a.25.25 0 0 0-.25.25v9.5c0 .138.112.25.25.25h2a.75.75 0 0 1 .75.75v2.19l2.72-2.72a.749.749 0 0 1 .53-.22h6.5a.25.25 0 0 0 .25-.25v-9.5a.25.25 0 0 0-.25-.25Zm7 2.25v2.5a.75.75 0 0 1-1.5 0v-2.5a.75.75 0 0 1 1.5 0ZM9 9a1 1 0 1 1-2 0 1 1 0 0 1 2 0Z\"></path></svg>Important</p>\n<p>Crucial information necessary for users to succeed.</p>\n</div>\n<div class=\"markdown-alert markdown-alert-warning\">\n<p class=\"markdown-alert-title\"><svg viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"><path d=\"M6.457 1.047c.659-1.234 2.427-1.234 3.086 0l6.082 11.378A1.75 1.75 0 0 1 14.082 15H1.918a1.75 1.75 0 0 1-1.543-2.575Zm1.763.707a.25.25 0 0 0-.44 0L1.698 13.132a.25.25 0 0 0 .22.368h12.164a.25.25 0 0 0 .22-.368Zm.53 3.996v2.5a.75.75 0 0 1-1.5 0v-2.5a.75.75 0 0 1 1.5 0ZM9 11a1 1 0 1 1-2 0 1 1 0 0 1 2 0Z\"></path></svg>Warning</p>\n<p>Critical content demanding immediate user attention due to potential risks.</p>\n</div>\n<div class=\"markdown-alert markdown-alert-caution\">\n<p class=\"markdown-alert-title\"><svg viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"><path d=\"M4.47.22A.749.749 0 0 1 5 0h6c.199 0 .389.079.53.22l4.25 4.25c.141.14.22.331.22.53v6a.749.749 0 0 1-.22.53l-4.25 4.25A.749.749 0 0 1 11 16H5a.749.749 0 0 1-.53-.22L.22 11.53A.749.749 0 0 1 0 11V5c0-.199.079-.389.22-.53Zm.84 1.28L1.5 5.31v5.38l3.81 3.81h5.38l3.81-3.81V5.31L10.69 1.5ZM8 4a.75.75 0 0 1 .75.75v3.5a.75.75 0 0 1-1.5 0v-3.5A.75.75 0 0 1 8 4Zm0 8a1 1 0 1 1 0-2 1 1 0 0 1 0 2Z\"></path></svg>Caution</p>\n<p>Negative potential consequences of an action.</p>\n</div>", "advanced", context: "Example 1\nSection Extensions / Alert Blocks\n");
-        }
-
-        // Example with code blocks and mix formatting:
-        [Test]
-        public void ExtensionsAlertBlocks_Example002()
-        {
-            // Example 2
-            // Section: Extensions / Alert Blocks
-            //
-            // The following Markdown:
-            //     > [!NOTE]
-            //     > Highlights information that users should take into account, even when skimming.
-            //     > Testing rendering for multiple lines
-            //     > ```csharp
-            //     > var test = "I can also add code to panels
-            //     > ```
-            //     > `Inline code testing`
-            //
-            // Should be rendered as:
-            //     <div class="markdown-alert markdown-alert-note">
-            //     <p class="markdown-alert-title"><svg viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="M0 8a8 8 0 1 1 16 0A8 8 0 0 1 0 8Zm8-6.5a6.5 6.5 0 1 0 0 13 6.5 6.5 0 0 0 0-13ZM6.5 7.75A.75.75 0 0 1 7.25 7h1a.75.75 0 0 1 .75.75v2.75h.25a.75.75 0 0 1 0 1.5h-2a.75.75 0 0 1 0-1.5h.25v-2h-.25a.75.75 0 0 1-.75-.75ZM8 6a1 1 0 1 1 0-2 1 1 0 0 1 0 2Z"></path></svg>Note</p>
-            //     <p>Highlights information that users should take into account, even when skimming.
-            //     Testing rendering for multiple lines</p>
-            //     <pre><code class="language-csharp">var test = &quot;I can also add code to panels
-            //     </code></pre>
-            //     <p><code>Inline code testing</code></p>
-            //     </div>
-
-            TestParser.TestSpec("> [!NOTE]\n> Highlights information that users should take into account, even when skimming.\n> Testing rendering for multiple lines\n> ```csharp\n> var test = \"I can also add code to panels\n> ```\n> `Inline code testing`", "<div class=\"markdown-alert markdown-alert-note\">\n<p class=\"markdown-alert-title\"><svg viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"><path d=\"M0 8a8 8 0 1 1 16 0A8 8 0 0 1 0 8Zm8-6.5a6.5 6.5 0 1 0 0 13 6.5 6.5 0 0 0 0-13ZM6.5 7.75A.75.75 0 0 1 7.25 7h1a.75.75 0 0 1 .75.75v2.75h.25a.75.75 0 0 1 0 1.5h-2a.75.75 0 0 1 0-1.5h.25v-2h-.25a.75.75 0 0 1-.75-.75ZM8 6a1 1 0 1 1 0-2 1 1 0 0 1 0 2Z\"></path></svg>Note</p>\n<p>Highlights information that users should take into account, even when skimming.\nTesting rendering for multiple lines</p>\n<pre><code class=\"language-csharp\">var test = &quot;I can also add code to panels\n</code></pre>\n<p><code>Inline code testing</code></p>\n</div>", "advanced", context: "Example 2\nSection Extensions / Alert Blocks\n");
-        }
-
-        // Multiline:
-        [Test]
-        public void ExtensionsAlertBlocks_Example003()
-        {
-            // Example 3
-            // Section: Extensions / Alert Blocks
-            //
-            // The following Markdown:
-            //     > [!NOTE]
-            //     > Highlights information that users should take into account, even when skimming.
-            //     > 
-            //     > Testing rendering for multiple lines
-            //     > 
-            //     > `Inline code testing`
-            //     > 
-            //     > Other line
-            //     > 
-            //     > > Nested quote
-            //     > >
-            //     > > Final nested quote line
-            //     > 
-            //     > Final line of alert
-            //
-            // Should be rendered as:
-            //     <div class="markdown-alert markdown-alert-note">
-            //     <p class="markdown-alert-title"><svg viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="M0 8a8 8 0 1 1 16 0A8 8 0 0 1 0 8Zm8-6.5a6.5 6.5 0 1 0 0 13 6.5 6.5 0 0 0 0-13ZM6.5 7.75A.75.75 0 0 1 7.25 7h1a.75.75 0 0 1 .75.75v2.75h.25a.75.75 0 0 1 0 1.5h-2a.75.75 0 0 1 0-1.5h.25v-2h-.25a.75.75 0 0 1-.75-.75ZM8 6a1 1 0 1 1 0-2 1 1 0 0 1 0 2Z"></path></svg>Note</p>
-            //     <p>Highlights information that users should take into account, even when skimming.</p>
-            //     <p>Testing rendering for multiple lines</p>
-            //     <p><code>Inline code testing</code></p>
-            //     <p>Other line</p>
-            //     <blockquote>
-            //     <p>Nested quote</p>
-            //     <p>Final nested quote line</p>
-            //     </blockquote>
-            //     <p>Final line of alert</p>
-            //     </div>
-
-            TestParser.TestSpec("> [!NOTE]\n> Highlights information that users should take into account, even when skimming.\n> \n> Testing rendering for multiple lines\n> \n> `Inline code testing`\n> \n> Other line\n> \n> > Nested quote\n> >\n> > Final nested quote line\n> \n> Final line of alert", "<div class=\"markdown-alert markdown-alert-note\">\n<p class=\"markdown-alert-title\"><svg viewBox=\"0 0 16 16\" version=\"1.1\" width=\"16\" height=\"16\" aria-hidden=\"true\"><path d=\"M0 8a8 8 0 1 1 16 0A8 8 0 0 1 0 8Zm8-6.5a6.5 6.5 0 1 0 0 13 6.5 6.5 0 0 0 0-13ZM6.5 7.75A.75.75 0 0 1 7.25 7h1a.75.75 0 0 1 .75.75v2.75h.25a.75.75 0 0 1 0 1.5h-2a.75.75 0 0 1 0-1.5h.25v-2h-.25a.75.75 0 0 1-.75-.75ZM8 6a1 1 0 1 1 0-2 1 1 0 0 1 0 2Z\"></path></svg>Note</p>\n<p>Highlights information that users should take into account, even when skimming.</p>\n<p>Testing rendering for multiple lines</p>\n<p><code>Inline code testing</code></p>\n<p>Other line</p>\n<blockquote>\n<p>Nested quote</p>\n<p>Final nested quote line</p>\n</blockquote>\n<p>Final line of alert</p>\n</div>", "advanced", context: "Example 3\nSection Extensions / Alert Blocks\n");
-        }
-
-        // An alert inline (e.g `[!NOTE]`) must come first in a quote block, and must be followed by optional spaces with a new line. If no new lines are found, it will not be considered as an alert block.
-        // 
-        // Followed by space and new line:
-        [Test]
-        public void ExtensionsAlertBlocks_Example004()
-        {
-            // Example 4
-            // Section: Extensions / Alert Blocks
-            //
-            // The following Markdown:
-            //     > [!NOTE] This is invalid because no new line
-            //     > Highlights information that users should take into account, even when skimming.
-            //
-            // Should be rendered as:
-            //     <blockquote>
-            //     <p>[!NOTE] This is invalid because no new line
-            //     Highlights information that users should take into account, even when skimming.</p>
-            //     </blockquote>
-
-            TestParser.TestSpec("> [!NOTE] This is invalid because no new line\n> Highlights information that users should take into account, even when skimming.", "<blockquote>\n<p>[!NOTE] This is invalid because no new line\nHighlights information that users should take into account, even when skimming.</p>\n</blockquote>", "advanced", context: "Example 4\nSection Extensions / Alert Blocks\n");
-        }
-
-        // Must come first in a quote block:
-        [Test]
-        public void ExtensionsAlertBlocks_Example005()
-        {
-            // Example 5
-            // Section: Extensions / Alert Blocks
-            //
-            // The following Markdown:
-            //     > This is not a [!NOTE]
-            //     > Highlights information that users should take into account, even when skimming.
-            //
-            // Should be rendered as:
-            //     <blockquote>
-            //     <p>This is not a [!NOTE]
-            //     Highlights information that users should take into account, even when skimming.</p>
-            //     </blockquote>
-
-            TestParser.TestSpec("> This is not a [!NOTE]\n> Highlights information that users should take into account, even when skimming.", "<blockquote>\n<p>This is not a [!NOTE]\nHighlights information that users should take into account, even when skimming.</p>\n</blockquote>", "advanced", context: "Example 5\nSection Extensions / Alert Blocks\n");
-        }
-    }
-}

src/Markdig.Tests/Specs/AlertBlockSpecs.md

@@ -1,127 +0,0 @@
-# Extensions
-
-This section describes the different extensions supported:
-
-## Alert Blocks
-
-This is supporting the [GitHub Alert blocks](https://github.com/orgs/community/discussions/16925)
-
-```````````````````````````````` example
-> [!NOTE]  
-> Highlights information that users should take into account, even when skimming.
-
-> [!TIP]
-> Optional information to help a user be more successful.
-
-> [!IMPORTANT]  
-> Crucial information necessary for users to succeed.
-
-> [!WARNING]  
-> Critical content demanding immediate user attention due to potential risks.
-
-> [!CAUTION]
-> Negative potential consequences of an action.
-.
-<div class="markdown-alert markdown-alert-note">
-<p class="markdown-alert-title"><svg viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="M0 8a8 8 0 1 1 16 0A8 8 0 0 1 0 8Zm8-6.5a6.5 6.5 0 1 0 0 13 6.5 6.5 0 0 0 0-13ZM6.5 7.75A.75.75 0 0 1 7.25 7h1a.75.75 0 0 1 .75.75v2.75h.25a.75.75 0 0 1 0 1.5h-2a.75.75 0 0 1 0-1.5h.25v-2h-.25a.75.75 0 0 1-.75-.75ZM8 6a1 1 0 1 1 0-2 1 1 0 0 1 0 2Z"></path></svg>Note</p>
-<p>Highlights information that users should take into account, even when skimming.</p>
-</div>
-<div class="markdown-alert markdown-alert-tip">
-<p class="markdown-alert-title"><svg viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="M8 1.5c-2.363 0-4 1.69-4 3.75 0 .984.424 1.625.984 2.304l.214.253c.223.264.47.556.673.848.284.411.537.896.621 1.49a.75.75 0 0 1-1.484.211c-.04-.282-.163-.547-.37-.847a8.456 8.456 0 0 0-.542-.68c-.084-.1-.173-.205-.268-.32C3.201 7.75 2.5 6.766 2.5 5.25 2.5 2.31 4.863 0 8 0s5.5 2.31 5.5 5.25c0 1.516-.701 2.5-1.328 3.259-.095.115-.184.22-.268.319-.207.245-.383.453-.541.681-.208.3-.33.565-.37.847a.751.751 0 0 1-1.485-.212c.084-.593.337-1.078.621-1.489.203-.292.45-.584.673-.848.075-.088.147-.173.213-.253.561-.679.985-1.32.985-2.304 0-2.06-1.637-3.75-4-3.75ZM5.75 12h4.5a.75.75 0 0 1 0 1.5h-4.5a.75.75 0 0 1 0-1.5ZM6 15.25a.75.75 0 0 1 .75-.75h2.5a.75.75 0 0 1 0 1.5h-2.5a.75.75 0 0 1-.75-.75Z"></path></svg>Tip</p>
-<p>Optional information to help a user be more successful.</p>
-</div>
-<div class="markdown-alert markdown-alert-important">
-<p class="markdown-alert-title"><svg viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="M0 1.75C0 .784.784 0 1.75 0h12.5C15.216 0 16 .784 16 1.75v9.5A1.75 1.75 0 0 1 14.25 13H8.06l-2.573 2.573A1.458 1.458 0 0 1 3 14.543V13H1.75A1.75 1.75 0 0 1 0 11.25Zm1.75-.25a.25.25 0 0 0-.25.25v9.5c0 .138.112.25.25.25h2a.75.75 0 0 1 .75.75v2.19l2.72-2.72a.749.749 0 0 1 .53-.22h6.5a.25.25 0 0 0 .25-.25v-9.5a.25.25 0 0 0-.25-.25Zm7 2.25v2.5a.75.75 0 0 1-1.5 0v-2.5a.75.75 0 0 1 1.5 0ZM9 9a1 1 0 1 1-2 0 1 1 0 0 1 2 0Z"></path></svg>Important</p>
-<p>Crucial information necessary for users to succeed.</p>
-</div>
-<div class="markdown-alert markdown-alert-warning">
-<p class="markdown-alert-title"><svg viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="M6.457 1.047c.659-1.234 2.427-1.234 3.086 0l6.082 11.378A1.75 1.75 0 0 1 14.082 15H1.918a1.75 1.75 0 0 1-1.543-2.575Zm1.763.707a.25.25 0 0 0-.44 0L1.698 13.132a.25.25 0 0 0 .22.368h12.164a.25.25 0 0 0 .22-.368Zm.53 3.996v2.5a.75.75 0 0 1-1.5 0v-2.5a.75.75 0 0 1 1.5 0ZM9 11a1 1 0 1 1-2 0 1 1 0 0 1 2 0Z"></path></svg>Warning</p>
-<p>Critical content demanding immediate user attention due to potential risks.</p>
-</div>
-<div class="markdown-alert markdown-alert-caution">
-<p class="markdown-alert-title"><svg viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="M4.47.22A.749.749 0 0 1 5 0h6c.199 0 .389.079.53.22l4.25 4.25c.141.14.22.331.22.53v6a.749.749 0 0 1-.22.53l-4.25 4.25A.749.749 0 0 1 11 16H5a.749.749 0 0 1-.53-.22L.22 11.53A.749.749 0 0 1 0 11V5c0-.199.079-.389.22-.53Zm.84 1.28L1.5 5.31v5.38l3.81 3.81h5.38l3.81-3.81V5.31L10.69 1.5ZM8 4a.75.75 0 0 1 .75.75v3.5a.75.75 0 0 1-1.5 0v-3.5A.75.75 0 0 1 8 4Zm0 8a1 1 0 1 1 0-2 1 1 0 0 1 0 2Z"></path></svg>Caution</p>
-<p>Negative potential consequences of an action.</p>
-</div>
-````````````````````````````````
-
-Example with code blocks and mix formatting:
-
-
-```````````````````````````````` example
-> [!NOTE]
-> Highlights information that users should take into account, even when skimming.
-> Testing rendering for multiple lines
-> ```csharp
-> var test = "I can also add code to panels
-> ```
-> `Inline code testing`
-.
-<div class="markdown-alert markdown-alert-note">
-<p class="markdown-alert-title"><svg viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="M0 8a8 8 0 1 1 16 0A8 8 0 0 1 0 8Zm8-6.5a6.5 6.5 0 1 0 0 13 6.5 6.5 0 0 0 0-13ZM6.5 7.75A.75.75 0 0 1 7.25 7h1a.75.75 0 0 1 .75.75v2.75h.25a.75.75 0 0 1 0 1.5h-2a.75.75 0 0 1 0-1.5h.25v-2h-.25a.75.75 0 0 1-.75-.75ZM8 6a1 1 0 1 1 0-2 1 1 0 0 1 0 2Z"></path></svg>Note</p>
-<p>Highlights information that users should take into account, even when skimming.
-Testing rendering for multiple lines</p>
-<pre><code class="language-csharp">var test = &quot;I can also add code to panels
-</code></pre>
-<p><code>Inline code testing</code></p>
-</div>
-````````````````````````````````
-
-Multiline:
-
-```````````````````````````````` example
-> [!NOTE]
-> Highlights information that users should take into account, even when skimming.
-> 
-> Testing rendering for multiple lines
-> 
-> `Inline code testing`
-> 
-> Other line
-> 
-> > Nested quote
-> >
-> > Final nested quote line
-> 
-> Final line of alert
-.
-<div class="markdown-alert markdown-alert-note">
-<p class="markdown-alert-title"><svg viewBox="0 0 16 16" version="1.1" width="16" height="16" aria-hidden="true"><path d="M0 8a8 8 0 1 1 16 0A8 8 0 0 1 0 8Zm8-6.5a6.5 6.5 0 1 0 0 13 6.5 6.5 0 0 0 0-13ZM6.5 7.75A.75.75 0 0 1 7.25 7h1a.75.75 0 0 1 .75.75v2.75h.25a.75.75 0 0 1 0 1.5h-2a.75.75 0 0 1 0-1.5h.25v-2h-.25a.75.75 0 0 1-.75-.75ZM8 6a1 1 0 1 1 0-2 1 1 0 0 1 0 2Z"></path></svg>Note</p>
-<p>Highlights information that users should take into account, even when skimming.</p>
-<p>Testing rendering for multiple lines</p>
-<p><code>Inline code testing</code></p>
-<p>Other line</p>
-<blockquote>
-<p>Nested quote</p>
-<p>Final nested quote line</p>
-</blockquote>
-<p>Final line of alert</p>
-</div>
-````````````````````````````````
-
-An alert inline (e.g `[!NOTE]`) must come first in a quote block, and must be followed by optional spaces with a new line. If no new lines are found, it will not be considered as an alert block.
-
-Followed by space and new line:
-
-```````````````````````````````` example
-> [!NOTE] This is invalid because no new line
-> Highlights information that users should take into account, even when skimming.
-.
-<blockquote>
-<p>[!NOTE] This is invalid because no new line
-Highlights information that users should take into account, even when skimming.</p>
-</blockquote>
-````````````````````````````````
-
-Must come first in a quote block:
-
-```````````````````````````````` example
-> This is not a [!NOTE]
-> Highlights information that users should take into account, even when skimming.
-.
-<blockquote>
-<p>This is not a [!NOTE]
-Highlights information that users should take into account, even when skimming.</p>
-</blockquote>
-````````````````````````````````
-
-

src/Markdig.Tests/Specs/AutoIdentifierSpecs.generated.cs

@@ -30,7 +30,8 @@ namespace Markdig.Tests.Specs.AutoIdentifiers
             // Should be rendered as:
             //     <h1 id="this-is-a-heading">This is a heading</h1>
 
-            TestParser.TestSpec("# This is a heading", "<h1 id=\"this-is-a-heading\">This is a heading</h1>", "autoidentifiers|advanced", context: "Example 1\nSection Extensions / Heading Auto Identifiers\n");
+            Console.WriteLine("Example 1\nSection Extensions / Heading Auto Identifiers\n");
+            TestParser.TestSpec("# This is a heading", "<h1 id=\"this-is-a-heading\">This is a heading</h1>", "autoidentifiers|advanced");
         }
 
         // Only punctuation `-`, `_` and `.` is kept, all other non letter characters are discarded.
@@ -48,7 +49,8 @@ namespace Markdig.Tests.Specs.AutoIdentifiers
             // Should be rendered as:
             //     <h1 id="this-is-a-heading_with.and">This - is a &amp;@! heading _ with . and ! -</h1>
 
-            TestParser.TestSpec("# This - is a &@! heading _ with . and ! -", "<h1 id=\"this-is-a-heading_with.and\">This - is a &amp;@! heading _ with . and ! -</h1>", "autoidentifiers|advanced", context: "Example 2\nSection Extensions / Heading Auto Identifiers\n");
+            Console.WriteLine("Example 2\nSection Extensions / Heading Auto Identifiers\n");
+            TestParser.TestSpec("# This - is a &@! heading _ with . and ! -", "<h1 id=\"this-is-a-heading_with.and\">This - is a &amp;@! heading _ with . and ! -</h1>", "autoidentifiers|advanced");
         }
 
         // Formatting (emphasis) are also discarded:
@@ -64,7 +66,8 @@ namespace Markdig.Tests.Specs.AutoIdentifiers
             // Should be rendered as:
             //     <h1 id="this-is-a-heading">This is a <em>heading</em></h1>
 
-            TestParser.TestSpec("# This is a *heading*", "<h1 id=\"this-is-a-heading\">This is a <em>heading</em></h1>", "autoidentifiers|advanced", context: "Example 3\nSection Extensions / Heading Auto Identifiers\n");
+            Console.WriteLine("Example 3\nSection Extensions / Heading Auto Identifiers\n");
+            TestParser.TestSpec("# This is a *heading*", "<h1 id=\"this-is-a-heading\">This is a <em>heading</em></h1>", "autoidentifiers|advanced");
         }
 
         // Links are also removed:
@@ -80,7 +83,8 @@ namespace Markdig.Tests.Specs.AutoIdentifiers
             // Should be rendered as:
             //     <h1 id="this-is-a-heading">This is a <a href="/url">heading</a></h1>
 
-            TestParser.TestSpec("# This is a [heading](/url)", "<h1 id=\"this-is-a-heading\">This is a <a href=\"/url\">heading</a></h1>", "autoidentifiers|advanced", context: "Example 4\nSection Extensions / Heading Auto Identifiers\n");
+            Console.WriteLine("Example 4\nSection Extensions / Heading Auto Identifiers\n");
+            TestParser.TestSpec("# This is a [heading](/url)", "<h1 id=\"this-is-a-heading\">This is a <a href=\"/url\">heading</a></h1>", "autoidentifiers|advanced");
         }
 
         // If multiple heading have the same text, -1, -2...-n will be postfix to the header id.
@@ -98,7 +102,8 @@ namespace Markdig.Tests.Specs.AutoIdentifiers
             //     <h1 id="this-is-a-heading">This is a heading</h1>
             //     <h1 id="this-is-a-heading-1">This is a heading</h1>
 
-            TestParser.TestSpec("# This is a heading\n# This is a heading", "<h1 id=\"this-is-a-heading\">This is a heading</h1>\n<h1 id=\"this-is-a-heading-1\">This is a heading</h1>", "autoidentifiers|advanced", context: "Example 5\nSection Extensions / Heading Auto Identifiers\n");
+            Console.WriteLine("Example 5\nSection Extensions / Heading Auto Identifiers\n");
+            TestParser.TestSpec("# This is a heading\n# This is a heading", "<h1 id=\"this-is-a-heading\">This is a heading</h1>\n<h1 id=\"this-is-a-heading-1\">This is a heading</h1>", "autoidentifiers|advanced");
         }
 
         // The heading Id will start on the first letter character of the heading, all previous characters will be discarded:
@@ -114,7 +119,8 @@ namespace Markdig.Tests.Specs.AutoIdentifiers
             // Should be rendered as:
             //     <h1 id="this-is-a-heading">1.0 This is a heading</h1>
 
-            TestParser.TestSpec("# 1.0 This is a heading", "<h1 id=\"this-is-a-heading\">1.0 This is a heading</h1>", "autoidentifiers|advanced", context: "Example 6\nSection Extensions / Heading Auto Identifiers\n");
+            Console.WriteLine("Example 6\nSection Extensions / Heading Auto Identifiers\n");
+            TestParser.TestSpec("# 1.0 This is a heading", "<h1 id=\"this-is-a-heading\">1.0 This is a heading</h1>", "autoidentifiers|advanced");
         }
 
         // If the heading is all stripped by the previous rules, the id `section` will be used instead:
@@ -132,7 +138,8 @@ namespace Markdig.Tests.Specs.AutoIdentifiers
             //     <h1 id="section">1.0 &amp; ^ % *</h1>
             //     <h1 id="section-1">1.0 &amp; ^ % *</h1>
 
-            TestParser.TestSpec("# 1.0 & ^ % *\n# 1.0 & ^ % *", "<h1 id=\"section\">1.0 &amp; ^ % *</h1>\n<h1 id=\"section-1\">1.0 &amp; ^ % *</h1>", "autoidentifiers|advanced", context: "Example 7\nSection Extensions / Heading Auto Identifiers\n");
+            Console.WriteLine("Example 7\nSection Extensions / Heading Auto Identifiers\n");
+            TestParser.TestSpec("# 1.0 & ^ % *\n# 1.0 & ^ % *", "<h1 id=\"section\">1.0 &amp; ^ % *</h1>\n<h1 id=\"section-1\">1.0 &amp; ^ % *</h1>", "autoidentifiers|advanced");
         }
 
         // When the options "AutoLink" is setup, it is possible to link to an existing heading by using the 
@@ -151,7 +158,8 @@ namespace Markdig.Tests.Specs.AutoIdentifiers
             //     <h1 id="this-is-a-heading">This is a heading</h1>
             //     <p><a href="#this-is-a-heading">This is a heading</a></p>
 
-            TestParser.TestSpec("# This is a heading\n[This is a heading]", "<h1 id=\"this-is-a-heading\">This is a heading</h1>\n<p><a href=\"#this-is-a-heading\">This is a heading</a></p>", "autoidentifiers|advanced", context: "Example 8\nSection Extensions / Heading Auto Identifiers\n");
+            Console.WriteLine("Example 8\nSection Extensions / Heading Auto Identifiers\n");
+            TestParser.TestSpec("# This is a heading\n[This is a heading]", "<h1 id=\"this-is-a-heading\">This is a heading</h1>\n<p><a href=\"#this-is-a-heading\">This is a heading</a></p>", "autoidentifiers|advanced");
         }
 
         // Links before the heading are also working:
@@ -169,7 +177,8 @@ namespace Markdig.Tests.Specs.AutoIdentifiers
             //     <p><a href="#this-is-a-heading">This is a heading</a></p>
             //     <h1 id="this-is-a-heading">This is a heading</h1>
 
-            TestParser.TestSpec("[This is a heading]\n# This is a heading", "<p><a href=\"#this-is-a-heading\">This is a heading</a></p>\n<h1 id=\"this-is-a-heading\">This is a heading</h1>", "autoidentifiers|advanced", context: "Example 9\nSection Extensions / Heading Auto Identifiers\n");
+            Console.WriteLine("Example 9\nSection Extensions / Heading Auto Identifiers\n");
+            TestParser.TestSpec("[This is a heading]\n# This is a heading", "<p><a href=\"#this-is-a-heading\">This is a heading</a></p>\n<h1 id=\"this-is-a-heading\">This is a heading</h1>", "autoidentifiers|advanced");
         }
 
         // The text of the link can be changed:
@@ -187,7 +196,8 @@ namespace Markdig.Tests.Specs.AutoIdentifiers
             //     <p><a href="#this-is-a-heading">With a new text</a></p>
             //     <h1 id="this-is-a-heading">This is a heading</h1>
 
-            TestParser.TestSpec("[With a new text][This is a heading]\n# This is a heading", "<p><a href=\"#this-is-a-heading\">With a new text</a></p>\n<h1 id=\"this-is-a-heading\">This is a heading</h1>", "autoidentifiers|advanced", context: "Example 10\nSection Extensions / Heading Auto Identifiers\n");
+            Console.WriteLine("Example 10\nSection Extensions / Heading Auto Identifiers\n");
+            TestParser.TestSpec("[With a new text][This is a heading]\n# This is a heading", "<p><a href=\"#this-is-a-heading\">With a new text</a></p>\n<h1 id=\"this-is-a-heading\">This is a heading</h1>", "autoidentifiers|advanced");
         }
 
         // An autoidentifier should not conflict with an existing link:
@@ -206,7 +216,8 @@ namespace Markdig.Tests.Specs.AutoIdentifiers
             //     <p><img src="./scenario.png" alt="scenario image" /></p>
             //     <h2 id="scenario">Scenario</h2>
 
-            TestParser.TestSpec("![scenario image][scenario]\n## Scenario\n[scenario]: ./scenario.png", "<p><img src=\"./scenario.png\" alt=\"scenario image\" /></p>\n<h2 id=\"scenario\">Scenario</h2>", "autoidentifiers|advanced", context: "Example 11\nSection Extensions / Heading Auto Identifiers\n");
+            Console.WriteLine("Example 11\nSection Extensions / Heading Auto Identifiers\n");
+            TestParser.TestSpec("![scenario image][scenario]\n## Scenario\n[scenario]: ./scenario.png", "<p><img src=\"./scenario.png\" alt=\"scenario image\" /></p>\n<h2 id=\"scenario\">Scenario</h2>", "autoidentifiers|advanced");
         }
     }
 }

src/Markdig.Tests/Specs/AutoLinks.generated.cs

@@ -44,7 +44,8 @@ namespace Markdig.Tests.Specs.AutoLinks
             //     And a <a href="tel:+1555123456">+1555123456</a>
             //     And a plain <a href="http://www.google.com">www.google.com</a></p>
 
-            TestParser.TestSpec("This is a http://www.google.com URL and https://www.google.com\nThis is a ftp://test.com\nAnd a mailto:email@toto.com\nAnd a tel:+1555123456\nAnd a plain www.google.com", "<p>This is a <a href=\"http://www.google.com\">http://www.google.com</a> URL and <a href=\"https://www.google.com\">https://www.google.com</a>\nThis is a <a href=\"ftp://test.com\">ftp://test.com</a>\nAnd a <a href=\"mailto:email@toto.com\">email@toto.com</a>\nAnd a <a href=\"tel:+1555123456\">+1555123456</a>\nAnd a plain <a href=\"http://www.google.com\">www.google.com</a></p>", "autolinks|advanced", context: "Example 1\nSection Extensions / AutoLinks\n");
+            Console.WriteLine("Example 1\nSection Extensions / AutoLinks\n");
+            TestParser.TestSpec("This is a http://www.google.com URL and https://www.google.com\nThis is a ftp://test.com\nAnd a mailto:email@toto.com\nAnd a tel:+1555123456\nAnd a plain www.google.com", "<p>This is a <a href=\"http://www.google.com\">http://www.google.com</a> URL and <a href=\"https://www.google.com\">https://www.google.com</a>\nThis is a <a href=\"ftp://test.com\">ftp://test.com</a>\nAnd a <a href=\"mailto:email@toto.com\">email@toto.com</a>\nAnd a <a href=\"tel:+1555123456\">+1555123456</a>\nAnd a plain <a href=\"http://www.google.com\">www.google.com</a></p>", "autolinks|advanced");
         }
 
         // But incomplete links will not be matched:
@@ -68,7 +69,8 @@ namespace Markdig.Tests.Specs.AutoLinks
             //     And not a plain www. or a www.x
             //     And not a tel:</p>
 
-            TestParser.TestSpec("This is not a http:/www.google.com URL and https:/www.google.com\nThis is not a ftp:/test.com\nAnd not a mailto:emailtoto.com\nAnd not a plain www. or a www.x \nAnd not a tel:", "<p>This is not a http:/www.google.com URL and https:/www.google.com\nThis is not a ftp:/test.com\nAnd not a mailto:emailtoto.com\nAnd not a plain www. or a www.x\nAnd not a tel:</p>", "autolinks|advanced", context: "Example 2\nSection Extensions / AutoLinks\n");
+            Console.WriteLine("Example 2\nSection Extensions / AutoLinks\n");
+            TestParser.TestSpec("This is not a http:/www.google.com URL and https:/www.google.com\nThis is not a ftp:/test.com\nAnd not a mailto:emailtoto.com\nAnd not a plain www. or a www.x \nAnd not a tel:", "<p>This is not a http:/www.google.com URL and https:/www.google.com\nThis is not a ftp:/test.com\nAnd not a mailto:emailtoto.com\nAnd not a plain www. or a www.x\nAnd not a tel:</p>", "autolinks|advanced");
         }
 
         // Previous character must be a punctuation or a valid space (tab, space, new line):
@@ -84,7 +86,8 @@ namespace Markdig.Tests.Specs.AutoLinks
             // Should be rendered as:
             //     <p>This is not a nhttp://www.google.com URL but this is (<a href="https://www.google.com">https://www.google.com</a>)</p>
 
-            TestParser.TestSpec("This is not a nhttp://www.google.com URL but this is (https://www.google.com)", "<p>This is not a nhttp://www.google.com URL but this is (<a href=\"https://www.google.com\">https://www.google.com</a>)</p>", "autolinks|advanced", context: "Example 3\nSection Extensions / AutoLinks\n");
+            Console.WriteLine("Example 3\nSection Extensions / AutoLinks\n");
+            TestParser.TestSpec("This is not a nhttp://www.google.com URL but this is (https://www.google.com)", "<p>This is not a nhttp://www.google.com URL but this is (<a href=\"https://www.google.com\">https://www.google.com</a>)</p>", "autolinks|advanced");
         }
 
         // An autolink should not interfere with an `<a>` HTML inline:
@@ -100,7 +103,8 @@ namespace Markdig.Tests.Specs.AutoLinks
             // Should be rendered as:
             //     <p>This is an HTML <a href="http://www.google.com">http://www.google.com</a> link</p>
 
-            TestParser.TestSpec("This is an HTML <a href=\"http://www.google.com\">http://www.google.com</a> link", "<p>This is an HTML <a href=\"http://www.google.com\">http://www.google.com</a> link</p>", "autolinks|advanced", context: "Example 4\nSection Extensions / AutoLinks\n");
+            Console.WriteLine("Example 4\nSection Extensions / AutoLinks\n");
+            TestParser.TestSpec("This is an HTML <a href=\"http://www.google.com\">http://www.google.com</a> link", "<p>This is an HTML <a href=\"http://www.google.com\">http://www.google.com</a> link</p>", "autolinks|advanced");
         }
 
         // or even within emphasis:
@@ -116,7 +120,8 @@ namespace Markdig.Tests.Specs.AutoLinks
             // Should be rendered as:
             //     <p>This is an HTML <a href="http://www.google.com"> <strong>http://www.google.com</strong> </a> link</p>
 
-            TestParser.TestSpec("This is an HTML <a href=\"http://www.google.com\"> **http://www.google.com** </a> link", "<p>This is an HTML <a href=\"http://www.google.com\"> <strong>http://www.google.com</strong> </a> link</p>", "autolinks|advanced", context: "Example 5\nSection Extensions / AutoLinks\n");
+            Console.WriteLine("Example 5\nSection Extensions / AutoLinks\n");
+            TestParser.TestSpec("This is an HTML <a href=\"http://www.google.com\"> **http://www.google.com** </a> link", "<p>This is an HTML <a href=\"http://www.google.com\"> <strong>http://www.google.com</strong> </a> link</p>", "autolinks|advanced");
         }
 
         // An autolink should not interfere with a markdown link:
@@ -132,7 +137,8 @@ namespace Markdig.Tests.Specs.AutoLinks
             // Should be rendered as:
             //     <p>This is an HTML <a href="http://www.google.com">http://www.google.com</a> link</p>
 
-            TestParser.TestSpec("This is an HTML [http://www.google.com](http://www.google.com) link", "<p>This is an HTML <a href=\"http://www.google.com\">http://www.google.com</a> link</p>", "autolinks|advanced", context: "Example 6\nSection Extensions / AutoLinks\n");
+            Console.WriteLine("Example 6\nSection Extensions / AutoLinks\n");
+            TestParser.TestSpec("This is an HTML [http://www.google.com](http://www.google.com) link", "<p>This is an HTML <a href=\"http://www.google.com\">http://www.google.com</a> link</p>", "autolinks|advanced");
         }
 
         // A link embraced by pending emphasis should let the emphasis takes precedence if characters are placed at the end of the matched link:
@@ -148,7 +154,8 @@ namespace Markdig.Tests.Specs.AutoLinks
             // Should be rendered as:
             //     <p>Check <strong><a href="http://www.a.com">http://www.a.com</a></strong> or <strong><a href="http://www.b.com">http://www.b.com</a></strong></p>
 
-            TestParser.TestSpec("Check **http://www.a.com** or __http://www.b.com__", "<p>Check <strong><a href=\"http://www.a.com\">http://www.a.com</a></strong> or <strong><a href=\"http://www.b.com\">http://www.b.com</a></strong></p>", "autolinks|advanced", context: "Example 7\nSection Extensions / AutoLinks\n");
+            Console.WriteLine("Example 7\nSection Extensions / AutoLinks\n");
+            TestParser.TestSpec("Check **http://www.a.com** or __http://www.b.com__", "<p>Check <strong><a href=\"http://www.a.com\">http://www.a.com</a></strong> or <strong><a href=\"http://www.b.com\">http://www.b.com</a></strong></p>", "autolinks|advanced");
         }
 
         // It is not mentioned by the spec, but empty emails won't be matched (only a subset of [RFC2368](https://tools.ietf.org/html/rfc2368) is supported by auto links):
@@ -164,7 +171,8 @@ namespace Markdig.Tests.Specs.AutoLinks
             // Should be rendered as:
             //     <p><a href="mailto:email@test.com">email@test.com</a> is okay, but mailto:@test.com is not</p>
 
-            TestParser.TestSpec("mailto:email@test.com is okay, but mailto:@test.com is not", "<p><a href=\"mailto:email@test.com\">email@test.com</a> is okay, but mailto:@test.com is not</p>", "autolinks|advanced", context: "Example 8\nSection Extensions / AutoLinks\n");
+            Console.WriteLine("Example 8\nSection Extensions / AutoLinks\n");
+            TestParser.TestSpec("mailto:email@test.com is okay, but mailto:@test.com is not", "<p><a href=\"mailto:email@test.com\">email@test.com</a> is okay, but mailto:@test.com is not</p>", "autolinks|advanced");
         }
     }
 
@@ -186,7 +194,8 @@ namespace Markdig.Tests.Specs.AutoLinks
             // Should be rendered as:
             //     <p><a href="http://www.commonmark.org">www.commonmark.org</a></p>
 
-            TestParser.TestSpec("www.commonmark.org", "<p><a href=\"http://www.commonmark.org\">www.commonmark.org</a></p>", "autolinks|advanced", context: "Example 9\nSection Extensions / AutoLinks / GFM Support\n");
+            Console.WriteLine("Example 9\nSection Extensions / AutoLinks / GFM Support\n");
+            TestParser.TestSpec("www.commonmark.org", "<p><a href=\"http://www.commonmark.org\">www.commonmark.org</a></p>", "autolinks|advanced");
         }
 
         [Test]
@@ -201,7 +210,8 @@ namespace Markdig.Tests.Specs.AutoLinks
             // Should be rendered as:
             //     <p>Visit <a href="http://www.commonmark.org/help">www.commonmark.org/help</a> for more information.</p>
 
-            TestParser.TestSpec("Visit www.commonmark.org/help for more information.", "<p>Visit <a href=\"http://www.commonmark.org/help\">www.commonmark.org/help</a> for more information.</p>", "autolinks|advanced", context: "Example 10\nSection Extensions / AutoLinks / GFM Support\n");
+            Console.WriteLine("Example 10\nSection Extensions / AutoLinks / GFM Support\n");
+            TestParser.TestSpec("Visit www.commonmark.org/help for more information.", "<p>Visit <a href=\"http://www.commonmark.org/help\">www.commonmark.org/help</a> for more information.</p>", "autolinks|advanced");
         }
 
         [Test]
@@ -219,7 +229,8 @@ namespace Markdig.Tests.Specs.AutoLinks
             //     <p>Visit <a href="http://www.commonmark.org">www.commonmark.org</a>.</p>
             //     <p>Visit <a href="http://www.commonmark.org/a.b">www.commonmark.org/a.b</a>.</p>
 
-            TestParser.TestSpec("Visit www.commonmark.org.\n\nVisit www.commonmark.org/a.b.", "<p>Visit <a href=\"http://www.commonmark.org\">www.commonmark.org</a>.</p>\n<p>Visit <a href=\"http://www.commonmark.org/a.b\">www.commonmark.org/a.b</a>.</p>", "autolinks|advanced", context: "Example 11\nSection Extensions / AutoLinks / GFM Support\n");
+            Console.WriteLine("Example 11\nSection Extensions / AutoLinks / GFM Support\n");
+            TestParser.TestSpec("Visit www.commonmark.org.\n\nVisit www.commonmark.org/a.b.", "<p>Visit <a href=\"http://www.commonmark.org\">www.commonmark.org</a>.</p>\n<p>Visit <a href=\"http://www.commonmark.org/a.b\">www.commonmark.org/a.b</a>.</p>", "autolinks|advanced");
         }
 
         [Test]
@@ -237,7 +248,8 @@ namespace Markdig.Tests.Specs.AutoLinks
             //     <p><a href="http://www.google.com/search?q=Markup+(business)">www.google.com/search?q=Markup+(business)</a></p>
             //     <p>(<a href="http://www.google.com/search?q=Markup+(business)">www.google.com/search?q=Markup+(business)</a>)</p>
 
-            TestParser.TestSpec("www.google.com/search?q=Markup+(business)\n\n(www.google.com/search?q=Markup+(business))", "<p><a href=\"http://www.google.com/search?q=Markup+(business)\">www.google.com/search?q=Markup+(business)</a></p>\n<p>(<a href=\"http://www.google.com/search?q=Markup+(business)\">www.google.com/search?q=Markup+(business)</a>)</p>", "autolinks|advanced", context: "Example 12\nSection Extensions / AutoLinks / GFM Support\n");
+            Console.WriteLine("Example 12\nSection Extensions / AutoLinks / GFM Support\n");
+            TestParser.TestSpec("www.google.com/search?q=Markup+(business)\n\n(www.google.com/search?q=Markup+(business))", "<p><a href=\"http://www.google.com/search?q=Markup+(business)\">www.google.com/search?q=Markup+(business)</a></p>\n<p>(<a href=\"http://www.google.com/search?q=Markup+(business)\">www.google.com/search?q=Markup+(business)</a>)</p>", "autolinks|advanced");
         }
 
         [Test]
@@ -255,7 +267,8 @@ namespace Markdig.Tests.Specs.AutoLinks
             //     <p><a href="http://www.google.com/search?q=commonmark&amp;hl=en">www.google.com/search?q=commonmark&amp;hl=en</a></p>
             //     <p><a href="http://www.google.com/search?q=commonmark">www.google.com/search?q=commonmark</a>&amp;hl;</p>
 
-            TestParser.TestSpec("www.google.com/search?q=commonmark&hl=en\n\nwww.google.com/search?q=commonmark&hl;", "<p><a href=\"http://www.google.com/search?q=commonmark&amp;hl=en\">www.google.com/search?q=commonmark&amp;hl=en</a></p>\n<p><a href=\"http://www.google.com/search?q=commonmark\">www.google.com/search?q=commonmark</a>&amp;hl;</p>", "autolinks|advanced", context: "Example 13\nSection Extensions / AutoLinks / GFM Support\n");
+            Console.WriteLine("Example 13\nSection Extensions / AutoLinks / GFM Support\n");
+            TestParser.TestSpec("www.google.com/search?q=commonmark&hl=en\n\nwww.google.com/search?q=commonmark&hl;", "<p><a href=\"http://www.google.com/search?q=commonmark&amp;hl=en\">www.google.com/search?q=commonmark&amp;hl=en</a></p>\n<p><a href=\"http://www.google.com/search?q=commonmark\">www.google.com/search?q=commonmark</a>&amp;hl;</p>", "autolinks|advanced");
         }
 
         [Test]
@@ -270,7 +283,8 @@ namespace Markdig.Tests.Specs.AutoLinks
             // Should be rendered as:
             //     <p><a href="http://www.commonmark.org/he">www.commonmark.org/he</a>&lt;lp</p>
 
-            TestParser.TestSpec("www.commonmark.org/he<lp", "<p><a href=\"http://www.commonmark.org/he\">www.commonmark.org/he</a>&lt;lp</p>", "autolinks|advanced", context: "Example 14\nSection Extensions / AutoLinks / GFM Support\n");
+            Console.WriteLine("Example 14\nSection Extensions / AutoLinks / GFM Support\n");
+            TestParser.TestSpec("www.commonmark.org/he<lp", "<p><a href=\"http://www.commonmark.org/he\">www.commonmark.org/he</a>&lt;lp</p>", "autolinks|advanced");
         }
 
         [Test]
@@ -291,7 +305,8 @@ namespace Markdig.Tests.Specs.AutoLinks
             //     <p>(Visit <a href="https://encrypted.google.com/search?q=Markup+(business)">https://encrypted.google.com/search?q=Markup+(business)</a>)</p>
             //     <p>Anonymous FTP is available at <a href="ftp://foo.bar.baz">ftp://foo.bar.baz</a>.</p>
 
-            TestParser.TestSpec("http://commonmark.org\n\n(Visit https://encrypted.google.com/search?q=Markup+(business))\n\nAnonymous FTP is available at ftp://foo.bar.baz.", "<p><a href=\"http://commonmark.org\">http://commonmark.org</a></p>\n<p>(Visit <a href=\"https://encrypted.google.com/search?q=Markup+(business)\">https://encrypted.google.com/search?q=Markup+(business)</a>)</p>\n<p>Anonymous FTP is available at <a href=\"ftp://foo.bar.baz\">ftp://foo.bar.baz</a>.</p>", "autolinks|advanced", context: "Example 15\nSection Extensions / AutoLinks / GFM Support\n");
+            Console.WriteLine("Example 15\nSection Extensions / AutoLinks / GFM Support\n");
+            TestParser.TestSpec("http://commonmark.org\n\n(Visit https://encrypted.google.com/search?q=Markup+(business))\n\nAnonymous FTP is available at ftp://foo.bar.baz.", "<p><a href=\"http://commonmark.org\">http://commonmark.org</a></p>\n<p>(Visit <a href=\"https://encrypted.google.com/search?q=Markup+(business)\">https://encrypted.google.com/search?q=Markup+(business)</a>)</p>\n<p>Anonymous FTP is available at <a href=\"ftp://foo.bar.baz\">ftp://foo.bar.baz</a>.</p>", "autolinks|advanced");
         }
     }
 
@@ -331,7 +346,8 @@ namespace Markdig.Tests.Specs.AutoLinks
             //     mailto:email@test.
             //     mailto:email@.test</p>
 
-            TestParser.TestSpec("www..\nwww..com\nhttp://test.\nhttp://.test\nhttp://.\nhttp://..\nftp://test.\nftp://.test\nmailto:email@test.\nmailto:email@.test", "<p>www..\nwww..com\nhttp://test.\nhttp://.test\nhttp://.\nhttp://..\nftp://test.\nftp://.test\nmailto:email@test.\nmailto:email@.test</p>", "autolinks|advanced", context: "Example 16\nSection Extensions / AutoLinks / Valid Domain Tests\n");
+            Console.WriteLine("Example 16\nSection Extensions / AutoLinks / Valid Domain Tests\n");
+            TestParser.TestSpec("www..\nwww..com\nhttp://test.\nhttp://.test\nhttp://.\nhttp://..\nftp://test.\nftp://.test\nmailto:email@test.\nmailto:email@.test", "<p>www..\nwww..com\nhttp://test.\nhttp://.test\nhttp://.\nhttp://..\nftp://test.\nftp://.test\nmailto:email@test.\nmailto:email@.test</p>", "autolinks|advanced");
         }
 
         // Domain names with too few segments won't be matched
@@ -355,7 +371,8 @@ namespace Markdig.Tests.Specs.AutoLinks
             //     ftp://test
             //     mailto:email@test</p>
 
-            TestParser.TestSpec("www\nwww.com\nhttp://test\nftp://test\nmailto:email@test", "<p>www\nwww.com\nhttp://test\nftp://test\nmailto:email@test</p>", "autolinks|advanced", context: "Example 17\nSection Extensions / AutoLinks / Valid Domain Tests\n");
+            Console.WriteLine("Example 17\nSection Extensions / AutoLinks / Valid Domain Tests\n");
+            TestParser.TestSpec("www\nwww.com\nhttp://test\nftp://test\nmailto:email@test", "<p>www\nwww.com\nhttp://test\nftp://test\nmailto:email@test</p>", "autolinks|advanced");
         }
 
         // Domain names that contain an underscores in the last two segments won't be matched
@@ -383,7 +400,8 @@ namespace Markdig.Tests.Specs.AutoLinks
             //     <p><a href="ftp://test_.foo.bar">ftp://test_.foo.bar</a> is okay, but ftp://test.fo_o is not</p>
             //     <p><a href="mailto:email@_test.foo.bar">email@_test.foo.bar</a> is okay, but mailto:email@_test.foo is not</p>
 
-            TestParser.TestSpec("www._test.foo.bar is okay, but www._test.foo is not\n\nhttp://te_st.foo.bar is okay, as is http://test.foo_.bar.foo\n\nBut http://te_st.foo, http://test.foo_.bar and http://test._foo are not\n\nftp://test_.foo.bar is okay, but ftp://test.fo_o is not\n\nmailto:email@_test.foo.bar is okay, but mailto:email@_test.foo is not", "<p><a href=\"http://www._test.foo.bar\">www._test.foo.bar</a> is okay, but www._test.foo is not</p>\n<p><a href=\"http://te_st.foo.bar\">http://te_st.foo.bar</a> is okay, as is <a href=\"http://test.foo_.bar.foo\">http://test.foo_.bar.foo</a></p>\n<p>But http://te_st.foo, http://test.foo_.bar and http://test._foo are not</p>\n<p><a href=\"ftp://test_.foo.bar\">ftp://test_.foo.bar</a> is okay, but ftp://test.fo_o is not</p>\n<p><a href=\"mailto:email@_test.foo.bar\">email@_test.foo.bar</a> is okay, but mailto:email@_test.foo is not</p>", "autolinks|advanced", context: "Example 18\nSection Extensions / AutoLinks / Valid Domain Tests\n");
+            Console.WriteLine("Example 18\nSection Extensions / AutoLinks / Valid Domain Tests\n");
+            TestParser.TestSpec("www._test.foo.bar is okay, but www._test.foo is not\n\nhttp://te_st.foo.bar is okay, as is http://test.foo_.bar.foo\n\nBut http://te_st.foo, http://test.foo_.bar and http://test._foo are not\n\nftp://test_.foo.bar is okay, but ftp://test.fo_o is not\n\nmailto:email@_test.foo.bar is okay, but mailto:email@_test.foo is not", "<p><a href=\"http://www._test.foo.bar\">www._test.foo.bar</a> is okay, but www._test.foo is not</p>\n<p><a href=\"http://te_st.foo.bar\">http://te_st.foo.bar</a> is okay, as is <a href=\"http://test.foo_.bar.foo\">http://test.foo_.bar.foo</a></p>\n<p>But http://te_st.foo, http://test.foo_.bar and http://test._foo are not</p>\n<p><a href=\"ftp://test_.foo.bar\">ftp://test_.foo.bar</a> is okay, but ftp://test.fo_o is not</p>\n<p><a href=\"mailto:email@_test.foo.bar\">email@_test.foo.bar</a> is okay, but mailto:email@_test.foo is not</p>", "autolinks|advanced");
         }
 
         // Domain names that contain invalid characters (not AlphaNumberic, -, _ or .) won't be matched
@@ -399,7 +417,8 @@ namespace Markdig.Tests.Specs.AutoLinks
             // Should be rendered as:
             //     <p>https://[your-domain]/api</p>
 
-            TestParser.TestSpec("https://[your-domain]/api", "<p>https://[your-domain]/api</p>", "autolinks|advanced", context: "Example 19\nSection Extensions / AutoLinks / Valid Domain Tests\n");
+            Console.WriteLine("Example 19\nSection Extensions / AutoLinks / Valid Domain Tests\n");
+            TestParser.TestSpec("https://[your-domain]/api", "<p>https://[your-domain]/api</p>", "autolinks|advanced");
         }
 
         // Domain names followed by ?, : or # instead of / are matched
@@ -427,7 +446,8 @@ namespace Markdig.Tests.Specs.AutoLinks
             //     <p><a href="https://github.com">https://github.com</a>:</p>
             //     <p><a href="https://github.com:443">https://github.com:443</a></p>
 
-            TestParser.TestSpec("https://github.com?\n\nhttps://github.com?a\n\nhttps://github.com#a\n\nhttps://github.com:\n\nhttps://github.com:443", "<p><a href=\"https://github.com\">https://github.com</a>?</p>\n<p><a href=\"https://github.com?a\">https://github.com?a</a></p>\n<p><a href=\"https://github.com#a\">https://github.com#a</a></p>\n<p><a href=\"https://github.com\">https://github.com</a>:</p>\n<p><a href=\"https://github.com:443\">https://github.com:443</a></p>", "autolinks|advanced", context: "Example 20\nSection Extensions / AutoLinks / Valid Domain Tests\n");
+            Console.WriteLine("Example 20\nSection Extensions / AutoLinks / Valid Domain Tests\n");
+            TestParser.TestSpec("https://github.com?\n\nhttps://github.com?a\n\nhttps://github.com#a\n\nhttps://github.com:\n\nhttps://github.com:443", "<p><a href=\"https://github.com\">https://github.com</a>?</p>\n<p><a href=\"https://github.com?a\">https://github.com?a</a></p>\n<p><a href=\"https://github.com#a\">https://github.com#a</a></p>\n<p><a href=\"https://github.com\">https://github.com</a>:</p>\n<p><a href=\"https://github.com:443\">https://github.com:443</a></p>", "autolinks|advanced");
         }
     }
 
@@ -458,7 +478,8 @@ namespace Markdig.Tests.Specs.AutoLinks
             //     <p><a href="http://abc.net#%E2%98%83">http://abc.net#☃</a></p>
             //     <p><a href="http://abc.net/foo#%E2%98%83">http://abc.net/foo#☃</a></p>
 
-            TestParser.TestSpec("http://abc.net/☃\n\nhttp://abc.net?☃\n\nhttp://abc.net#☃\n\nhttp://abc.net/foo#☃", "<p><a href=\"http://abc.net/%E2%98%83\">http://abc.net/☃</a></p>\n<p><a href=\"http://abc.net?%E2%98%83\">http://abc.net?☃</a></p>\n<p><a href=\"http://abc.net#%E2%98%83\">http://abc.net#☃</a></p>\n<p><a href=\"http://abc.net/foo#%E2%98%83\">http://abc.net/foo#☃</a></p>", "autolinks|advanced", context: "Example 21\nSection Extensions / AutoLinks / Unicode support\n");
+            Console.WriteLine("Example 21\nSection Extensions / AutoLinks / Unicode support\n");
+            TestParser.TestSpec("http://abc.net/☃\n\nhttp://abc.net?☃\n\nhttp://abc.net#☃\n\nhttp://abc.net/foo#☃", "<p><a href=\"http://abc.net/%E2%98%83\">http://abc.net/☃</a></p>\n<p><a href=\"http://abc.net?%E2%98%83\">http://abc.net?☃</a></p>\n<p><a href=\"http://abc.net#%E2%98%83\">http://abc.net#☃</a></p>\n<p><a href=\"http://abc.net/foo#%E2%98%83\">http://abc.net/foo#☃</a></p>", "autolinks|advanced");
         }
 
         // Unicode characters in the FQDN are matched and IDNA encoded
@@ -474,7 +495,8 @@ namespace Markdig.Tests.Specs.AutoLinks
             // Should be rendered as:
             //     <p><a href="http://xn--n3h.net?%E2%98%83">http://☃.net?☃</a></p>
 
-            TestParser.TestSpec("http://☃.net?☃", "<p><a href=\"http://xn--n3h.net?%E2%98%83\">http://☃.net?☃</a></p>", "autolinks|advanced", context: "Example 22\nSection Extensions / AutoLinks / Unicode support\n");
+            Console.WriteLine("Example 22\nSection Extensions / AutoLinks / Unicode support\n");
+            TestParser.TestSpec("http://☃.net?☃", "<p><a href=\"http://xn--n3h.net?%E2%98%83\">http://☃.net?☃</a></p>", "autolinks|advanced");
         }
 
         // Same goes for regular autolinks
@@ -499,7 +521,8 @@ namespace Markdig.Tests.Specs.AutoLinks
             //     <p><a href="http://abc.net#%E2%98%83">http://abc.net#☃</a></p>
             //     <p><a href="http://abc.net/foo#%E2%98%83">http://abc.net/foo#☃</a></p>
 
-            TestParser.TestSpec("<http://abc.net/☃>\n\n<http://abc.net?☃>\n\n<http://abc.net#☃>\n\n<http://abc.net/foo#☃>", "<p><a href=\"http://abc.net/%E2%98%83\">http://abc.net/☃</a></p>\n<p><a href=\"http://abc.net?%E2%98%83\">http://abc.net?☃</a></p>\n<p><a href=\"http://abc.net#%E2%98%83\">http://abc.net#☃</a></p>\n<p><a href=\"http://abc.net/foo#%E2%98%83\">http://abc.net/foo#☃</a></p>", "autolinks|advanced", context: "Example 23\nSection Extensions / AutoLinks / Unicode support\n");
+            Console.WriteLine("Example 23\nSection Extensions / AutoLinks / Unicode support\n");
+            TestParser.TestSpec("<http://abc.net/☃>\n\n<http://abc.net?☃>\n\n<http://abc.net#☃>\n\n<http://abc.net/foo#☃>", "<p><a href=\"http://abc.net/%E2%98%83\">http://abc.net/☃</a></p>\n<p><a href=\"http://abc.net?%E2%98%83\">http://abc.net?☃</a></p>\n<p><a href=\"http://abc.net#%E2%98%83\">http://abc.net#☃</a></p>\n<p><a href=\"http://abc.net/foo#%E2%98%83\">http://abc.net/foo#☃</a></p>", "autolinks|advanced");
         }
 
         [Test]
@@ -514,7 +537,8 @@ namespace Markdig.Tests.Specs.AutoLinks
             // Should be rendered as:
             //     <p><a href="http://xn--n3h.net?%E2%98%83">http://☃.net?☃</a></p>
 
-            TestParser.TestSpec("<http://☃.net?☃>", "<p><a href=\"http://xn--n3h.net?%E2%98%83\">http://☃.net?☃</a></p>", "autolinks|advanced", context: "Example 24\nSection Extensions / AutoLinks / Unicode support\n");
+            Console.WriteLine("Example 24\nSection Extensions / AutoLinks / Unicode support\n");
+            TestParser.TestSpec("<http://☃.net?☃>", "<p><a href=\"http://xn--n3h.net?%E2%98%83\">http://☃.net?☃</a></p>", "autolinks|advanced");
         }
 
         // It also complies with CommonMark's vision of priority.
@@ -531,30 +555,8 @@ namespace Markdig.Tests.Specs.AutoLinks
             // Should be rendered as:
             //     <p><a href="http://xn--fo-gka.bar.%60baz">http://foö.bar.`baz</a>`</p>
 
-            TestParser.TestSpec("<http://foö.bar.`baz>`", "<p><a href=\"http://xn--fo-gka.bar.%60baz\">http://foö.bar.`baz</a>`</p>", "autolinks|advanced", context: "Example 25\nSection Extensions / AutoLinks / Unicode support\n");
-        }
-
-        // Unicode punctuation characters are not allowed, but symbols are.
-        // Note that this does _not_ exactly match CommonMark's "Unicode punctuation character" definition.
-        [Test]
-        public void ExtensionsAutoLinksUnicodeSupport_Example026()
-        {
-            // Example 26
-            // Section: Extensions / AutoLinks / Unicode support
-            //
-            // The following Markdown:
-            //     http://☃.net?☃ // OtherSymbol
-            //     
-            //     http://🍉.net?🍉 // A UTF-16 surrogate pair, but code point is OtherSymbol
-            //     
-            //     http://‰.net?‰ // OtherPunctuation
-            //
-            // Should be rendered as:
-            //     <p><a href="http://xn--n3h.net?%E2%98%83">http://☃.net?☃</a> // OtherSymbol</p>
-            //     <p><a href="http://xn--ji8h.net?%F0%9F%8D%89">http://🍉.net?🍉</a> // A UTF-16 surrogate pair, but code point is OtherSymbol</p>
-            //     <p>http://‰.net?‰ // OtherPunctuation</p>
-
-            TestParser.TestSpec("http://☃.net?☃ // OtherSymbol\n\nhttp://🍉.net?🍉 // A UTF-16 surrogate pair, but code point is OtherSymbol\n\nhttp://‰.net?‰ // OtherPunctuation", "<p><a href=\"http://xn--n3h.net?%E2%98%83\">http://☃.net?☃</a> // OtherSymbol</p>\n<p><a href=\"http://xn--ji8h.net?%F0%9F%8D%89\">http://🍉.net?🍉</a> // A UTF-16 surrogate pair, but code point is OtherSymbol</p>\n<p>http://‰.net?‰ // OtherPunctuation</p>", "autolinks|advanced", context: "Example 26\nSection Extensions / AutoLinks / Unicode support\n");
+            Console.WriteLine("Example 25\nSection Extensions / AutoLinks / Unicode support\n");
+            TestParser.TestSpec("<http://foö.bar.`baz>`", "<p><a href=\"http://xn--fo-gka.bar.%60baz\">http://foö.bar.`baz</a>`</p>", "autolinks|advanced");
         }
     }
 }

src/Markdig.Tests/Specs/AutoLinks.md

@@ -303,19 +303,4 @@ This will therefore be seen as an autolink and not as code inline.
 <http://foö.bar.`baz>`
 .
 <p><a href="http://xn--fo-gka.bar.%60baz">http://foö.bar.`baz</a>`</p>
-````````````````````````````````
-
-Unicode punctuation characters are not allowed, but symbols are.
-Note that this does _not_ exactly match CommonMark's "Unicode punctuation character" definition.
-
-```````````````````````````````` example
-http://☃.net?☃ // OtherSymbol
-
-http://🍉.net?🍉 // A UTF-16 surrogate pair, but code point is OtherSymbol
-
-http://‰.net?‰ // OtherPunctuation
-.
-<p><a href="http://xn--n3h.net?%E2%98%83">http://☃.net?☃</a> // OtherSymbol</p>
-<p><a href="http://xn--ji8h.net?%F0%9F%8D%89">http://🍉.net?🍉</a> // A UTF-16 surrogate pair, but code point is OtherSymbol</p>
-<p>http://‰.net?‰ // OtherPunctuation</p>
 ````````````````````````````````

src/Markdig.Tests/Specs/BootstrapSpecs.generated.cs

@@ -45,7 +45,8 @@ namespace Markdig.Tests.Specs.Bootstrap
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec("Name | Value\n-----| -----\nAbc  | 16", "<table class=\"table\">\n<thead>\n<tr>\n<th>Name</th>\n<th>Value</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Abc</td>\n<td>16</td>\n</tr>\n</tbody>\n</table>", "bootstrap+pipetables+figures+attributes", context: "Example 1\nSection Extensions / Bootstrap\n");
+            Console.WriteLine("Example 1\nSection Extensions / Bootstrap\n");
+            TestParser.TestSpec("Name | Value\n-----| -----\nAbc  | 16", "<table class=\"table\">\n<thead>\n<tr>\n<th>Name</th>\n<th>Value</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Abc</td>\n<td>16</td>\n</tr>\n</tbody>\n</table>", "bootstrap+pipetables+figures+attributes");
         }
 
         // Adds bootstrap `.blockquote` class to `<blockquote>`:
@@ -63,7 +64,8 @@ namespace Markdig.Tests.Specs.Bootstrap
             //     <p>This is a blockquote</p>
             //     </blockquote>
 
-            TestParser.TestSpec("> This is a blockquote", "<blockquote class=\"blockquote\">\n<p>This is a blockquote</p>\n</blockquote>", "bootstrap+pipetables+figures+attributes", context: "Example 2\nSection Extensions / Bootstrap\n");
+            Console.WriteLine("Example 2\nSection Extensions / Bootstrap\n");
+            TestParser.TestSpec("> This is a blockquote", "<blockquote class=\"blockquote\">\n<p>This is a blockquote</p>\n</blockquote>", "bootstrap+pipetables+figures+attributes");
         }
 
         // Adds bootstrap `.figure` class to `<figure>` and `.figure-caption` to `<figcaption>`
@@ -84,7 +86,8 @@ namespace Markdig.Tests.Specs.Bootstrap
             //     <figcaption class="figure-caption">This is the caption</figcaption>
             //     </figure>
 
-            TestParser.TestSpec("^^^\nThis is a text in a caption\n^^^ This is the caption", "<figure class=\"figure\">\n<p>This is a text in a caption</p>\n<figcaption class=\"figure-caption\">This is the caption</figcaption>\n</figure>", "bootstrap+pipetables+figures+attributes", context: "Example 3\nSection Extensions / Bootstrap\n");
+            Console.WriteLine("Example 3\nSection Extensions / Bootstrap\n");
+            TestParser.TestSpec("^^^\nThis is a text in a caption\n^^^ This is the caption", "<figure class=\"figure\">\n<p>This is a text in a caption</p>\n<figcaption class=\"figure-caption\">This is the caption</figcaption>\n</figure>", "bootstrap+pipetables+figures+attributes");
         }
 
         // Adds the `.img-fluid` class to all image links `<img>`
@@ -100,7 +103,8 @@ namespace Markdig.Tests.Specs.Bootstrap
             // Should be rendered as:
             //     <p><img src="/url" class="img-fluid" alt="Image Link" /></p>
 
-            TestParser.TestSpec("![Image Link](/url)", "<p><img src=\"/url\" class=\"img-fluid\" alt=\"Image Link\" /></p>", "bootstrap+pipetables+figures+attributes", context: "Example 4\nSection Extensions / Bootstrap\n");
+            Console.WriteLine("Example 4\nSection Extensions / Bootstrap\n");
+            TestParser.TestSpec("![Image Link](/url)", "<p><img src=\"/url\" class=\"img-fluid\" alt=\"Image Link\" /></p>", "bootstrap+pipetables+figures+attributes");
         }
     }
 }

src/Markdig.Tests/Specs/CustomContainerSpecs.generated.cs

@@ -33,7 +33,8 @@ namespace Markdig.Tests.Specs.CustomContainers
             //     <div class="spoiler"><p>This is a <em>spoiler</em></p>
             //     </div>
 
-            TestParser.TestSpec(":::spoiler\nThis is a *spoiler*\n:::", "<div class=\"spoiler\"><p>This is a <em>spoiler</em></p>\n</div>", "customcontainers+attributes|advanced", context: "Example 1\nSection Extensions / Custom Container\n");
+            Console.WriteLine("Example 1\nSection Extensions / Custom Container\n");
+            TestParser.TestSpec(":::spoiler\nThis is a *spoiler*\n:::", "<div class=\"spoiler\"><p>This is a <em>spoiler</em></p>\n</div>", "customcontainers+attributes|advanced");
         }
 
         // The text following the opened custom container is optional:
@@ -52,7 +53,8 @@ namespace Markdig.Tests.Specs.CustomContainers
             //     <div><p>This is a regular div</p>
             //     </div>
 
-            TestParser.TestSpec(":::\nThis is a regular div\n:::", "<div><p>This is a regular div</p>\n</div>", "customcontainers+attributes|advanced", context: "Example 2\nSection Extensions / Custom Container\n");
+            Console.WriteLine("Example 2\nSection Extensions / Custom Container\n");
+            TestParser.TestSpec(":::\nThis is a regular div\n:::", "<div><p>This is a regular div</p>\n</div>", "customcontainers+attributes|advanced");
         }
 
         // Like for fenced code block, you can use more than 3 `:` characters as long as the closing has the same number of characters:
@@ -71,7 +73,8 @@ namespace Markdig.Tests.Specs.CustomContainers
             //     <div class="spoiler"><p>This is a spoiler</p>
             //     </div>
 
-            TestParser.TestSpec("::::::::::::spoiler\nThis is a spoiler\n::::::::::::", "<div class=\"spoiler\"><p>This is a spoiler</p>\n</div>", "customcontainers+attributes|advanced", context: "Example 3\nSection Extensions / Custom Container\n");
+            Console.WriteLine("Example 3\nSection Extensions / Custom Container\n");
+            TestParser.TestSpec("::::::::::::spoiler\nThis is a spoiler\n::::::::::::", "<div class=\"spoiler\"><p>This is a spoiler</p>\n</div>", "customcontainers+attributes|advanced");
         }
 
         // Like for fenced code block, a custom container can span over multiple empty lines in a list block:
@@ -103,7 +106,8 @@ namespace Markdig.Tests.Specs.CustomContainers
             //     <li>A second item in the list</li>
             //     </ul>
 
-            TestParser.TestSpec("- This is a list\n  :::spoiler\n  This is a spoiler\n  - item1\n  - item2\n  :::\n- A second item in the list", "<ul>\n<li>This is a list\n<div class=\"spoiler\">This is a spoiler\n<ul>\n<li>item1</li>\n<li>item2</li>\n</ul>\n</div>\n</li>\n<li>A second item in the list</li>\n</ul>", "customcontainers+attributes|advanced", context: "Example 4\nSection Extensions / Custom Container\n");
+            Console.WriteLine("Example 4\nSection Extensions / Custom Container\n");
+            TestParser.TestSpec("- This is a list\n  :::spoiler\n  This is a spoiler\n  - item1\n  - item2\n  :::\n- A second item in the list", "<ul>\n<li>This is a list\n<div class=\"spoiler\">This is a spoiler\n<ul>\n<li>item1</li>\n<li>item2</li>\n</ul>\n</div>\n</li>\n<li>A second item in the list</li>\n</ul>", "customcontainers+attributes|advanced");
         }
 
         // Attributes extension is also supported for Custom Container, as long as the Attributes extension is activated after the CustomContainer extension (`.UseCustomContainer().UseAttributes()`)
@@ -122,7 +126,8 @@ namespace Markdig.Tests.Specs.CustomContainers
             //     <div id="myspoiler" class="spoiler" myprop="yes"><p>This is a spoiler</p>
             //     </div>
 
-            TestParser.TestSpec(":::spoiler {#myspoiler myprop=yes}\nThis is a spoiler\n:::", "<div id=\"myspoiler\" class=\"spoiler\" myprop=\"yes\"><p>This is a spoiler</p>\n</div>", "customcontainers+attributes|advanced", context: "Example 5\nSection Extensions / Custom Container\n");
+            Console.WriteLine("Example 5\nSection Extensions / Custom Container\n");
+            TestParser.TestSpec(":::spoiler {#myspoiler myprop=yes}\nThis is a spoiler\n:::", "<div id=\"myspoiler\" class=\"spoiler\" myprop=\"yes\"><p>This is a spoiler</p>\n</div>", "customcontainers+attributes|advanced");
         }
 
         // The content of a custom container can contain any blocks:
@@ -141,7 +146,8 @@ namespace Markdig.Tests.Specs.CustomContainers
             //     <div class="mycontainer"><p>This is a raw spoiler</p>
             //     </div>
 
-            TestParser.TestSpec(":::mycontainer\n<p>This is a raw spoiler</p>\n:::", "<div class=\"mycontainer\"><p>This is a raw spoiler</p>\n</div>", "customcontainers+attributes|advanced", context: "Example 6\nSection Extensions / Custom Container\n");
+            Console.WriteLine("Example 6\nSection Extensions / Custom Container\n");
+            TestParser.TestSpec(":::mycontainer\n<p>This is a raw spoiler</p>\n:::", "<div class=\"mycontainer\"><p>This is a raw spoiler</p>\n</div>", "customcontainers+attributes|advanced");
         }
     }
 
@@ -163,7 +169,8 @@ namespace Markdig.Tests.Specs.CustomContainers
             // Should be rendered as:
             //     <p>This is a text <span>with special emphasis</span></p>
 
-            TestParser.TestSpec("This is a text ::with special emphasis::", "<p>This is a text <span>with special emphasis</span></p>", "customcontainers+attributes|advanced", context: "Example 7\nSection Extensions / Inline Custom Container \n");
+            Console.WriteLine("Example 7\nSection Extensions / Inline Custom Container \n");
+            TestParser.TestSpec("This is a text ::with special emphasis::", "<p>This is a text <span>with special emphasis</span></p>", "customcontainers+attributes|advanced");
         }
 
         // Any other emphasis inline can be used within this emphasis inline container:
@@ -179,7 +186,8 @@ namespace Markdig.Tests.Specs.CustomContainers
             // Should be rendered as:
             //     <p>This is a text <span>with special <em>emphasis</em></span></p>
 
-            TestParser.TestSpec("This is a text ::with special *emphasis*::", "<p>This is a text <span>with special <em>emphasis</em></span></p>", "customcontainers+attributes|advanced", context: "Example 8\nSection Extensions / Inline Custom Container \n");
+            Console.WriteLine("Example 8\nSection Extensions / Inline Custom Container \n");
+            TestParser.TestSpec("This is a text ::with special *emphasis*::", "<p>This is a text <span>with special <em>emphasis</em></span></p>", "customcontainers+attributes|advanced");
         }
 
         // Attributes can be attached to a inline custom container:
@@ -195,7 +203,8 @@ namespace Markdig.Tests.Specs.CustomContainers
             // Should be rendered as:
             //     <p>This is a text <span id="myId" class="myemphasis">with special emphasis</span></p>
 
-            TestParser.TestSpec("This is a text ::with special emphasis::{#myId .myemphasis}", "<p>This is a text <span id=\"myId\" class=\"myemphasis\">with special emphasis</span></p>", "customcontainers+attributes|advanced", context: "Example 9\nSection Extensions / Inline Custom Container \n");
+            Console.WriteLine("Example 9\nSection Extensions / Inline Custom Container \n");
+            TestParser.TestSpec("This is a text ::with special emphasis::{#myId .myemphasis}", "<p>This is a text <span id=\"myId\" class=\"myemphasis\">with special emphasis</span></p>", "customcontainers+attributes|advanced");
         }
     }
 }

src/Markdig.Tests/Specs/DefinitionListSpecs.generated.cs

@@ -71,7 +71,8 @@ namespace Markdig.Tests.Specs.DefinitionLists
             //     <dd>This is another definition for term2</dd>
             //     </dl>
 
-            TestParser.TestSpec("\nTerm 1\n:   This is a definition item\n    With a paragraph\n    > This is a block quote\n\n    - This is a list\n    - with an item2\n\n    ```java\n    Test\n\n\n    ```\n\n    And a last line\n:   This ia another definition item\n\nTerm2\nTerm3 *with some inline*\n:   This is another definition for term2", "<dl>\n<dt>Term 1</dt>\n<dd><p>This is a definition item\nWith a paragraph</p>\n<blockquote>\n<p>This is a block quote</p>\n</blockquote>\n<ul>\n<li>This is a list</li>\n<li>with an item2</li>\n</ul>\n<pre><code class=\"language-java\">Test\n\n\n</code></pre>\n<p>And a last line</p>\n</dd>\n<dd>This ia another definition item</dd>\n<dt>Term2</dt>\n<dt>Term3 <em>with some inline</em></dt>\n<dd>This is another definition for term2</dd>\n</dl>", "definitionlists+attributes|advanced", context: "Example 1\nSection Extensions / Definition lists\n");
+            Console.WriteLine("Example 1\nSection Extensions / Definition lists\n");
+            TestParser.TestSpec("\nTerm 1\n:   This is a definition item\n    With a paragraph\n    > This is a block quote\n\n    - This is a list\n    - with an item2\n\n    ```java\n    Test\n\n\n    ```\n\n    And a last line\n:   This ia another definition item\n\nTerm2\nTerm3 *with some inline*\n:   This is another definition for term2", "<dl>\n<dt>Term 1</dt>\n<dd><p>This is a definition item\nWith a paragraph</p>\n<blockquote>\n<p>This is a block quote</p>\n</blockquote>\n<ul>\n<li>This is a list</li>\n<li>with an item2</li>\n</ul>\n<pre><code class=\"language-java\">Test\n\n\n</code></pre>\n<p>And a last line</p>\n</dd>\n<dd>This ia another definition item</dd>\n<dt>Term2</dt>\n<dt>Term3 <em>with some inline</em></dt>\n<dd>This is another definition for term2</dd>\n</dl>", "definitionlists+attributes|advanced");
         }
 
         // A definition term can be followed at most by one blank line. Lazy continuations are supported for definitions:
@@ -98,7 +99,8 @@ namespace Markdig.Tests.Specs.DefinitionLists
             //     </dd>
             //     </dl>
 
-            TestParser.TestSpec("Term 1\n\n:   Definition\nwith lazy continuation.\n\n    Second paragraph of the definition.", "<dl>\n<dt>Term 1</dt>\n<dd><p>Definition\nwith lazy continuation.</p>\n<p>Second paragraph of the definition.</p>\n</dd>\n</dl>", "definitionlists+attributes|advanced", context: "Example 2\nSection Extensions / Definition lists\n");
+            Console.WriteLine("Example 2\nSection Extensions / Definition lists\n");
+            TestParser.TestSpec("Term 1\n\n:   Definition\nwith lazy continuation.\n\n    Second paragraph of the definition.", "<dl>\n<dt>Term 1</dt>\n<dd><p>Definition\nwith lazy continuation.</p>\n<p>Second paragraph of the definition.</p>\n</dd>\n</dl>", "definitionlists+attributes|advanced");
         }
 
         // The definition must be indented to 4 characters including the `:`. 
@@ -116,7 +118,8 @@ namespace Markdig.Tests.Specs.DefinitionLists
             //     <p>Term 1
             //     :  Invalid with less than 3 characters</p>
 
-            TestParser.TestSpec("Term 1\n:  Invalid with less than 3 characters", "<p>Term 1\n:  Invalid with less than 3 characters</p>", "definitionlists+attributes|advanced", context: "Example 3\nSection Extensions / Definition lists\n");
+            Console.WriteLine("Example 3\nSection Extensions / Definition lists\n");
+            TestParser.TestSpec("Term 1\n:  Invalid with less than 3 characters", "<p>Term 1\n:  Invalid with less than 3 characters</p>", "definitionlists+attributes|advanced");
         }
 
         // The `:` can be indented up to 3 spaces:
@@ -136,7 +139,8 @@ namespace Markdig.Tests.Specs.DefinitionLists
             //     <dd>Valid even if <code>:</code> starts at most 3 spaces</dd>
             //     </dl>
 
-            TestParser.TestSpec("Term 1\n   : Valid even if `:` starts at most 3 spaces", "<dl>\n<dt>Term 1</dt>\n<dd>Valid even if <code>:</code> starts at most 3 spaces</dd>\n</dl>", "definitionlists+attributes|advanced", context: "Example 4\nSection Extensions / Definition lists\n");
+            Console.WriteLine("Example 4\nSection Extensions / Definition lists\n");
+            TestParser.TestSpec("Term 1\n   : Valid even if `:` starts at most 3 spaces", "<dl>\n<dt>Term 1</dt>\n<dd>Valid even if <code>:</code> starts at most 3 spaces</dd>\n</dl>", "definitionlists+attributes|advanced");
         }
 
         // But more than 3 spaces before `:` will trigger an indented code block:
@@ -156,7 +160,8 @@ namespace Markdig.Tests.Specs.DefinitionLists
             //     <pre><code>: Not valid
             //     </code></pre>
 
-            TestParser.TestSpec("Term 1\n\n    : Not valid", "<p>Term 1</p>\n<pre><code>: Not valid\n</code></pre>", "definitionlists+attributes|advanced", context: "Example 5\nSection Extensions / Definition lists\n");
+            Console.WriteLine("Example 5\nSection Extensions / Definition lists\n");
+            TestParser.TestSpec("Term 1\n\n    : Not valid", "<p>Term 1</p>\n<pre><code>: Not valid\n</code></pre>", "definitionlists+attributes|advanced");
         }
 
         // Definition lists can be nested inside list items
@@ -189,7 +194,8 @@ namespace Markdig.Tests.Specs.DefinitionLists
             //     </dl></li>
             //     </ol>
 
-            TestParser.TestSpec("1.  First\n    \n2.  Second\n    \n    Term 1\n    :   Definition\n    \n    Term 2\n    :   Second Definition", "<ol>\n<li><p>First</p></li>\n<li><p>Second</p>\n<dl>\n<dt>Term 1</dt>\n<dd>Definition</dd>\n<dt>Term 2</dt>\n<dd>Second Definition</dd>\n</dl></li>\n</ol>", "definitionlists+attributes|advanced", context: "Example 6\nSection Extensions / Definition lists\n");
+            Console.WriteLine("Example 6\nSection Extensions / Definition lists\n");
+            TestParser.TestSpec("1.  First\n    \n2.  Second\n    \n    Term 1\n    :   Definition\n    \n    Term 2\n    :   Second Definition", "<ol>\n<li><p>First</p></li>\n<li><p>Second</p>\n<dl>\n<dt>Term 1</dt>\n<dd>Definition</dd>\n<dt>Term 2</dt>\n<dd>Second Definition</dd>\n</dl></li>\n</ol>", "definitionlists+attributes|advanced");
         }
     }
 }

src/Markdig.Tests/Specs/DiagramsSpecs.generated.cs

@@ -17,7 +17,7 @@ namespace Markdig.Tests.Specs.Diagrams
         // 
         // ## Mermaid diagrams
         //  
-        // Using a fenced code block with the `mermaid` language info will output a `<pre class='mermaid'>` block (which is the default for other code block):
+        // Using a fenced code block with the `mermaid` language info will output a `<div class='mermaid'>` instead of a `pre/code` block:
         [Test]
         public void ExtensionsMermaidDiagrams_Example001()
         {
@@ -34,14 +34,15 @@ namespace Markdig.Tests.Specs.Diagrams
             //     ```
             //
             // Should be rendered as:
-            //     <pre class="mermaid">graph TD;
+            //     <div class="mermaid">graph TD;
             //         A-->B;
             //         A-->C;
             //         B-->D;
             //         C-->D;
-            //     </pre>
+            //     </div>
 
-            TestParser.TestSpec("```mermaid\ngraph TD;\n    A-->B;\n    A-->C;\n    B-->D;\n    C-->D;\n```", "<pre class=\"mermaid\">graph TD;\n    A-->B;\n    A-->C;\n    B-->D;\n    C-->D;\n</pre>", "diagrams|advanced", context: "Example 1\nSection Extensions / Mermaid diagrams\n");
+            Console.WriteLine("Example 1\nSection Extensions / Mermaid diagrams\n");
+            TestParser.TestSpec("```mermaid\ngraph TD;\n    A-->B;\n    A-->C;\n    B-->D;\n    C-->D;\n```", "<div class=\"mermaid\">graph TD;\n    A-->B;\n    A-->C;\n    B-->D;\n    C-->D;\n</div>", "diagrams|advanced");
         }
     }
 
@@ -84,7 +85,8 @@ namespace Markdig.Tests.Specs.Diagrams
             //     ]
             //     </div>
 
-            TestParser.TestSpec("```nomnoml\n[example|\n  propertyA: Int\n  propertyB: string\n|\n  methodA()\n  methodB()\n|\n  [subA]--[subB]\n  [subA]-:>[sub C]\n]\n```", "<div class=\"nomnoml\">[example|\n  propertyA: Int\n  propertyB: string\n|\n  methodA()\n  methodB()\n|\n  [subA]--[subB]\n  [subA]-:>[sub C]\n]\n</div>", "diagrams|advanced", context: "Example 2\nSection Extensions / nomnoml diagrams\n");
+            Console.WriteLine("Example 2\nSection Extensions / nomnoml diagrams\n");
+            TestParser.TestSpec("```nomnoml\n[example|\n  propertyA: Int\n  propertyB: string\n|\n  methodA()\n  methodB()\n|\n  [subA]--[subB]\n  [subA]-:>[sub C]\n]\n```", "<div class=\"nomnoml\">[example|\n  propertyA: Int\n  propertyB: string\n|\n  methodA()\n  methodB()\n|\n  [subA]--[subB]\n  [subA]-:>[sub C]\n]\n</div>", "diagrams|advanced");
         }
         // TODO: Add other text diagram languages
     }

src/Markdig.Tests/Specs/DiagramsSpecs.md

@@ -4,7 +4,7 @@ Adds support for diagrams extension:
 
 ## Mermaid diagrams
  
-Using a fenced code block with the `mermaid` language info will output a `<pre class='mermaid'>` block (which is the default for other code block):
+Using a fenced code block with the `mermaid` language info will output a `<div class='mermaid'>` instead of a `pre/code` block:
 
 ```````````````````````````````` example
 ```mermaid
@@ -15,12 +15,12 @@ graph TD;
     C-->D;
 ```
 .
-<pre class="mermaid">graph TD;
+<div class="mermaid">graph TD;
     A-->B;
     A-->C;
     B-->D;
     C-->D;
-</pre>
+</div>
 ````````````````````````````````
 
 ## nomnoml diagrams

src/Markdig.Tests/Specs/EmojiSpecs.generated.cs

@@ -30,7 +30,8 @@ namespace Markdig.Tests.Specs.Emoji
             // Should be rendered as:
             //     <p>This is a test with a 😃 and a 😠 smiley</p>
 
-            TestParser.TestSpec("This is a test with a :) and a :angry: smiley", "<p>This is a test with a 😃 and a 😠 smiley</p>", "emojis|advanced+emojis", context: "Example 1\nSection Extensions / Emoji\n");
+            Console.WriteLine("Example 1\nSection Extensions / Emoji\n");
+            TestParser.TestSpec("This is a test with a :) and a :angry: smiley", "<p>This is a test with a 😃 and a 😠 smiley</p>", "emojis|advanced+emojis");
         }
 
         // An emoji needs to be preceded by a space:
@@ -46,7 +47,8 @@ namespace Markdig.Tests.Specs.Emoji
             // Should be rendered as:
             //     <p>These are not:) an emoji with a:) x:angry:x</p>
 
-            TestParser.TestSpec("These are not:) an emoji with a:) x:angry:x", "<p>These are not:) an emoji with a:) x:angry:x</p>", "emojis|advanced+emojis", context: "Example 2\nSection Extensions / Emoji\n");
+            Console.WriteLine("Example 2\nSection Extensions / Emoji\n");
+            TestParser.TestSpec("These are not:) an emoji with a:) x:angry:x", "<p>These are not:) an emoji with a:) x:angry:x</p>", "emojis|advanced+emojis");
         }
 
         // Emojis can be followed by close punctuation (or any other characters):
@@ -62,7 +64,8 @@ namespace Markdig.Tests.Specs.Emoji
             // Should be rendered as:
             //     <p>We all need 😃, it makes us 💪. (and 👌).</p>
 
-            TestParser.TestSpec("We all need :), it makes us :muscle:. (and :ok_hand:).", "<p>We all need 😃, it makes us 💪. (and 👌).</p>", "emojis|advanced+emojis", context: "Example 3\nSection Extensions / Emoji\n");
+            Console.WriteLine("Example 3\nSection Extensions / Emoji\n");
+            TestParser.TestSpec("We all need :), it makes us :muscle:. (and :ok_hand:).", "<p>We all need 😃, it makes us 💪. (and 👌).</p>", "emojis|advanced+emojis");
         }
 
         // Sentences can end with emojis:
@@ -80,7 +83,8 @@ namespace Markdig.Tests.Specs.Emoji
             //     <p>This is a sentence 👌
             //     and keeps going to the next line 😃</p>
 
-            TestParser.TestSpec("This is a sentence :ok_hand:\nand keeps going to the next line :)", "<p>This is a sentence 👌\nand keeps going to the next line 😃</p>", "emojis|advanced+emojis", context: "Example 4\nSection Extensions / Emoji\n");
+            Console.WriteLine("Example 4\nSection Extensions / Emoji\n");
+            TestParser.TestSpec("This is a sentence :ok_hand:\nand keeps going to the next line :)", "<p>This is a sentence 👌\nand keeps going to the next line 😃</p>", "emojis|advanced+emojis");
         }
     }
 }

src/Markdig.Tests/Specs/EmphasisExtraSpecs.generated.cs

@@ -30,7 +30,8 @@ namespace Markdig.Tests.Specs.EmphasisExtra
             // Should be rendered as:
             //     <p>The following text <del>is deleted</del></p>
 
-            TestParser.TestSpec("The following text ~~is deleted~~", "<p>The following text <del>is deleted</del></p>", "emphasisextras|advanced", context: "Example 1\nSection Extensions / Strikethrough\n");
+            Console.WriteLine("Example 1\nSection Extensions / Strikethrough\n");
+            TestParser.TestSpec("The following text ~~is deleted~~", "<p>The following text <del>is deleted</del></p>", "emphasisextras|advanced");
         }
     }
 
@@ -52,7 +53,8 @@ namespace Markdig.Tests.Specs.EmphasisExtra
             // Should be rendered as:
             //     <p>H<sub>2</sub>O is a liquid. 2<sup>10</sup> is 1024</p>
 
-            TestParser.TestSpec("H~2~O is a liquid. 2^10^ is 1024", "<p>H<sub>2</sub>O is a liquid. 2<sup>10</sup> is 1024</p>", "emphasisextras|advanced", context: "Example 2\nSection Extensions / Superscript and Subscript\n");
+            Console.WriteLine("Example 2\nSection Extensions / Superscript and Subscript\n");
+            TestParser.TestSpec("H~2~O is a liquid. 2^10^ is 1024", "<p>H<sub>2</sub>O is a liquid. 2<sup>10</sup> is 1024</p>", "emphasisextras|advanced");
         }
 
         // Certain punctuation characters are exempted from the rule forbidding them within inline delimiters
@@ -71,7 +73,8 @@ namespace Markdig.Tests.Specs.EmphasisExtra
             //     <p>One quintillionth can be expressed as 10<sup>-18</sup></p>
             //     <p>Daggers<sup>†</sup> and double-daggers<sup>‡</sup> can be used to denote notes.</p>
 
-            TestParser.TestSpec("One quintillionth can be expressed as 10^-18^\n\nDaggers^†^ and double-daggers^‡^ can be used to denote notes.", "<p>One quintillionth can be expressed as 10<sup>-18</sup></p>\n<p>Daggers<sup>†</sup> and double-daggers<sup>‡</sup> can be used to denote notes.</p>", "emphasisextras|advanced", context: "Example 3\nSection Extensions / Superscript and Subscript\n");
+            Console.WriteLine("Example 3\nSection Extensions / Superscript and Subscript\n");
+            TestParser.TestSpec("One quintillionth can be expressed as 10^-18^\n\nDaggers^†^ and double-daggers^‡^ can be used to denote notes.", "<p>One quintillionth can be expressed as 10<sup>-18</sup></p>\n<p>Daggers<sup>†</sup> and double-daggers<sup>‡</sup> can be used to denote notes.</p>", "emphasisextras|advanced");
         }
     }
 
@@ -93,7 +96,8 @@ namespace Markdig.Tests.Specs.EmphasisExtra
             // Should be rendered as:
             //     <p><ins>Inserted text</ins></p>
 
-            TestParser.TestSpec("++Inserted text++", "<p><ins>Inserted text</ins></p>", "emphasisextras|advanced", context: "Example 4\nSection Extensions / Inserted\n");
+            Console.WriteLine("Example 4\nSection Extensions / Inserted\n");
+            TestParser.TestSpec("++Inserted text++", "<p><ins>Inserted text</ins></p>", "emphasisextras|advanced");
         }
     }
 
@@ -115,7 +119,8 @@ namespace Markdig.Tests.Specs.EmphasisExtra
             // Should be rendered as:
             //     <p><mark>Marked text</mark></p>
 
-            TestParser.TestSpec("==Marked text==", "<p><mark>Marked text</mark></p>", "emphasisextras|advanced", context: "Example 5\nSection Extensions / Marked\n");
+            Console.WriteLine("Example 5\nSection Extensions / Marked\n");
+            TestParser.TestSpec("==Marked text==", "<p><mark>Marked text</mark></p>", "emphasisextras|advanced");
         }
     }
 
@@ -123,8 +128,6 @@ namespace Markdig.Tests.Specs.EmphasisExtra
     public class TestExtensionsEmphasisOnHtmlEntities
     {
         // ## Emphasis on Html Entities
-        // 
-        // Note that Unicode symbols are treated as punctuation, which are not allowed to open the emphasis unless they are preceded by a space.
         [Test]
         public void ExtensionsEmphasisOnHtmlEntities_Example006()
         {
@@ -134,14 +137,15 @@ namespace Markdig.Tests.Specs.EmphasisExtra
             // The following Markdown:
             //     This is text MyBrand ^&reg;^ and MyTrademark ^&trade;^
             //     This is text MyBrand^&reg;^ and MyTrademark^&trade;^
-            //     This is text MyBrand ~&reg;~ and MyCopyright ^&copy;^
+            //     This is text MyBrand~&reg;~ and MyCopyright^&copy;^
             //
             // Should be rendered as:
             //     <p>This is text MyBrand <sup>®</sup> and MyTrademark <sup>TM</sup>
-            //     This is text MyBrand^®^ and MyTrademark^TM^
-            //     This is text MyBrand <sub>®</sub> and MyCopyright <sup>©</sup></p>
+            //     This is text MyBrand<sup>®</sup> and MyTrademark<sup>TM</sup>
+            //     This is text MyBrand<sub>®</sub> and MyCopyright<sup>©</sup></p>
 
-            TestParser.TestSpec("This is text MyBrand ^&reg;^ and MyTrademark ^&trade;^\nThis is text MyBrand^&reg;^ and MyTrademark^&trade;^\nThis is text MyBrand ~&reg;~ and MyCopyright ^&copy;^", "<p>This is text MyBrand <sup>®</sup> and MyTrademark <sup>TM</sup>\nThis is text MyBrand^®^ and MyTrademark^TM^\nThis is text MyBrand <sub>®</sub> and MyCopyright <sup>©</sup></p>", "emphasisextras|advanced", context: "Example 6\nSection Extensions / Emphasis on Html Entities\n");
+            Console.WriteLine("Example 6\nSection Extensions / Emphasis on Html Entities\n");
+            TestParser.TestSpec("This is text MyBrand ^&reg;^ and MyTrademark ^&trade;^\nThis is text MyBrand^&reg;^ and MyTrademark^&trade;^\nThis is text MyBrand~&reg;~ and MyCopyright^&copy;^", "<p>This is text MyBrand <sup>®</sup> and MyTrademark <sup>TM</sup>\nThis is text MyBrand<sup>®</sup> and MyTrademark<sup>TM</sup>\nThis is text MyBrand<sub>®</sub> and MyCopyright<sup>©</sup></p>", "emphasisextras|advanced");
         }
     }
 }

src/Markdig.Tests/Specs/EmphasisExtraSpecs.md

@@ -52,17 +52,16 @@ Marked text can be used to specify that a text has been marked in a document.  T
 .
 <p><mark>Marked text</mark></p>
 ````````````````````````````````
-
 ## Emphasis on Html Entities
 
-Note that Unicode symbols are treated as punctuation, which are not allowed to open the emphasis unless they are preceded by a space.
 
 ```````````````````````````````` example
 This is text MyBrand ^&reg;^ and MyTrademark ^&trade;^
 This is text MyBrand^&reg;^ and MyTrademark^&trade;^
-This is text MyBrand ~&reg;~ and MyCopyright ^&copy;^
+This is text MyBrand~&reg;~ and MyCopyright^&copy;^
 .
 <p>This is text MyBrand <sup>®</sup> and MyTrademark <sup>TM</sup>
-This is text MyBrand^®^ and MyTrademark^TM^
-This is text MyBrand <sub>®</sub> and MyCopyright <sup>©</sup></p>
+This is text MyBrand<sup>®</sup> and MyTrademark<sup>TM</sup>
+This is text MyBrand<sub>®</sub> and MyCopyright<sup>©</sup></p>
 ````````````````````````````````
+

src/Markdig.Tests/Specs/FigureFooterAndCiteSpecs.generated.cs

@@ -35,7 +35,8 @@ namespace Markdig.Tests.Specs.FiguresFootersAndCites
             //     <figcaption>This is a <em>caption</em></figcaption>
             //     </figure>
 
-            TestParser.TestSpec("^^^\nThis is a figure\n^^^ This is a *caption*", "<figure>\n<p>This is a figure</p>\n<figcaption>This is a <em>caption</em></figcaption>\n</figure>", "figures+footers+citations|advanced", context: "Example 1\nSection Extensions / Figures\n");
+            Console.WriteLine("Example 1\nSection Extensions / Figures\n");
+            TestParser.TestSpec("^^^\nThis is a figure\n^^^ This is a *caption*", "<figure>\n<p>This is a figure</p>\n<figcaption>This is a <em>caption</em></figcaption>\n</figure>", "figures+footers+citations|advanced");
         }
     }
 
@@ -59,7 +60,8 @@ namespace Markdig.Tests.Specs.FiguresFootersAndCites
             //     <footer>This is a footer
             //     multi-line</footer>
 
-            TestParser.TestSpec("^^ This is a footer\n^^ multi-line", "<footer>This is a footer\nmulti-line</footer>", "figures+footers+citations|advanced", context: "Example 2\nSection Extensions / Footers\n");
+            Console.WriteLine("Example 2\nSection Extensions / Footers\n");
+            TestParser.TestSpec("^^ This is a footer\n^^ multi-line", "<footer>This is a footer\nmulti-line</footer>", "figures+footers+citations|advanced");
         }
     }
 
@@ -81,7 +83,8 @@ namespace Markdig.Tests.Specs.FiguresFootersAndCites
             // Should be rendered as:
             //     <p>This is a <cite>citation of someone</cite></p>
 
-            TestParser.TestSpec("This is a \"\"citation of someone\"\"", "<p>This is a <cite>citation of someone</cite></p>", "figures+footers+citations|advanced", context: "Example 3\nSection Extensions / Cite\n");
+            Console.WriteLine("Example 3\nSection Extensions / Cite\n");
+            TestParser.TestSpec("This is a \"\"citation of someone\"\"", "<p>This is a <cite>citation of someone</cite></p>", "figures+footers+citations|advanced");
         }
     }
 }

src/Markdig.Tests/Specs/FootnotesSpecs.generated.cs

@@ -79,7 +79,8 @@ namespace Markdig.Tests.Specs.Footnotes
             //     </ol>
             //     </div>
 
-            TestParser.TestSpec("Here is a footnote reference,[^1] and another.[^longnote]\n\nThis is another reference to [^1]\n\n[^1]: Here is the footnote.\n\nAnd another reference to [^longnote]\n\n[^longnote]: Here's one with multiple blocks.\n\n    Subsequent paragraphs are indented to show that they\nbelong to the previous footnote.\n\n    > This is a block quote\n    > Inside a footnote\n\n        { some.code }\n\n    The whole paragraph can be indented, or just the first\n    line.  In this way, multi-paragraph footnotes work like\n    multi-paragraph list items.\n\nThis paragraph won't be part of the note, because it\nisn't indented.", "<p>Here is a footnote reference,<a id=\"fnref:1\" href=\"#fn:1\" class=\"footnote-ref\"><sup>1</sup></a> and another.<a id=\"fnref:3\" href=\"#fn:2\" class=\"footnote-ref\"><sup>2</sup></a></p>\n<p>This is another reference to <a id=\"fnref:2\" href=\"#fn:1\" class=\"footnote-ref\"><sup>1</sup></a></p>\n<p>And another reference to <a id=\"fnref:4\" href=\"#fn:2\" class=\"footnote-ref\"><sup>2</sup></a></p>\n<p>This paragraph won't be part of the note, because it\nisn't indented.</p>\n<div class=\"footnotes\">\n<hr />\n<ol>\n<li id=\"fn:1\">\n<p>Here is the footnote.<a href=\"#fnref:1\" class=\"footnote-back-ref\">&#8617;</a><a href=\"#fnref:2\" class=\"footnote-back-ref\">&#8617;</a></p>\n</li>\n<li id=\"fn:2\">\n<p>Here's one with multiple blocks.</p>\n<p>Subsequent paragraphs are indented to show that they\nbelong to the previous footnote.</p>\n<blockquote>\n<p>This is a block quote\nInside a footnote</p>\n</blockquote>\n<pre><code>{ some.code }\n</code></pre>\n<p>The whole paragraph can be indented, or just the first\nline.  In this way, multi-paragraph footnotes work like\nmulti-paragraph list items.<a href=\"#fnref:3\" class=\"footnote-back-ref\">&#8617;</a><a href=\"#fnref:4\" class=\"footnote-back-ref\">&#8617;</a></p>\n</li>\n</ol>\n</div>", "footnotes|advanced", context: "Example 1\nSection Extensions / Footnotes\n");
+            Console.WriteLine("Example 1\nSection Extensions / Footnotes\n");
+            TestParser.TestSpec("Here is a footnote reference,[^1] and another.[^longnote]\n\nThis is another reference to [^1]\n\n[^1]: Here is the footnote.\n\nAnd another reference to [^longnote]\n\n[^longnote]: Here's one with multiple blocks.\n\n    Subsequent paragraphs are indented to show that they\nbelong to the previous footnote.\n\n    > This is a block quote\n    > Inside a footnote\n\n        { some.code }\n\n    The whole paragraph can be indented, or just the first\n    line.  In this way, multi-paragraph footnotes work like\n    multi-paragraph list items.\n\nThis paragraph won't be part of the note, because it\nisn't indented.", "<p>Here is a footnote reference,<a id=\"fnref:1\" href=\"#fn:1\" class=\"footnote-ref\"><sup>1</sup></a> and another.<a id=\"fnref:3\" href=\"#fn:2\" class=\"footnote-ref\"><sup>2</sup></a></p>\n<p>This is another reference to <a id=\"fnref:2\" href=\"#fn:1\" class=\"footnote-ref\"><sup>1</sup></a></p>\n<p>And another reference to <a id=\"fnref:4\" href=\"#fn:2\" class=\"footnote-ref\"><sup>2</sup></a></p>\n<p>This paragraph won't be part of the note, because it\nisn't indented.</p>\n<div class=\"footnotes\">\n<hr />\n<ol>\n<li id=\"fn:1\">\n<p>Here is the footnote.<a href=\"#fnref:1\" class=\"footnote-back-ref\">&#8617;</a><a href=\"#fnref:2\" class=\"footnote-back-ref\">&#8617;</a></p>\n</li>\n<li id=\"fn:2\">\n<p>Here's one with multiple blocks.</p>\n<p>Subsequent paragraphs are indented to show that they\nbelong to the previous footnote.</p>\n<blockquote>\n<p>This is a block quote\nInside a footnote</p>\n</blockquote>\n<pre><code>{ some.code }\n</code></pre>\n<p>The whole paragraph can be indented, or just the first\nline.  In this way, multi-paragraph footnotes work like\nmulti-paragraph list items.<a href=\"#fnref:3\" class=\"footnote-back-ref\">&#8617;</a><a href=\"#fnref:4\" class=\"footnote-back-ref\">&#8617;</a></p>\n</li>\n</ol>\n</div>", "footnotes|advanced");
         }
 
         // Check with multiple consecutive footnotes:
@@ -119,7 +120,8 @@ namespace Markdig.Tests.Specs.Footnotes
             //     </ol>
             //     </div>
 
-            TestParser.TestSpec("Here is a footnote[^1]. And another one[^2]. And a third one[^3]. And a fourth[^4].\n\n[^1]: Footnote 1 text\n\n[^2]: Footnote 2 text\n\na\n\n[^3]: Footnote 3 text\n\n[^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>\n<p>a</p>\n<div class=\"footnotes\">\n<hr />\n<ol>\n<li id=\"fn:1\">\n<p>Footnote 1 text<a href=\"#fnref:1\" class=\"footnote-back-ref\">&#8617;</a></p></li>\n<li id=\"fn:2\">\n<p>Footnote 2 text<a href=\"#fnref:2\" class=\"footnote-back-ref\">&#8617;</a></p></li>\n<li id=\"fn:3\">\n<p>Footnote 3 text<a href=\"#fnref:3\" class=\"footnote-back-ref\">&#8617;</a></p></li>\n<li id=\"fn:4\">\n<p>Footnote 4 text<a href=\"#fnref:4\" class=\"footnote-back-ref\">&#8617;</a></p></li>\n</ol>\n</div>", "footnotes|advanced", context: "Example 2\nSection Extensions / Footnotes\n");
+            Console.WriteLine("Example 2\nSection Extensions / Footnotes\n");
+            TestParser.TestSpec("Here is a footnote[^1]. And another one[^2]. And a third one[^3]. And a fourth[^4].\n\n[^1]: Footnote 1 text\n\n[^2]: Footnote 2 text\n\na\n\n[^3]: Footnote 3 text\n\n[^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>\n<p>a</p>\n<div class=\"footnotes\">\n<hr />\n<ol>\n<li id=\"fn:1\">\n<p>Footnote 1 text<a href=\"#fnref:1\" class=\"footnote-back-ref\">&#8617;</a></p></li>\n<li id=\"fn:2\">\n<p>Footnote 2 text<a href=\"#fnref:2\" class=\"footnote-back-ref\">&#8617;</a></p></li>\n<li id=\"fn:3\">\n<p>Footnote 3 text<a href=\"#fnref:3\" class=\"footnote-back-ref\">&#8617;</a></p></li>\n<li id=\"fn:4\">\n<p>Footnote 4 text<a href=\"#fnref:4\" class=\"footnote-back-ref\">&#8617;</a></p></li>\n</ol>\n</div>", "footnotes|advanced");
         }
 
         // Another test with consecutive footnotes without a blank line separator:
@@ -153,7 +155,8 @@ namespace Markdig.Tests.Specs.Footnotes
             //     </ol>
             //     </div>
 
-            TestParser.TestSpec("Here is a footnote[^1]. And another one[^2]. And a third one[^3]. And a fourth[^4].\n\n[^1]: Footnote 1 text\n[^2]: Footnote 2 text\n[^3]: Footnote 3 text\n[^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>\n<div class=\"footnotes\">\n<hr />\n<ol>\n<li id=\"fn:1\">\n<p>Footnote 1 text<a href=\"#fnref:1\" class=\"footnote-back-ref\">&#8617;</a></p></li>\n<li id=\"fn:2\">\n<p>Footnote 2 text<a href=\"#fnref:2\" class=\"footnote-back-ref\">&#8617;</a></p></li>\n<li id=\"fn:3\">\n<p>Footnote 3 text<a href=\"#fnref:3\" class=\"footnote-back-ref\">&#8617;</a></p></li>\n<li id=\"fn:4\">\n<p>Footnote 4 text<a href=\"#fnref:4\" class=\"footnote-back-ref\">&#8617;</a></p></li>\n</ol>\n</div>", "footnotes|advanced", context: "Example 3\nSection Extensions / Footnotes\n");
+            Console.WriteLine("Example 3\nSection Extensions / Footnotes\n");
+            TestParser.TestSpec("Here is a footnote[^1]. And another one[^2]. And a third one[^3]. And a fourth[^4].\n\n[^1]: Footnote 1 text\n[^2]: Footnote 2 text\n[^3]: Footnote 3 text\n[^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>\n<div class=\"footnotes\">\n<hr />\n<ol>\n<li id=\"fn:1\">\n<p>Footnote 1 text<a href=\"#fnref:1\" class=\"footnote-back-ref\">&#8617;</a></p></li>\n<li id=\"fn:2\">\n<p>Footnote 2 text<a href=\"#fnref:2\" class=\"footnote-back-ref\">&#8617;</a></p></li>\n<li id=\"fn:3\">\n<p>Footnote 3 text<a href=\"#fnref:3\" class=\"footnote-back-ref\">&#8617;</a></p></li>\n<li id=\"fn:4\">\n<p>Footnote 4 text<a href=\"#fnref:4\" class=\"footnote-back-ref\">&#8617;</a></p></li>\n</ol>\n</div>", "footnotes|advanced");
         }
 
         // A footnote link inside a list should work as well:
@@ -182,7 +185,8 @@ namespace Markdig.Tests.Specs.Footnotes
             //     </ol>
             //     </div>
 
-            TestParser.TestSpec("- abc\n- def[^1]\n\n[^1]: Here is the footnote.", "<ul>\n<li>abc</li>\n<li>def<a id=\"fnref:1\" href=\"#fn:1\" class=\"footnote-ref\"><sup>1</sup></a></li>\n</ul>\n<div class=\"footnotes\">\n<hr />\n<ol>\n<li id=\"fn:1\">\n<p>Here is the footnote.<a href=\"#fnref:1\" class=\"footnote-back-ref\">&#8617;</a></p></li>\n</ol>\n</div>", "footnotes|advanced", context: "Example 4\nSection Extensions / Footnotes\n");
+            Console.WriteLine("Example 4\nSection Extensions / Footnotes\n");
+            TestParser.TestSpec("- abc\n- def[^1]\n\n[^1]: Here is the footnote.", "<ul>\n<li>abc</li>\n<li>def<a id=\"fnref:1\" href=\"#fn:1\" class=\"footnote-ref\"><sup>1</sup></a></li>\n</ul>\n<div class=\"footnotes\">\n<hr />\n<ol>\n<li id=\"fn:1\">\n<p>Here is the footnote.<a href=\"#fnref:1\" class=\"footnote-back-ref\">&#8617;</a></p></li>\n</ol>\n</div>", "footnotes|advanced");
         }
     }
 }

src/Markdig.Tests/Specs/GenericAttributesSpecs.generated.cs

@@ -54,7 +54,8 @@ namespace Markdig.Tests.Specs.GenericAttributes
             //     <h2 id="heading-link2">This is a heading</h2>
             //     <p id="myparagraph" attached-bool-property="" attached-bool-property2="">This is a paragraph with an attached attributes </p>
 
-            TestParser.TestSpec("# This is a heading with an an attribute{#heading-link}\n\n# This is a heading # {#heading-link2}\n\n[This is a link](http://google.com){#a-link .myclass data-lang=fr data-value=\"This is a value\"}\n\nThis is a heading{#heading-link2}\n-----------------\n\nThis is a paragraph with an attached attributes {#myparagraph attached-bool-property attached-bool-property2}", "<h1 id=\"heading-link\">This is a heading with an an attribute</h1>\n<h1 id=\"heading-link2\">This is a heading</h1>\n<p><a href=\"http://google.com\" id=\"a-link\" class=\"myclass\" data-lang=\"fr\" data-value=\"This is a value\">This is a link</a></p>\n<h2 id=\"heading-link2\">This is a heading</h2>\n<p id=\"myparagraph\" attached-bool-property=\"\" attached-bool-property2=\"\">This is a paragraph with an attached attributes </p>", "attributes|advanced", context: "Example 1\nSection Extensions / Generic Attributes\n");
+            Console.WriteLine("Example 1\nSection Extensions / Generic Attributes\n");
+            TestParser.TestSpec("# This is a heading with an an attribute{#heading-link}\n\n# This is a heading # {#heading-link2}\n\n[This is a link](http://google.com){#a-link .myclass data-lang=fr data-value=\"This is a value\"}\n\nThis is a heading{#heading-link2}\n-----------------\n\nThis is a paragraph with an attached attributes {#myparagraph attached-bool-property attached-bool-property2}", "<h1 id=\"heading-link\">This is a heading with an an attribute</h1>\n<h1 id=\"heading-link2\">This is a heading</h1>\n<p><a href=\"http://google.com\" id=\"a-link\" class=\"myclass\" data-lang=\"fr\" data-value=\"This is a value\">This is a link</a></p>\n<h2 id=\"heading-link2\">This is a heading</h2>\n<p id=\"myparagraph\" attached-bool-property=\"\" attached-bool-property2=\"\">This is a paragraph with an attached attributes </p>", "attributes|advanced");
         }
 
         // The following shows that attributes can be attached to the next block if they are used inside a single line just preceding the block (and preceded by a blank line or beginning of a block container):
@@ -74,7 +75,8 @@ namespace Markdig.Tests.Specs.GenericAttributes
             //     <pre><code id="fenced-id" class="fenced-class">This is a fenced with attached attributes
             //     </code></pre>
 
-            TestParser.TestSpec("{#fenced-id .fenced-class}\n~~~\nThis is a fenced with attached attributes\n~~~ ", "<pre><code id=\"fenced-id\" class=\"fenced-class\">This is a fenced with attached attributes\n</code></pre>", "attributes|advanced", context: "Example 2\nSection Extensions / Generic Attributes\n");
+            Console.WriteLine("Example 2\nSection Extensions / Generic Attributes\n");
+            TestParser.TestSpec("{#fenced-id .fenced-class}\n~~~\nThis is a fenced with attached attributes\n~~~ ", "<pre><code id=\"fenced-id\" class=\"fenced-class\">This is a fenced with attached attributes\n</code></pre>", "attributes|advanced");
         }
 
         // Attribute values can be one character long
@@ -96,24 +98,8 @@ namespace Markdig.Tests.Specs.GenericAttributes
             //     <p><a href="url" data-x="1">Foo</a></p>
             //     <p><a href="url" data-x="11">Foo</a></p>
 
-            TestParser.TestSpec("[Foo](url){data-x=1}\n\n[Foo](url){data-x='1'}\n\n[Foo](url){data-x=11}", "<p><a href=\"url\" data-x=\"1\">Foo</a></p>\n<p><a href=\"url\" data-x=\"1\">Foo</a></p>\n<p><a href=\"url\" data-x=\"11\">Foo</a></p>", "attributes|advanced", context: "Example 3\nSection Extensions / Generic Attributes\n");
-        }
-
-        // Attributes that occur immediately before a block element, on a line by themselves, affect that element
-        [Test]
-        public void ExtensionsGenericAttributes_Example004()
-        {
-            // Example 4
-            // Section: Extensions / Generic Attributes
-            //
-            // The following Markdown:
-            //     {.center}
-            //     A paragraph
-            //
-            // Should be rendered as:
-            //     <p class="center">A paragraph</p>
-
-            TestParser.TestSpec("{.center}\nA paragraph", "<p class=\"center\">A paragraph</p>", "attributes|advanced", context: "Example 4\nSection Extensions / Generic Attributes\n");
+            Console.WriteLine("Example 3\nSection Extensions / Generic Attributes\n");
+            TestParser.TestSpec("[Foo](url){data-x=1}\n\n[Foo](url){data-x='1'}\n\n[Foo](url){data-x=11}", "<p><a href=\"url\" data-x=\"1\">Foo</a></p>\n<p><a href=\"url\" data-x=\"1\">Foo</a></p>\n<p><a href=\"url\" data-x=\"11\">Foo</a></p>", "attributes|advanced");
         }
     }
 }

src/Markdig.Tests/Specs/GenericAttributesSpecs.md

@@ -61,12 +61,3 @@ Attribute values can be one character long
 <p><a href="url" data-x="1">Foo</a></p>
 <p><a href="url" data-x="11">Foo</a></p>
 ````````````````````````````````
-
-Attributes that occur immediately before a block element, on a line by themselves, affect that element
-
-```````````````````````````````` example
-{.center}
-A paragraph
-.
-<p class="center">A paragraph</p>
-````````````````````````````````

src/Markdig.Tests/Specs/GlobalizationSpecs.generated.cs

@@ -56,7 +56,8 @@ namespace Markdig.Tests.Specs.Globalization
             //     -- نەزانراو</p>
             //     </blockquote>
 
-            TestParser.TestSpec("# Fruits\nIn botany, a [fruit](https://en.wikipedia.org/wiki/Fruit) is the seed-bearing structure in flowering plants (also known as angiosperms) formed from the ovary after flowering.\n\n> Fruits are good for health\n-- Anonymous\n\n# میوە\n[میوە](https://ckb.wikipedia.org/wiki/%D9%85%DB%8C%D9%88%DB%95) یان مێوە بەروبوومی ڕوەکیە کە ڕوەکەکان ھەڵیان ئەگرن وەک بەرگێک بۆ تۆوەکانیان، بە زۆری جیادەکرێتەوە بە شیرینی یان ترشی لە تامدا و بە بوونی بڕێکی زۆر ئاو\n\n> میوە بۆ تەندروستی باشە\n-- نەزانراو", "<h1 id=\"fruits\">Fruits</h1>\n<p>In botany, a <a href=\"https://en.wikipedia.org/wiki/Fruit\">fruit</a> is the seed-bearing structure in flowering plants (also known as angiosperms) formed from the ovary after flowering.</p>\n<blockquote>\n<p>Fruits are good for health\n-- Anonymous</p>\n</blockquote>\n<h1 id=\"section\" dir=\"rtl\">میوە</h1>\n<p dir=\"rtl\"><a href=\"https://ckb.wikipedia.org/wiki/%D9%85%DB%8C%D9%88%DB%95\" dir=\"rtl\">میوە</a> یان مێوە بەروبوومی ڕوەکیە کە ڕوەکەکان ھەڵیان ئەگرن وەک بەرگێک بۆ تۆوەکانیان، بە زۆری جیادەکرێتەوە بە شیرینی یان ترشی لە تامدا و بە بوونی بڕێکی زۆر ئاو</p>\n<blockquote dir=\"rtl\">\n<p dir=\"rtl\">میوە بۆ تەندروستی باشە\n-- نەزانراو</p>\n</blockquote>", "globalization+advanced+emojis", context: "Example 1\nSection Extensions / Globalization\n");
+            Console.WriteLine("Example 1\nSection Extensions / Globalization\n");
+            TestParser.TestSpec("# Fruits\nIn botany, a [fruit](https://en.wikipedia.org/wiki/Fruit) is the seed-bearing structure in flowering plants (also known as angiosperms) formed from the ovary after flowering.\n\n> Fruits are good for health\n-- Anonymous\n\n# میوە\n[میوە](https://ckb.wikipedia.org/wiki/%D9%85%DB%8C%D9%88%DB%95) یان مێوە بەروبوومی ڕوەکیە کە ڕوەکەکان ھەڵیان ئەگرن وەک بەرگێک بۆ تۆوەکانیان، بە زۆری جیادەکرێتەوە بە شیرینی یان ترشی لە تامدا و بە بوونی بڕێکی زۆر ئاو\n\n> میوە بۆ تەندروستی باشە\n-- نەزانراو", "<h1 id=\"fruits\">Fruits</h1>\n<p>In botany, a <a href=\"https://en.wikipedia.org/wiki/Fruit\">fruit</a> is the seed-bearing structure in flowering plants (also known as angiosperms) formed from the ovary after flowering.</p>\n<blockquote>\n<p>Fruits are good for health\n-- Anonymous</p>\n</blockquote>\n<h1 id=\"section\" dir=\"rtl\">میوە</h1>\n<p dir=\"rtl\"><a href=\"https://ckb.wikipedia.org/wiki/%D9%85%DB%8C%D9%88%DB%95\" dir=\"rtl\">میوە</a> یان مێوە بەروبوومی ڕوەکیە کە ڕوەکەکان ھەڵیان ئەگرن وەک بەرگێک بۆ تۆوەکانیان، بە زۆری جیادەکرێتەوە بە شیرینی یان ترشی لە تامدا و بە بوونی بڕێکی زۆر ئاو</p>\n<blockquote dir=\"rtl\">\n<p dir=\"rtl\">میوە بۆ تەندروستی باشە\n-- نەزانراو</p>\n</blockquote>", "globalization+advanced+emojis");
         }
 
         // Lists:
@@ -159,7 +160,8 @@ namespace Markdig.Tests.Specs.Globalization
             //     <li class="task-list-item"><input disabled="disabled" type="checkbox" /> هەنجیر</li>
             //     </ul>
 
-            TestParser.TestSpec("## Types of fruits\n- Berries\n  - Strawberry\n  - kiwifruit\n- Citrus\n  - Orange\n  - Lemon\n\n## Examples of fruits :yum:\n1. Apple\n2. Banana\n3. Orange\n\n## Grocery List\n- [X] 􏿽 Watermelon\n- [X] Apricot\n- [ ] Fig \n\n## نموونەی میوە :yum:\n1. ? سێو\n2. 5 مۆز \n3. 􏿽 پرتەقاڵ\n\n## جۆرەکانی میوە\n- توو\n  - فڕاولە\n  - کیوی\n- مزرەمەنی\n  - پڕتەقاڵ\n  - لیمۆ\n\n## لیستی کڕین\n- [X] شووتی\n- [X] قەیسی\n- [ ] هەنجیر", "<h2 id=\"types-of-fruits\">Types of fruits</h2>\n<ul>\n<li>Berries\n<ul>\n<li>Strawberry</li>\n<li>kiwifruit</li>\n</ul>\n</li>\n<li>Citrus\n<ul>\n<li>Orange</li>\n<li>Lemon</li>\n</ul>\n</li>\n</ul>\n<h2 id=\"examples-of-fruits\">Examples of fruits 😋</h2>\n<ol>\n<li>Apple</li>\n<li>Banana</li>\n<li>Orange</li>\n</ol>\n<h2 id=\"grocery-list\">Grocery List</h2>\n<ul class=\"contains-task-list\">\n<li class=\"task-list-item\"><input disabled=\"disabled\" type=\"checkbox\" checked=\"checked\" /> 􏿽 Watermelon</li>\n<li class=\"task-list-item\"><input disabled=\"disabled\" type=\"checkbox\" checked=\"checked\" /> Apricot</li>\n<li class=\"task-list-item\"><input disabled=\"disabled\" type=\"checkbox\" /> Fig</li>\n</ul>\n<h2 id=\"section\" dir=\"rtl\">نموونەی میوە 😋</h2>\n<ol dir=\"rtl\">\n<li>? سێو</li>\n<li>5 مۆز</li>\n<li>􏿽 پرتەقاڵ</li>\n</ol>\n<h2 id=\"section-1\" dir=\"rtl\">جۆرەکانی میوە</h2>\n<ul dir=\"rtl\">\n<li>توو\n<ul dir=\"rtl\">\n<li>فڕاولە</li>\n<li>کیوی</li>\n</ul>\n</li>\n<li>مزرەمەنی\n<ul dir=\"rtl\">\n<li>پڕتەقاڵ</li>\n<li>لیمۆ</li>\n</ul>\n</li>\n</ul>\n<h2 id=\"section-2\" dir=\"rtl\">لیستی کڕین</h2>\n<ul class=\"contains-task-list\" dir=\"rtl\">\n<li class=\"task-list-item\"><input disabled=\"disabled\" type=\"checkbox\" checked=\"checked\" /> شووتی</li>\n<li class=\"task-list-item\"><input disabled=\"disabled\" type=\"checkbox\" checked=\"checked\" /> قەیسی</li>\n<li class=\"task-list-item\"><input disabled=\"disabled\" type=\"checkbox\" /> هەنجیر</li>\n</ul>", "globalization+advanced+emojis", context: "Example 2\nSection Extensions / Globalization\n");
+            Console.WriteLine("Example 2\nSection Extensions / Globalization\n");
+            TestParser.TestSpec("## Types of fruits\n- Berries\n  - Strawberry\n  - kiwifruit\n- Citrus\n  - Orange\n  - Lemon\n\n## Examples of fruits :yum:\n1. Apple\n2. Banana\n3. Orange\n\n## Grocery List\n- [X] 􏿽 Watermelon\n- [X] Apricot\n- [ ] Fig \n\n## نموونەی میوە :yum:\n1. ? سێو\n2. 5 مۆز \n3. 􏿽 پرتەقاڵ\n\n## جۆرەکانی میوە\n- توو\n  - فڕاولە\n  - کیوی\n- مزرەمەنی\n  - پڕتەقاڵ\n  - لیمۆ\n\n## لیستی کڕین\n- [X] شووتی\n- [X] قەیسی\n- [ ] هەنجیر", "<h2 id=\"types-of-fruits\">Types of fruits</h2>\n<ul>\n<li>Berries\n<ul>\n<li>Strawberry</li>\n<li>kiwifruit</li>\n</ul>\n</li>\n<li>Citrus\n<ul>\n<li>Orange</li>\n<li>Lemon</li>\n</ul>\n</li>\n</ul>\n<h2 id=\"examples-of-fruits\">Examples of fruits 😋</h2>\n<ol>\n<li>Apple</li>\n<li>Banana</li>\n<li>Orange</li>\n</ol>\n<h2 id=\"grocery-list\">Grocery List</h2>\n<ul class=\"contains-task-list\">\n<li class=\"task-list-item\"><input disabled=\"disabled\" type=\"checkbox\" checked=\"checked\" /> 􏿽 Watermelon</li>\n<li class=\"task-list-item\"><input disabled=\"disabled\" type=\"checkbox\" checked=\"checked\" /> Apricot</li>\n<li class=\"task-list-item\"><input disabled=\"disabled\" type=\"checkbox\" /> Fig</li>\n</ul>\n<h2 id=\"section\" dir=\"rtl\">نموونەی میوە 😋</h2>\n<ol dir=\"rtl\">\n<li>? سێو</li>\n<li>5 مۆز</li>\n<li>􏿽 پرتەقاڵ</li>\n</ol>\n<h2 id=\"section-1\" dir=\"rtl\">جۆرەکانی میوە</h2>\n<ul dir=\"rtl\">\n<li>توو\n<ul dir=\"rtl\">\n<li>فڕاولە</li>\n<li>کیوی</li>\n</ul>\n</li>\n<li>مزرەمەنی\n<ul dir=\"rtl\">\n<li>پڕتەقاڵ</li>\n<li>لیمۆ</li>\n</ul>\n</li>\n</ul>\n<h2 id=\"section-2\" dir=\"rtl\">لیستی کڕین</h2>\n<ul class=\"contains-task-list\" dir=\"rtl\">\n<li class=\"task-list-item\"><input disabled=\"disabled\" type=\"checkbox\" checked=\"checked\" /> شووتی</li>\n<li class=\"task-list-item\"><input disabled=\"disabled\" type=\"checkbox\" checked=\"checked\" /> قەیسی</li>\n<li class=\"task-list-item\"><input disabled=\"disabled\" type=\"checkbox\" /> هەنجیر</li>\n</ul>", "globalization+advanced+emojis");
         }
 
         // Tables:
@@ -224,29 +226,8 @@ namespace Markdig.Tests.Specs.Globalization
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec("Nutrition |Apple | Oranges\n--|-- | --\nCalories|52|47\nSugar|10g|9g\n\n پێکهاتە |سێو | پڕتەقاڵ\n--|-- | --\nکالۆری|٥٢|٤٧\nشەکر| ١٠گ|٩گ", "<table>\n<thead>\n<tr>\n<th>Nutrition</th>\n<th>Apple</th>\n<th>Oranges</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Calories</td>\n<td>52</td>\n<td>47</td>\n</tr>\n<tr>\n<td>Sugar</td>\n<td>10g</td>\n<td>9g</td>\n</tr>\n</tbody>\n</table>\n<table dir=\"rtl\" align=\"right\">\n<thead>\n<tr>\n<th>پێکهاتە</th>\n<th>سێو</th>\n<th>پڕتەقاڵ</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>کالۆری</td>\n<td>٥٢</td>\n<td>٤٧</td>\n</tr>\n<tr>\n<td>شەکر</td>\n<td>١٠گ</td>\n<td>٩گ</td>\n</tr>\n</tbody>\n</table>", "globalization+advanced+emojis", context: "Example 3\nSection Extensions / Globalization\n");
-        }
-
-        // But if text starts with LTR characters, no attributes are added.
-        [Test]
-        public void ExtensionsGlobalization_Example004()
-        {
-            // Example 4
-            // Section: Extensions / Globalization
-            //
-            // The following Markdown:
-            //     Foo میوە
-            //     
-            //     میوە bar
-            //     
-            //     Baz میوە
-            //
-            // Should be rendered as:
-            //     <p>Foo میوە</p>
-            //     <p dir="rtl">میوە bar</p>
-            //     <p>Baz میوە</p>
-
-            TestParser.TestSpec("Foo میوە\n\nمیوە bar\n\nBaz میوە", "<p>Foo میوە</p>\n<p dir=\"rtl\">میوە bar</p>\n<p>Baz میوە</p>", "globalization+advanced+emojis", context: "Example 4\nSection Extensions / Globalization\n");
+            Console.WriteLine("Example 3\nSection Extensions / Globalization\n");
+            TestParser.TestSpec("Nutrition |Apple | Oranges\n--|-- | --\nCalories|52|47\nSugar|10g|9g\n\n پێکهاتە |سێو | پڕتەقاڵ\n--|-- | --\nکالۆری|٥٢|٤٧\nشەکر| ١٠گ|٩گ", "<table>\n<thead>\n<tr>\n<th>Nutrition</th>\n<th>Apple</th>\n<th>Oranges</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Calories</td>\n<td>52</td>\n<td>47</td>\n</tr>\n<tr>\n<td>Sugar</td>\n<td>10g</td>\n<td>9g</td>\n</tr>\n</tbody>\n</table>\n<table dir=\"rtl\" align=\"right\">\n<thead>\n<tr>\n<th>پێکهاتە</th>\n<th>سێو</th>\n<th>پڕتەقاڵ</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>کالۆری</td>\n<td>٥٢</td>\n<td>٤٧</td>\n</tr>\n<tr>\n<td>شەکر</td>\n<td>١٠گ</td>\n<td>٩گ</td>\n</tr>\n</tbody>\n</table>", "globalization+advanced+emojis");
         }
     }
 }

src/Markdig.Tests/Specs/GlobalizationSpecs.md

@@ -186,18 +186,4 @@ Sugar|10g|9g
 </tr>
 </tbody>
 </table>
-````````````````````````````````
-
-But if text starts with LTR characters, no attributes are added.
-
-```````````````````````````````` example
-Foo میوە
-
-میوە bar
-
-Baz میوە
-.
-<p>Foo میوە</p>
-<p dir="rtl">میوە bar</p>
-<p>Baz میوە</p>
 ````````````````````````````````

src/Markdig.Tests/Specs/GridTableSpecs.generated.cs

@@ -17,8 +17,7 @@ namespace Markdig.Tests.Specs.GridTables
         // 
         // ## Grid Table
         // 
-        // A grid table allows having multiple lines per cells and allows spanning cells over multiple columns.
-        // The following shows a simple grid table:
+        // A grid table allows to have multiple lines per cells and allows to span cells over multiple columns. The following shows a simple grid table  
         // 
         // ```
         // +---------+---------+
@@ -39,20 +38,17 @@ namespace Markdig.Tests.Specs.GridTables
         // ```
         // 
         // **Rule #1**
-        // The first line of a grid table must be a **row separator**.
-        // It must start with the column separator character `+` used to separate columns in a row separator.
+        // The first line of a grid table must a **row separator**. It must start with the column separator character `+` used to separate columns in a row separator. Each column separator is:
+        //   - starting by optional spaces
+        //   - followed by an optional `:` to specify left align, followed by optional spaces
+        //   - followed by a sequence of at least one `-` character, followed by optional spaces
+        //   - followed by an optional `:` to specify right align (or center align if left align is also defined)
+        //   - ending by optional spaces
         // 
-        // Each column separator:
-        // - starts with optional spaces
-        // - followed by an optional `:` to specify left align, followed by optional spaces
-        // - followed by a sequence of one or more `-` characters, followed by optional spaces
-        // - followed by an optional `:` to specify right align (or center align if left align is also defined)
-        // - ends with optional spaces
+        // The first row separator must be followed by a *regular row*. A regular row must start with the character `|` that is starting at the same position than the column separator `+` of the first row separator.
         // 
-        // The first row separator must be followed by a *regular row*.
-        // A regular row must start with a `|` character starting at the same position as the column separator `+` of the first row separator.
         // 
-        // The following is a valid row separator:
+        // The following is a valid row separator 
         [Test]
         public void ExtensionsGridTable_Example001()
         {
@@ -75,10 +71,11 @@ namespace Markdig.Tests.Specs.GridTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec("+---------+---------+\n| This is | a table |", "<table>\n<col style=\"width:50%\" />\n<col style=\"width:50%\" />\n<tbody>\n<tr>\n<td>This is</td>\n<td>a table</td>\n</tr>\n</tbody>\n</table>", "gridtables|advanced", context: "Example 1\nSection Extensions / Grid Table\n");
+            Console.WriteLine("Example 1\nSection Extensions / Grid Table\n");
+            TestParser.TestSpec("+---------+---------+\n| This is | a table |", "<table>\n<col style=\"width:50%\" />\n<col style=\"width:50%\" />\n<tbody>\n<tr>\n<td>This is</td>\n<td>a table</td>\n</tr>\n</tbody>\n</table>", "gridtables|advanced");
         }
 
-        // The following is not a valid row separator:
+        // The following is not a valid row separator 
         [Test]
         public void ExtensionsGridTable_Example002()
         {
@@ -93,12 +90,12 @@ namespace Markdig.Tests.Specs.GridTables
             //     <p>|-----xxx----+---------+
             //     | This is    | not a table</p>
 
-            TestParser.TestSpec("|-----xxx----+---------+\n| This is    | not a table", "<p>|-----xxx----+---------+\n| This is    | not a table</p>", "gridtables|advanced", context: "Example 2\nSection Extensions / Grid Table\n");
+            Console.WriteLine("Example 2\nSection Extensions / Grid Table\n");
+            TestParser.TestSpec("|-----xxx----+---------+\n| This is    | not a table", "<p>|-----xxx----+---------+\n| This is    | not a table</p>", "gridtables|advanced");
         }
 
         // **Rule #2**
-        // A regular row can continue a previous regular row when the column separators `|` are positioned at the same position as those of the previous line.
-        // If they are positioned at the same location, the column may span over multiple columns:
+        // A regular row can continue a previous regular row when column separator `|` are positioned at the same  position than the previous line. If they are positioned at the same location, the column may span over multiple columns:
         [Test]
         public void ExtensionsGridTable_Example003()
         {
@@ -136,7 +133,8 @@ namespace Markdig.Tests.Specs.GridTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec("+---------+---------+---------+\n| Col1    | Col2    | Col3    |\n| Col1a   | Col2a   | Col3a   |\n| Col1b             | Col3b   |\n| Col1c                       |", "<table>\n<col style=\"width:33.33%\" />\n<col style=\"width:33.33%\" />\n<col style=\"width:33.33%\" />\n<tbody>\n<tr>\n<td>Col1\nCol1a</td>\n<td>Col2\nCol2a</td>\n<td>Col3\nCol3a</td>\n</tr>\n<tr>\n<td colspan=\"2\">Col1b</td>\n<td>Col3b</td>\n</tr>\n<tr>\n<td colspan=\"3\">Col1c</td>\n</tr>\n</tbody>\n</table>", "gridtables|advanced", context: "Example 3\nSection Extensions / Grid Table\n");
+            Console.WriteLine("Example 3\nSection Extensions / Grid Table\n");
+            TestParser.TestSpec("+---------+---------+---------+\n| Col1    | Col2    | Col3    |\n| Col1a   | Col2a   | Col3a   |\n| Col1b             | Col3b   |\n| Col1c                       |", "<table>\n<col style=\"width:33.33%\" />\n<col style=\"width:33.33%\" />\n<col style=\"width:33.33%\" />\n<tbody>\n<tr>\n<td>Col1\nCol1a</td>\n<td>Col2\nCol2a</td>\n<td>Col3\nCol3a</td>\n</tr>\n<tr>\n<td colspan=\"2\">Col1b</td>\n<td>Col3b</td>\n</tr>\n<tr>\n<td colspan=\"3\">Col1c</td>\n</tr>\n</tbody>\n</table>", "gridtables|advanced");
         }
 
         // A row header is separated using `+========+` instead of `+---------+`:
@@ -163,7 +161,8 @@ namespace Markdig.Tests.Specs.GridTables
             //     </thead>
             //     </table>
 
-            TestParser.TestSpec("+---------+---------+\n| This is | a table |\n+=========+=========+", "<table>\n<col style=\"width:50%\" />\n<col style=\"width:50%\" />\n<thead>\n<tr>\n<th>This is</th>\n<th>a table</th>\n</tr>\n</thead>\n</table>", "gridtables|advanced", context: "Example 4\nSection Extensions / Grid Table\n");
+            Console.WriteLine("Example 4\nSection Extensions / Grid Table\n");
+            TestParser.TestSpec("+---------+---------+\n| This is | a table |\n+=========+=========+", "<table>\n<col style=\"width:50%\" />\n<col style=\"width:50%\" />\n<thead>\n<tr>\n<th>This is</th>\n<th>a table</th>\n</tr>\n</thead>\n</table>", "gridtables|advanced");
         }
 
         // The last column separator `|` may be omitted:
@@ -189,16 +188,19 @@ namespace Markdig.Tests.Specs.GridTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec("+---------+---------+\n| This is | a table with a longer text in the second column", "<table>\n<col style=\"width:50%\" />\n<col style=\"width:50%\" />\n<tbody>\n<tr>\n<td>This is</td>\n<td>a table with a longer text in the second column</td>\n</tr>\n</tbody>\n</table>", "gridtables|advanced", context: "Example 5\nSection Extensions / Grid Table\n");
+            Console.WriteLine("Example 5\nSection Extensions / Grid Table\n");
+            TestParser.TestSpec("+---------+---------+\n| This is | a table with a longer text in the second column", "<table>\n<col style=\"width:50%\" />\n<col style=\"width:50%\" />\n<tbody>\n<tr>\n<td>This is</td>\n<td>a table with a longer text in the second column</td>\n</tr>\n</tbody>\n</table>", "gridtables|advanced");
         }
 
-        // The respective widths of the columns are calculated from the ratio between the total size of the first table row without counting the `+`: `+----+--------+----+` would be divided between:
+        // The respective width of the columns are calculated from the ratio between the total size of the first table row without counting the `+`: `+----+--------+----+` would be divided between:
         // 
-        // - `----` → 4 characters
-        // - `--------` → 8 characters
-        // - `----` → 4 characters
+        // Total size is : 16 
         // 
-        // The total size is 16 characters, so the widths would be 4/16 = 25%, 8/16 = 50%, and 4/16 = 25%.
+        // - `----` -> 4
+        // - `--------` -> 8
+        // - `----` -> 4
+        // 
+        // So the width would be 4/16 = 25%, 8/16 = 50%, 4/16 = 25%
         [Test]
         public void ExtensionsGridTable_Example006()
         {
@@ -224,7 +226,8 @@ namespace Markdig.Tests.Specs.GridTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec("+----+--------+----+\n| A  |  B C D | E  |\n+----+--------+----+", "<table>\n<col style=\"width:25%\" />\n<col style=\"width:50%\" />\n<col style=\"width:25%\" />\n<tbody>\n<tr>\n<td>A</td>\n<td>B C D</td>\n<td>E</td>\n</tr>\n</tbody>\n</table>", "gridtables|advanced", context: "Example 6\nSection Extensions / Grid Table\n");
+            Console.WriteLine("Example 6\nSection Extensions / Grid Table\n");
+            TestParser.TestSpec("+----+--------+----+\n| A  |  B C D | E  |\n+----+--------+----+", "<table>\n<col style=\"width:25%\" />\n<col style=\"width:50%\" />\n<col style=\"width:25%\" />\n<tbody>\n<tr>\n<td>A</td>\n<td>B C D</td>\n<td>E</td>\n</tr>\n</tbody>\n</table>", "gridtables|advanced");
         }
 
         // Alignment might be specified on the first row using the character `:`:
@@ -253,7 +256,8 @@ namespace Markdig.Tests.Specs.GridTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec("+-----+:---:+-----+\n|  A  |  B  |  C  |\n+-----+-----+-----+", "<table>\n<col style=\"width:33.33%\" />\n<col style=\"width:33.33%\" />\n<col style=\"width:33.33%\" />\n<tbody>\n<tr>\n<td>A</td>\n<td style=\"text-align: center;\">B</td>\n<td>C</td>\n</tr>\n</tbody>\n</table>", "gridtables|advanced", context: "Example 7\nSection Extensions / Grid Table\n");
+            Console.WriteLine("Example 7\nSection Extensions / Grid Table\n");
+            TestParser.TestSpec("+-----+:---:+-----+\n|  A  |  B  |  C  |\n+-----+-----+-----+", "<table>\n<col style=\"width:33.33%\" />\n<col style=\"width:33.33%\" />\n<col style=\"width:33.33%\" />\n<tbody>\n<tr>\n<td>A</td>\n<td style=\"text-align: center;\">B</td>\n<td>C</td>\n</tr>\n</tbody>\n</table>", "gridtables|advanced");
         }
 
         //  A grid table may have cells spanning both columns and rows:
@@ -296,10 +300,11 @@ namespace Markdig.Tests.Specs.GridTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec("+---+---+---+\n| AAAAA | B |\n+---+---+ B +\n| D | E | B |\n+ D +---+---+\n| D | CCCCC |\n+---+---+---+", "<table>\n<col style=\"width:33.33%\" />\n<col style=\"width:33.33%\" />\n<col style=\"width:33.33%\" />\n<tbody>\n<tr>\n<td colspan=\"2\">AAAAA</td>\n<td rowspan=\"2\">B\nB\nB</td>\n</tr>\n<tr>\n<td rowspan=\"2\">D\nD\nD</td>\n<td>E</td>\n</tr>\n<tr>\n<td colspan=\"2\">CCCCC</td>\n</tr>\n</tbody>\n</table>", "gridtables|advanced", context: "Example 8\nSection Extensions / Grid Table\n");
+            Console.WriteLine("Example 8\nSection Extensions / Grid Table\n");
+            TestParser.TestSpec("+---+---+---+\n| AAAAA | B |\n+---+---+ B +\n| D | E | B |\n+ D +---+---+\n| D | CCCCC |\n+---+---+---+", "<table>\n<col style=\"width:33.33%\" />\n<col style=\"width:33.33%\" />\n<col style=\"width:33.33%\" />\n<tbody>\n<tr>\n<td colspan=\"2\">AAAAA</td>\n<td rowspan=\"2\">B\nB\nB</td>\n</tr>\n<tr>\n<td rowspan=\"2\">D\nD\nD</td>\n<td>E</td>\n</tr>\n<tr>\n<td colspan=\"2\">CCCCC</td>\n</tr>\n</tbody>\n</table>", "gridtables|advanced");
         }
 
-        // A grid table may have cells with both `colspan` and `rowspan`:
+        // A grid table may have cells with both colspan and rowspan:
         [Test]
         public void ExtensionsGridTable_Example009()
         {
@@ -338,7 +343,8 @@ namespace Markdig.Tests.Specs.GridTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec("+---+---+---+\n| AAAAA | B |\n+ AAAAA +---+\n| AAAAA | C |\n+---+---+---+\n| D | E | F |\n+---+---+---+", "<table>\n<col style=\"width:33.33%\" />\n<col style=\"width:33.33%\" />\n<col style=\"width:33.33%\" />\n<tbody>\n<tr>\n<td colspan=\"2\" rowspan=\"2\">AAAAA\nAAAAA\nAAAAA</td>\n<td>B</td>\n</tr>\n<tr>\n<td>C</td>\n</tr>\n<tr>\n<td>D</td>\n<td>E</td>\n<td>F</td>\n</tr>\n</tbody>\n</table>", "gridtables|advanced", context: "Example 9\nSection Extensions / Grid Table\n");
+            Console.WriteLine("Example 9\nSection Extensions / Grid Table\n");
+            TestParser.TestSpec("+---+---+---+\n| AAAAA | B |\n+ AAAAA +---+\n| AAAAA | C |\n+---+---+---+\n| D | E | F |\n+---+---+---+", "<table>\n<col style=\"width:33.33%\" />\n<col style=\"width:33.33%\" />\n<col style=\"width:33.33%\" />\n<tbody>\n<tr>\n<td colspan=\"2\" rowspan=\"2\">AAAAA\nAAAAA\nAAAAA</td>\n<td>B</td>\n</tr>\n<tr>\n<td>C</td>\n</tr>\n<tr>\n<td>D</td>\n<td>E</td>\n<td>F</td>\n</tr>\n</tbody>\n</table>", "gridtables|advanced");
         }
 
         // A grid table may not have irregularly shaped cells:
@@ -366,7 +372,8 @@ namespace Markdig.Tests.Specs.GridTables
             //     | DDDDD | E |
             //     +---+---+---+</p>
 
-            TestParser.TestSpec("+---+---+---+\n| AAAAA | B |\n+ A +---+ B +\n| A | C | B |\n+---+---+---+\n| DDDDD | E |\n+---+---+---+", "<p>+---+---+---+\n| AAAAA | B |\n+ A +---+ B +\n| A | C | B |\n+---+---+---+\n| DDDDD | E |\n+---+---+---+</p>", "gridtables|advanced", context: "Example 10\nSection Extensions / Grid Table\n");
+            Console.WriteLine("Example 10\nSection Extensions / Grid Table\n");
+            TestParser.TestSpec("+---+---+---+\n| AAAAA | B |\n+ A +---+ B +\n| A | C | B |\n+---+---+---+\n| DDDDD | E |\n+---+---+---+", "<p>+---+---+---+\n| AAAAA | B |\n+ A +---+ B +\n| A | C | B |\n+---+---+---+\n| DDDDD | E |\n+---+---+---+</p>", "gridtables|advanced");
         }
 
         // An empty `+` on a line should result in a simple empty list output:
@@ -384,36 +391,8 @@ namespace Markdig.Tests.Specs.GridTables
             //     <li></li>
             //     </ul>
 
-            TestParser.TestSpec("+", "<ul>\n<li></li>\n</ul>", "gridtables|advanced", context: "Example 11\nSection Extensions / Grid Table\n");
-        }
-
-        // A table may begin right after a paragraph without an empty line in between:
-        [Test]
-        public void ExtensionsGridTable_Example012()
-        {
-            // Example 12
-            // Section: Extensions / Grid Table
-            //
-            // The following Markdown:
-            //     Some
-            //     **text**.
-            //     +---+
-            //     | A |
-            //     +---+
-            //
-            // Should be rendered as:
-            //     <p>Some
-            //     <strong>text</strong>.</p>
-            //     <table>
-            //     <col style="width:100%" />
-            //     <tbody>
-            //     <tr>
-            //     <td>A</td>
-            //     </tr>
-            //     </tbody>
-            //     </table>
-
-            TestParser.TestSpec("Some\n**text**.\n+---+\n| A |\n+---+", "<p>Some\n<strong>text</strong>.</p>\n<table>\n<col style=\"width:100%\" />\n<tbody>\n<tr>\n<td>A</td>\n</tr>\n</tbody>\n</table>", "gridtables|advanced", context: "Example 12\nSection Extensions / Grid Table\n");
+            Console.WriteLine("Example 11\nSection Extensions / Grid Table\n");
+            TestParser.TestSpec("+", "<ul>\n<li></li>\n</ul>", "gridtables|advanced");
         }
     }
 }

src/Markdig.Tests/Specs/GridTableSpecs.md

@@ -4,8 +4,7 @@ This section describes the different extensions supported:
 
 ## Grid Table
 
-A grid table allows having multiple lines per cells and allows spanning cells over multiple columns.
-The following shows a simple grid table:
+A grid table allows to have multiple lines per cells and allows to span cells over multiple columns. The following shows a simple grid table  
 
 ```
 +---------+---------+
@@ -26,20 +25,17 @@ The following shows a simple grid table:
 ```
 
 **Rule #1**
-The first line of a grid table must be a **row separator**.
-It must start with the column separator character `+` used to separate columns in a row separator.
+The first line of a grid table must a **row separator**. It must start with the column separator character `+` used to separate columns in a row separator. Each column separator is:
+  - starting by optional spaces
+  - followed by an optional `:` to specify left align, followed by optional spaces
+  - followed by a sequence of at least one `-` character, followed by optional spaces
+  - followed by an optional `:` to specify right align (or center align if left align is also defined)
+  - ending by optional spaces
 
-Each column separator:
-- starts with optional spaces
-- followed by an optional `:` to specify left align, followed by optional spaces
-- followed by a sequence of one or more `-` characters, followed by optional spaces
-- followed by an optional `:` to specify right align (or center align if left align is also defined)
-- ends with optional spaces
+The first row separator must be followed by a *regular row*. A regular row must start with the character `|` that is starting at the same position than the column separator `+` of the first row separator.
 
-The first row separator must be followed by a *regular row*.
-A regular row must start with a `|` character starting at the same position as the column separator `+` of the first row separator.
 
-The following is a valid row separator:
+The following is a valid row separator 
 
 ```````````````````````````````` example
 +---------+---------+
@@ -57,8 +53,8 @@ The following is a valid row separator:
 </table>
 ````````````````````````````````
 
-The following is not a valid row separator:
 
+The following is not a valid row separator 
 ```````````````````````````````` example
 |-----xxx----+---------+
 | This is    | not a table
@@ -68,8 +64,7 @@ The following is not a valid row separator:
 ````````````````````````````````
 
 **Rule #2**
-A regular row can continue a previous regular row when the column separators `|` are positioned at the same position as those of the previous line.
-If they are positioned at the same location, the column may span over multiple columns:
+A regular row can continue a previous regular row when column separator `|` are positioned at the same  position than the previous line. If they are positioned at the same location, the column may span over multiple columns:
 
 ```````````````````````````````` example
 +---------+---------+---------+
@@ -139,13 +134,15 @@ The last column separator `|` may be omitted:
 </table>
 ````````````````````````````````
 
-The respective widths of the columns are calculated from the ratio between the total size of the first table row without counting the `+`: `+----+--------+----+` would be divided between:
+The respective width of the columns are calculated from the ratio between the total size of the first table row without counting the `+`: `+----+--------+----+` would be divided between:
 
-- `----` → 4 characters
-- `--------` → 8 characters
-- `----` → 4 characters
+Total size is : 16 
 
-The total size is 16 characters, so the widths would be 4/16 = 25%, 8/16 = 50%, and 4/16 = 25%.
+- `----` -> 4
+- `--------` -> 8
+- `----` -> 4
+
+So the width would be 4/16 = 25%, 8/16 = 50%, 4/16 = 25%
 
 ```````````````````````````````` example
 +----+--------+----+
@@ -168,6 +165,7 @@ The total size is 16 characters, so the widths would be 4/16 = 25%, 8/16 = 50%,
 
 Alignment might be specified on the first row using the character `:`:
 
+
 ```````````````````````````````` example
 +-----+:---:+-----+
 |  A  |  B  |  C  |
@@ -222,7 +220,7 @@ D</td>
 </table>
 ````````````````````````````````
 
-A grid table may have cells with both `colspan` and `rowspan`:
+A grid table may have cells with both colspan and rowspan:
 
 ```````````````````````````````` example
 +---+---+---+
@@ -278,6 +276,7 @@ A grid table may not have irregularly shaped cells:
 
 An empty `+` on a line should result in a simple empty list output:
 
+
 ```````````````````````````````` example
 +
 .
@@ -285,24 +284,3 @@ An empty `+` on a line should result in a simple empty list output:
 <li></li>
 </ul>
 ````````````````````````````````
-
-A table may begin right after a paragraph without an empty line in between:
-
-```````````````````````````````` example
-Some
-**text**.
-+---+
-| A |
-+---+
-.
-<p>Some
-<strong>text</strong>.</p>
-<table>
-<col style="width:100%" />
-<tbody>
-<tr>
-<td>A</td>
-</tr>
-</tbody>
-</table>
-````````````````````````````````

src/Markdig.Tests/Specs/HardlineBreakSpecs.generated.cs

@@ -32,7 +32,8 @@ namespace Markdig.Tests.Specs.HardlineBreaks
             //     <p>This is a paragraph<br />
             //     with a break inside</p>
 
-            TestParser.TestSpec("This is a paragraph\nwith a break inside", "<p>This is a paragraph<br />\nwith a break inside</p>", "hardlinebreak|advanced+hardlinebreak", context: "Example 1\nSection Extensions / Hardline break\n");
+            Console.WriteLine("Example 1\nSection Extensions / Hardline break\n");
+            TestParser.TestSpec("This is a paragraph\nwith a break inside", "<p>This is a paragraph<br />\nwith a break inside</p>", "hardlinebreak|advanced+hardlinebreak");
         }
     }
 }

src/Markdig.Tests/Specs/JiraLinks.generated.cs

@@ -40,9 +40,10 @@ namespace Markdig.Tests.Specs.JiraLinks
             //     This is a ABCD-123 issue
             //
             // Should be rendered as:
-            //     <p>This is a <a href="http://your.company.abc/browse/ABCD-123" target="_blank">ABCD-123</a> issue</p>
+            //     <p>This is a <a href="http://your.company.abc/browse/ABCD-123" target="blank">ABCD-123</a> issue</p>
 
-            TestParser.TestSpec("This is a ABCD-123 issue", "<p>This is a <a href=\"http://your.company.abc/browse/ABCD-123\" target=\"_blank\">ABCD-123</a> issue</p>", "jiralinks", context: "Example 1\nSection Jira Links\n");
+            Console.WriteLine("Example 1\nSection Jira Links\n");
+            TestParser.TestSpec("This is a ABCD-123 issue", "<p>This is a <a href=\"http://your.company.abc/browse/ABCD-123\" target=\"blank\">ABCD-123</a> issue</p>", "jiralinks");
         }
 
         [Test]
@@ -55,9 +56,10 @@ namespace Markdig.Tests.Specs.JiraLinks
             //     This is a ABC4-123 issue
             //
             // Should be rendered as:
-            //     <p>This is a <a href="http://your.company.abc/browse/ABC4-123" target="_blank">ABC4-123</a> issue</p>
+            //     <p>This is a <a href="http://your.company.abc/browse/ABC4-123" target="blank">ABC4-123</a> issue</p>
 
-            TestParser.TestSpec("This is a ABC4-123 issue", "<p>This is a <a href=\"http://your.company.abc/browse/ABC4-123\" target=\"_blank\">ABC4-123</a> issue</p>", "jiralinks", context: "Example 2\nSection Jira Links\n");
+            Console.WriteLine("Example 2\nSection Jira Links\n");
+            TestParser.TestSpec("This is a ABC4-123 issue", "<p>This is a <a href=\"http://your.company.abc/browse/ABC4-123\" target=\"blank\">ABC4-123</a> issue</p>", "jiralinks");
         }
 
         [Test]
@@ -70,9 +72,10 @@ namespace Markdig.Tests.Specs.JiraLinks
             //     This is a ABC45-123 issue
             //
             // Should be rendered as:
-            //     <p>This is a <a href="http://your.company.abc/browse/ABC45-123" target="_blank">ABC45-123</a> issue</p>
+            //     <p>This is a <a href="http://your.company.abc/browse/ABC45-123" target="blank">ABC45-123</a> issue</p>
 
-            TestParser.TestSpec("This is a ABC45-123 issue", "<p>This is a <a href=\"http://your.company.abc/browse/ABC45-123\" target=\"_blank\">ABC45-123</a> issue</p>", "jiralinks", context: "Example 3\nSection Jira Links\n");
+            Console.WriteLine("Example 3\nSection Jira Links\n");
+            TestParser.TestSpec("This is a ABC45-123 issue", "<p>This is a <a href=\"http://your.company.abc/browse/ABC45-123\" target=\"blank\">ABC45-123</a> issue</p>", "jiralinks");
         }
 
         [Test]
@@ -85,9 +88,10 @@ namespace Markdig.Tests.Specs.JiraLinks
             //     This is a KIRA-1 issue
             //
             // Should be rendered as:
-            //     <p>This is a <a href="http://your.company.abc/browse/KIRA-1" target="_blank">KIRA-1</a> issue</p>
+            //     <p>This is a <a href="http://your.company.abc/browse/KIRA-1" target="blank">KIRA-1</a> issue</p>
 
-            TestParser.TestSpec("This is a KIRA-1 issue", "<p>This is a <a href=\"http://your.company.abc/browse/KIRA-1\" target=\"_blank\">KIRA-1</a> issue</p>", "jiralinks", context: "Example 4\nSection Jira Links\n");
+            Console.WriteLine("Example 4\nSection Jira Links\n");
+            TestParser.TestSpec("This is a KIRA-1 issue", "<p>This is a <a href=\"http://your.company.abc/browse/KIRA-1\" target=\"blank\">KIRA-1</a> issue</p>", "jiralinks");
         }
 
         [Test]
@@ -100,9 +104,10 @@ namespace Markdig.Tests.Specs.JiraLinks
             //     This is a Z-1 issue
             //
             // Should be rendered as:
-            //     <p>This is a <a href="http://your.company.abc/browse/Z-1" target="_blank">Z-1</a> issue</p>
+            //     <p>This is a <a href="http://your.company.abc/browse/Z-1" target="blank">Z-1</a> issue</p>
 
-            TestParser.TestSpec("This is a Z-1 issue", "<p>This is a <a href=\"http://your.company.abc/browse/Z-1\" target=\"_blank\">Z-1</a> issue</p>", "jiralinks", context: "Example 5\nSection Jira Links\n");
+            Console.WriteLine("Example 5\nSection Jira Links\n");
+            TestParser.TestSpec("This is a Z-1 issue", "<p>This is a <a href=\"http://your.company.abc/browse/Z-1\" target=\"blank\">Z-1</a> issue</p>", "jiralinks");
         }
 
         // These are also valid links with `(` and `)`:
@@ -116,9 +121,10 @@ namespace Markdig.Tests.Specs.JiraLinks
             //     This is a (ABCD-123) issue
             //
             // Should be rendered as:
-            //     <p>This is a (<a href="http://your.company.abc/browse/ABCD-123" target="_blank">ABCD-123</a>) issue</p>
+            //     <p>This is a (<a href="http://your.company.abc/browse/ABCD-123" target="blank">ABCD-123</a>) issue</p>
 
-            TestParser.TestSpec("This is a (ABCD-123) issue", "<p>This is a (<a href=\"http://your.company.abc/browse/ABCD-123\" target=\"_blank\">ABCD-123</a>) issue</p>", "jiralinks", context: "Example 6\nSection Jira Links\n");
+            Console.WriteLine("Example 6\nSection Jira Links\n");
+            TestParser.TestSpec("This is a (ABCD-123) issue", "<p>This is a (<a href=\"http://your.company.abc/browse/ABCD-123\" target=\"blank\">ABCD-123</a>) issue</p>", "jiralinks");
         }
 
         [Test]
@@ -131,9 +137,10 @@ namespace Markdig.Tests.Specs.JiraLinks
             //     This is a (ABC4-123) issue
             //
             // Should be rendered as:
-            //     <p>This is a (<a href="http://your.company.abc/browse/ABC4-123" target="_blank">ABC4-123</a>) issue</p>
+            //     <p>This is a (<a href="http://your.company.abc/browse/ABC4-123" target="blank">ABC4-123</a>) issue</p>
 
-            TestParser.TestSpec("This is a (ABC4-123) issue", "<p>This is a (<a href=\"http://your.company.abc/browse/ABC4-123\" target=\"_blank\">ABC4-123</a>) issue</p>", "jiralinks", context: "Example 7\nSection Jira Links\n");
+            Console.WriteLine("Example 7\nSection Jira Links\n");
+            TestParser.TestSpec("This is a (ABC4-123) issue", "<p>This is a (<a href=\"http://your.company.abc/browse/ABC4-123\" target=\"blank\">ABC4-123</a>) issue</p>", "jiralinks");
         }
 
         [Test]
@@ -146,9 +153,10 @@ namespace Markdig.Tests.Specs.JiraLinks
             //     This is a (KIRA-1) issue
             //
             // Should be rendered as:
-            //     <p>This is a (<a href="http://your.company.abc/browse/KIRA-1" target="_blank">KIRA-1</a>) issue</p>
+            //     <p>This is a (<a href="http://your.company.abc/browse/KIRA-1" target="blank">KIRA-1</a>) issue</p>
 
-            TestParser.TestSpec("This is a (KIRA-1) issue", "<p>This is a (<a href=\"http://your.company.abc/browse/KIRA-1\" target=\"_blank\">KIRA-1</a>) issue</p>", "jiralinks", context: "Example 8\nSection Jira Links\n");
+            Console.WriteLine("Example 8\nSection Jira Links\n");
+            TestParser.TestSpec("This is a (KIRA-1) issue", "<p>This is a (<a href=\"http://your.company.abc/browse/KIRA-1\" target=\"blank\">KIRA-1</a>) issue</p>", "jiralinks");
         }
 
         [Test]
@@ -161,9 +169,10 @@ namespace Markdig.Tests.Specs.JiraLinks
             //     This is a (Z-1) issue
             //
             // Should be rendered as:
-            //     <p>This is a (<a href="http://your.company.abc/browse/Z-1" target="_blank">Z-1</a>) issue</p>
+            //     <p>This is a (<a href="http://your.company.abc/browse/Z-1" target="blank">Z-1</a>) issue</p>
 
-            TestParser.TestSpec("This is a (Z-1) issue", "<p>This is a (<a href=\"http://your.company.abc/browse/Z-1\" target=\"_blank\">Z-1</a>) issue</p>", "jiralinks", context: "Example 9\nSection Jira Links\n");
+            Console.WriteLine("Example 9\nSection Jira Links\n");
+            TestParser.TestSpec("This is a (Z-1) issue", "<p>This is a (<a href=\"http://your.company.abc/browse/Z-1\" target=\"blank\">Z-1</a>) issue</p>", "jiralinks");
         }
 
         // These are not valid links:
@@ -179,7 +188,8 @@ namespace Markdig.Tests.Specs.JiraLinks
             // Should be rendered as:
             //     <p>This is not aJIRA-123 issue</p>
 
-            TestParser.TestSpec("This is not aJIRA-123 issue", "<p>This is not aJIRA-123 issue</p>", "jiralinks", context: "Example 10\nSection Jira Links\n");
+            Console.WriteLine("Example 10\nSection Jira Links\n");
+            TestParser.TestSpec("This is not aJIRA-123 issue", "<p>This is not aJIRA-123 issue</p>", "jiralinks");
         }
 
         [Test]
@@ -194,7 +204,8 @@ namespace Markdig.Tests.Specs.JiraLinks
             // Should be rendered as:
             //     <p>This is not 4JIRA-123 issue</p>
 
-            TestParser.TestSpec("This is not 4JIRA-123 issue", "<p>This is not 4JIRA-123 issue</p>", "jiralinks", context: "Example 11\nSection Jira Links\n");
+            Console.WriteLine("Example 11\nSection Jira Links\n");
+            TestParser.TestSpec("This is not 4JIRA-123 issue", "<p>This is not 4JIRA-123 issue</p>", "jiralinks");
         }
 
         [Test]
@@ -209,7 +220,8 @@ namespace Markdig.Tests.Specs.JiraLinks
             // Should be rendered as:
             //     <p>This is not JIRA-123a issue</p>
 
-            TestParser.TestSpec("This is not JIRA-123a issue", "<p>This is not JIRA-123a issue</p>", "jiralinks", context: "Example 12\nSection Jira Links\n");
+            Console.WriteLine("Example 12\nSection Jira Links\n");
+            TestParser.TestSpec("This is not JIRA-123a issue", "<p>This is not JIRA-123a issue</p>", "jiralinks");
         }
 
         [Test]
@@ -224,7 +236,8 @@ namespace Markdig.Tests.Specs.JiraLinks
             // Should be rendered as:
             //     <p>This is not JIRA- issue</p>
 
-            TestParser.TestSpec("This is not JIRA- issue", "<p>This is not JIRA- issue</p>", "jiralinks", context: "Example 13\nSection Jira Links\n");
+            Console.WriteLine("Example 13\nSection Jira Links\n");
+            TestParser.TestSpec("This is not JIRA- issue", "<p>This is not JIRA- issue</p>", "jiralinks");
         }
 
         [Test]
@@ -239,7 +252,8 @@ namespace Markdig.Tests.Specs.JiraLinks
             // Should be rendered as:
             //     <p>This is not JIR4- issue</p>
 
-            TestParser.TestSpec("This is not JIR4- issue", "<p>This is not JIR4- issue</p>", "jiralinks", context: "Example 14\nSection Jira Links\n");
+            Console.WriteLine("Example 14\nSection Jira Links\n");
+            TestParser.TestSpec("This is not JIR4- issue", "<p>This is not JIR4- issue</p>", "jiralinks");
         }
     }
 }

src/Markdig.Tests/Specs/JiraLinks.md

@@ -21,31 +21,31 @@ The following are valid examples:
 ```````````````````````````````` example
 This is a ABCD-123 issue
 .
-<p>This is a <a href="http://your.company.abc/browse/ABCD-123" target="_blank">ABCD-123</a> issue</p>
+<p>This is a <a href="http://your.company.abc/browse/ABCD-123" target="blank">ABCD-123</a> issue</p>
 ````````````````````````````````
 
 ```````````````````````````````` example
 This is a ABC4-123 issue
 .
-<p>This is a <a href="http://your.company.abc/browse/ABC4-123" target="_blank">ABC4-123</a> issue</p>
+<p>This is a <a href="http://your.company.abc/browse/ABC4-123" target="blank">ABC4-123</a> issue</p>
 ````````````````````````````````
 
 ```````````````````````````````` example
 This is a ABC45-123 issue
 .
-<p>This is a <a href="http://your.company.abc/browse/ABC45-123" target="_blank">ABC45-123</a> issue</p>
+<p>This is a <a href="http://your.company.abc/browse/ABC45-123" target="blank">ABC45-123</a> issue</p>
 ````````````````````````````````
 
 ```````````````````````````````` example
 This is a KIRA-1 issue
 .
-<p>This is a <a href="http://your.company.abc/browse/KIRA-1" target="_blank">KIRA-1</a> issue</p>
+<p>This is a <a href="http://your.company.abc/browse/KIRA-1" target="blank">KIRA-1</a> issue</p>
 ````````````````````````````````
 
 ```````````````````````````````` example
 This is a Z-1 issue
 .
-<p>This is a <a href="http://your.company.abc/browse/Z-1" target="_blank">Z-1</a> issue</p>
+<p>This is a <a href="http://your.company.abc/browse/Z-1" target="blank">Z-1</a> issue</p>
 ````````````````````````````````
 
 These are also valid links with `(` and `)`:
@@ -53,25 +53,25 @@ These are also valid links with `(` and `)`:
 ```````````````````````````````` example
 This is a (ABCD-123) issue
 .
-<p>This is a (<a href="http://your.company.abc/browse/ABCD-123" target="_blank">ABCD-123</a>) issue</p>
+<p>This is a (<a href="http://your.company.abc/browse/ABCD-123" target="blank">ABCD-123</a>) issue</p>
 ````````````````````````````````
 
 ```````````````````````````````` example
 This is a (ABC4-123) issue
 .
-<p>This is a (<a href="http://your.company.abc/browse/ABC4-123" target="_blank">ABC4-123</a>) issue</p>
+<p>This is a (<a href="http://your.company.abc/browse/ABC4-123" target="blank">ABC4-123</a>) issue</p>
 ````````````````````````````````
 
 ```````````````````````````````` example
 This is a (KIRA-1) issue
 .
-<p>This is a (<a href="http://your.company.abc/browse/KIRA-1" target="_blank">KIRA-1</a>) issue</p>
+<p>This is a (<a href="http://your.company.abc/browse/KIRA-1" target="blank">KIRA-1</a>) issue</p>
 ````````````````````````````````
 
 ```````````````````````````````` example
 This is a (Z-1) issue
 .
-<p>This is a (<a href="http://your.company.abc/browse/Z-1" target="_blank">Z-1</a>) issue</p>
+<p>This is a (<a href="http://your.company.abc/browse/Z-1" target="blank">Z-1</a>) issue</p>
 ````````````````````````````````
 
 These are not valid links:

src/Markdig.Tests/Specs/ListExtraSpecs.generated.cs

@@ -36,7 +36,8 @@ namespace Markdig.Tests.Specs.ListExtras
             //     <li>Last item</li>
             //     </ol>
 
-            TestParser.TestSpec("a. First item\nb. Second item\nc. Last item", "<ol type=\"a\">\n<li>First item</li>\n<li>Second item</li>\n<li>Last item</li>\n</ol>", "listextras|advanced", context: "Example 1\nSection Extensions / Ordered list with alpha letter\n");
+            Console.WriteLine("Example 1\nSection Extensions / Ordered list with alpha letter\n");
+            TestParser.TestSpec("a. First item\nb. Second item\nc. Last item", "<ol type=\"a\">\n<li>First item</li>\n<li>Second item</li>\n<li>Last item</li>\n</ol>", "listextras|advanced");
         }
 
         // It works also for uppercase alpha: 
@@ -58,7 +59,8 @@ namespace Markdig.Tests.Specs.ListExtras
             //     <li>Last item</li>
             //     </ol>
 
-            TestParser.TestSpec("A. First item\nB. Second item\nC. Last item", "<ol type=\"A\">\n<li>First item</li>\n<li>Second item</li>\n<li>Last item</li>\n</ol>", "listextras|advanced", context: "Example 2\nSection Extensions / Ordered list with alpha letter\n");
+            Console.WriteLine("Example 2\nSection Extensions / Ordered list with alpha letter\n");
+            TestParser.TestSpec("A. First item\nB. Second item\nC. Last item", "<ol type=\"A\">\n<li>First item</li>\n<li>Second item</li>\n<li>Last item</li>\n</ol>", "listextras|advanced");
         }
 
         // Like for numbered list, a list can start with a different letter
@@ -78,7 +80,8 @@ namespace Markdig.Tests.Specs.ListExtras
             //     <li>Second item</li>
             //     </ol>
 
-            TestParser.TestSpec("b. First item\nc. Second item", "<ol type=\"a\" start=\"2\">\n<li>First item</li>\n<li>Second item</li>\n</ol>", "listextras|advanced", context: "Example 3\nSection Extensions / Ordered list with alpha letter\n");
+            Console.WriteLine("Example 3\nSection Extensions / Ordered list with alpha letter\n");
+            TestParser.TestSpec("b. First item\nc. Second item", "<ol type=\"a\" start=\"2\">\n<li>First item</li>\n<li>Second item</li>\n</ol>", "listextras|advanced");
         }
 
         // A different type of list will break the existing list:
@@ -102,7 +105,8 @@ namespace Markdig.Tests.Specs.ListExtras
             //     <li>First item2</li>
             //     </ol>
 
-            TestParser.TestSpec("a. First item1\nb. Second item\nA. First item2", "<ol type=\"a\">\n<li>First item1</li>\n<li>Second item</li>\n</ol>\n<ol type=\"A\">\n<li>First item2</li>\n</ol>", "listextras|advanced", context: "Example 4\nSection Extensions / Ordered list with alpha letter\n");
+            Console.WriteLine("Example 4\nSection Extensions / Ordered list with alpha letter\n");
+            TestParser.TestSpec("a. First item1\nb. Second item\nA. First item2", "<ol type=\"a\">\n<li>First item1</li>\n<li>Second item</li>\n</ol>\n<ol type=\"A\">\n<li>First item2</li>\n</ol>", "listextras|advanced");
         }
     }
 
@@ -132,7 +136,8 @@ namespace Markdig.Tests.Specs.ListExtras
             //     <li>Last item</li>
             //     </ol>
 
-            TestParser.TestSpec("i. First item\nii. Second item\niii. Third item\niv. Last item", "<ol type=\"i\">\n<li>First item</li>\n<li>Second item</li>\n<li>Third item</li>\n<li>Last item</li>\n</ol>", "listextras|advanced", context: "Example 5\nSection Extensions / Ordered list with roman letter\n");
+            Console.WriteLine("Example 5\nSection Extensions / Ordered list with roman letter\n");
+            TestParser.TestSpec("i. First item\nii. Second item\niii. Third item\niv. Last item", "<ol type=\"i\">\n<li>First item</li>\n<li>Second item</li>\n<li>Third item</li>\n<li>Last item</li>\n</ol>", "listextras|advanced");
         }
 
         // It works also for uppercase alpha: 
@@ -156,7 +161,8 @@ namespace Markdig.Tests.Specs.ListExtras
             //     <li>Last item</li>
             //     </ol>
 
-            TestParser.TestSpec("I. First item\nII. Second item\nIII. Third item\nIV. Last item", "<ol type=\"I\">\n<li>First item</li>\n<li>Second item</li>\n<li>Third item</li>\n<li>Last item</li>\n</ol>", "listextras|advanced", context: "Example 6\nSection Extensions / Ordered list with roman letter\n");
+            Console.WriteLine("Example 6\nSection Extensions / Ordered list with roman letter\n");
+            TestParser.TestSpec("I. First item\nII. Second item\nIII. Third item\nIV. Last item", "<ol type=\"I\">\n<li>First item</li>\n<li>Second item</li>\n<li>Third item</li>\n<li>Last item</li>\n</ol>", "listextras|advanced");
         }
 
         // Like for numbered list, a list can start with a different letter
@@ -176,7 +182,8 @@ namespace Markdig.Tests.Specs.ListExtras
             //     <li>Second item</li>
             //     </ol>
 
-            TestParser.TestSpec("ii. First item\niii. Second item", "<ol type=\"i\" start=\"2\">\n<li>First item</li>\n<li>Second item</li>\n</ol>", "listextras|advanced", context: "Example 7\nSection Extensions / Ordered list with roman letter\n");
+            Console.WriteLine("Example 7\nSection Extensions / Ordered list with roman letter\n");
+            TestParser.TestSpec("ii. First item\niii. Second item", "<ol type=\"i\" start=\"2\">\n<li>First item</li>\n<li>Second item</li>\n</ol>", "listextras|advanced");
         }
 
         // Lists can be restarted, specifying the start point.
@@ -202,7 +209,8 @@ namespace Markdig.Tests.Specs.ListExtras
             //     <li>Second item</li>
             //     </ol>
 
-            TestParser.TestSpec("1.   First item\n\nSome text\n\n2.   Second item", "<ol>\n<li>First item</li>\n</ol>\n<p>Some text</p>\n<ol start=\"2\">\n<li>Second item</li>\n</ol>", "listextras|advanced", context: "Example 8\nSection Extensions / Ordered list with roman letter\n");
+            Console.WriteLine("Example 8\nSection Extensions / Ordered list with roman letter\n");
+            TestParser.TestSpec("1.   First item\n\nSome text\n\n2.   Second item", "<ol>\n<li>First item</li>\n</ol>\n<p>Some text</p>\n<ol start=\"2\">\n<li>Second item</li>\n</ol>", "listextras|advanced");
         }
     }
 }

src/Markdig.Tests/Specs/MathSpecs.generated.cs

@@ -17,7 +17,7 @@ namespace Markdig.Tests.Specs.Math
         // 
         // ## Math Inline
         //  
-        // Allows to define a mathematic inline block embraced by `$...$`
+        // Allows to define a mathematic block embraced by `$...$`
         [Test]
         public void ExtensionsMathInline_Example001()
         {
@@ -25,12 +25,13 @@ namespace Markdig.Tests.Specs.Math
             // Section: Extensions / Math Inline
             //
             // The following Markdown:
-            //     This is a $math inline$
+            //     This is a $math block$
             //
             // Should be rendered as:
-            //     <p>This is a <span class="math">\(math inline\)</span></p>
+            //     <p>This is a <span class="math">\(math block\)</span></p>
 
-            TestParser.TestSpec("This is a $math inline$", "<p>This is a <span class=\"math\">\\(math inline\\)</span></p>", "mathematics|advanced", context: "Example 1\nSection Extensions / Math Inline\n");
+            Console.WriteLine("Example 1\nSection Extensions / Math Inline\n");
+            TestParser.TestSpec("This is a $math block$", "<p>This is a <span class=\"math\">\\(math block\\)</span></p>", "mathematics|advanced");
         }
 
         // Or by `$$...$$` embracing it by:
@@ -41,12 +42,13 @@ namespace Markdig.Tests.Specs.Math
             // Section: Extensions / Math Inline
             //
             // The following Markdown:
-            //     This is a $$math inline$$
+            //     This is a $$math block$$
             //
             // Should be rendered as:
-            //     <p>This is a <span class="math">\(math inline\)</span></p>
+            //     <p>This is a <span class="math">\(math block\)</span></p>
 
-            TestParser.TestSpec("This is a $$math inline$$", "<p>This is a <span class=\"math\">\\(math inline\\)</span></p>", "mathematics|advanced", context: "Example 2\nSection Extensions / Math Inline\n");
+            Console.WriteLine("Example 2\nSection Extensions / Math Inline\n");
+            TestParser.TestSpec("This is a $$math block$$", "<p>This is a <span class=\"math\">\\(math block\\)</span></p>", "mathematics|advanced");
         }
 
         // Newlines inside an inline math are not allowed:
@@ -58,13 +60,14 @@ namespace Markdig.Tests.Specs.Math
             //
             // The following Markdown:
             //     This is not a $$math 
-            //     inline$$ and? this is a $$math inline$$
+            //     block$$ and? this is a $$math block$$
             //
             // Should be rendered as:
             //     <p>This is not a $$math
-            //     inline$$ and? this is a <span class="math">\(math inline\)</span></p>
+            //     block$$ and? this is a <span class="math">\(math block\)</span></p>
 
-            TestParser.TestSpec("This is not a $$math \ninline$$ and? this is a $$math inline$$", "<p>This is not a $$math\ninline$$ and? this is a <span class=\"math\">\\(math inline\\)</span></p>", "mathematics|advanced", context: "Example 3\nSection Extensions / Math Inline\n");
+            Console.WriteLine("Example 3\nSection Extensions / Math Inline\n");
+            TestParser.TestSpec("This is not a $$math \nblock$$ and? this is a $$math block$$", "<p>This is not a $$math\nblock$$ and? this is a <span class=\"math\">\\(math block\\)</span></p>", "mathematics|advanced");
         }
 
         [Test]
@@ -75,13 +78,14 @@ namespace Markdig.Tests.Specs.Math
             //
             // The following Markdown:
             //     This is not a $math 
-            //     inline$ and? this is a $math inline$
+            //     block$ and? this is a $math block$
             //
             // Should be rendered as:
             //     <p>This is not a $math
-            //     inline$ and? this is a <span class="math">\(math inline\)</span></p>
+            //     block$ and? this is a <span class="math">\(math block\)</span></p>
 
-            TestParser.TestSpec("This is not a $math \ninline$ and? this is a $math inline$", "<p>This is not a $math\ninline$ and? this is a <span class=\"math\">\\(math inline\\)</span></p>", "mathematics|advanced", context: "Example 4\nSection Extensions / Math Inline\n");
+            Console.WriteLine("Example 4\nSection Extensions / Math Inline\n");
+            TestParser.TestSpec("This is not a $math \nblock$ and? this is a $math block$", "<p>This is not a $math\nblock$ and? this is a <span class=\"math\">\\(math block\\)</span></p>", "mathematics|advanced");
         }
 
         // An opening `$` can be followed by a space if the closing is also preceded by a space `$`:
@@ -92,12 +96,13 @@ namespace Markdig.Tests.Specs.Math
             // Section: Extensions / Math Inline
             //
             // The following Markdown:
-            //     This is a $ math inline $
+            //     This is a $ math block $
             //
             // Should be rendered as:
-            //     <p>This is a <span class="math">\(math inline\)</span></p>
+            //     <p>This is a <span class="math">\(math block\)</span></p>
 
-            TestParser.TestSpec("This is a $ math inline $", "<p>This is a <span class=\"math\">\\(math inline\\)</span></p>", "mathematics|advanced", context: "Example 5\nSection Extensions / Math Inline\n");
+            Console.WriteLine("Example 5\nSection Extensions / Math Inline\n");
+            TestParser.TestSpec("This is a $ math block $", "<p>This is a <span class=\"math\">\\(math block\\)</span></p>", "mathematics|advanced");
         }
 
         [Test]
@@ -107,12 +112,13 @@ namespace Markdig.Tests.Specs.Math
             // Section: Extensions / Math Inline
             //
             // The following Markdown:
-            //     This is a $    math inline     $ after
+            //     This is a $    math block     $ after
             //
             // Should be rendered as:
-            //     <p>This is a <span class="math">\(math inline\)</span> after</p>
+            //     <p>This is a <span class="math">\(math block\)</span> after</p>
 
-            TestParser.TestSpec("This is a $    math inline     $ after", "<p>This is a <span class=\"math\">\\(math inline\\)</span> after</p>", "mathematics|advanced", context: "Example 6\nSection Extensions / Math Inline\n");
+            Console.WriteLine("Example 6\nSection Extensions / Math Inline\n");
+            TestParser.TestSpec("This is a $    math block     $ after", "<p>This is a <span class=\"math\">\\(math block\\)</span> after</p>", "mathematics|advanced");
         }
 
         [Test]
@@ -122,12 +128,13 @@ namespace Markdig.Tests.Specs.Math
             // Section: Extensions / Math Inline
             //
             // The following Markdown:
-            //     This is a $$    math inline     $$ after
+            //     This is a $$    math block     $$ after
             //
             // Should be rendered as:
-            //     <p>This is a <span class="math">\(math inline\)</span> after</p>
+            //     <p>This is a <span class="math">\(math block\)</span> after</p>
 
-            TestParser.TestSpec("This is a $$    math inline     $$ after", "<p>This is a <span class=\"math\">\\(math inline\\)</span> after</p>", "mathematics|advanced", context: "Example 7\nSection Extensions / Math Inline\n");
+            Console.WriteLine("Example 7\nSection Extensions / Math Inline\n");
+            TestParser.TestSpec("This is a $$    math block     $$ after", "<p>This is a <span class=\"math\">\\(math block\\)</span> after</p>", "mathematics|advanced");
         }
 
         [Test]
@@ -137,12 +144,13 @@ namespace Markdig.Tests.Specs.Math
             // Section: Extensions / Math Inline
             //
             // The following Markdown:
-            //     This is a not $ math inline$ because there is not a whitespace before the closing
+            //     This is a not $ math block$ because there is not a whitespace before the closing
             //
             // Should be rendered as:
-            //     <p>This is a not $ math inline$ because there is not a whitespace before the closing</p>
+            //     <p>This is a not $ math block$ because there is not a whitespace before the closing</p>
 
-            TestParser.TestSpec("This is a not $ math inline$ because there is not a whitespace before the closing", "<p>This is a not $ math inline$ because there is not a whitespace before the closing</p>", "mathematics|advanced", context: "Example 8\nSection Extensions / Math Inline\n");
+            Console.WriteLine("Example 8\nSection Extensions / Math Inline\n");
+            TestParser.TestSpec("This is a not $ math block$ because there is not a whitespace before the closing", "<p>This is a not $ math block$ because there is not a whitespace before the closing</p>", "mathematics|advanced");
         }
 
         // For the opening `$` it requires a space or a punctuation before (but cannot be used within a word):
@@ -153,12 +161,13 @@ namespace Markdig.Tests.Specs.Math
             // Section: Extensions / Math Inline
             //
             // The following Markdown:
-            //     This is not a m$ath inline$
+            //     This is not a m$ath block$
             //
             // Should be rendered as:
-            //     <p>This is not a m$ath inline$</p>
+            //     <p>This is not a m$ath block$</p>
 
-            TestParser.TestSpec("This is not a m$ath inline$", "<p>This is not a m$ath inline$</p>", "mathematics|advanced", context: "Example 9\nSection Extensions / Math Inline\n");
+            Console.WriteLine("Example 9\nSection Extensions / Math Inline\n");
+            TestParser.TestSpec("This is not a m$ath block$", "<p>This is not a m$ath block$</p>", "mathematics|advanced");
         }
 
         // For the closing `$` it requires a space after or a punctuation (but cannot be preceded by a space and cannot be used within a word):
@@ -169,12 +178,13 @@ namespace Markdig.Tests.Specs.Math
             // Section: Extensions / Math Inline
             //
             // The following Markdown:
-            //     This is not a $math inlin$e
+            //     This is not a $math bloc$k
             //
             // Should be rendered as:
-            //     <p>This is not a $math inlin$e</p>
+            //     <p>This is not a $math bloc$k</p>
 
-            TestParser.TestSpec("This is not a $math inlin$e", "<p>This is not a $math inlin$e</p>", "mathematics|advanced", context: "Example 10\nSection Extensions / Math Inline\n");
+            Console.WriteLine("Example 10\nSection Extensions / Math Inline\n");
+            TestParser.TestSpec("This is not a $math bloc$k", "<p>This is not a $math bloc$k</p>", "mathematics|advanced");
         }
 
         // For the closing `$` it requires a space after or a punctuation (but cannot be preceded by a space and cannot be used within a word):
@@ -190,7 +200,8 @@ namespace Markdig.Tests.Specs.Math
             // Should be rendered as:
             //     <p>This is should not match a 16$ or a $15</p>
 
-            TestParser.TestSpec("This is should not match a 16$ or a $15", "<p>This is should not match a 16$ or a $15</p>", "mathematics|advanced", context: "Example 11\nSection Extensions / Math Inline\n");
+            Console.WriteLine("Example 11\nSection Extensions / Math Inline\n");
+            TestParser.TestSpec("This is should not match a 16$ or a $15", "<p>This is should not match a 16$ or a $15</p>", "mathematics|advanced");
         }
 
         // A `$` can be escaped between a math inline block by using the escape `\\` 
@@ -201,12 +212,13 @@ namespace Markdig.Tests.Specs.Math
             // Section: Extensions / Math Inline
             //
             // The following Markdown:
-            //     This is a $math \$ inline$
+            //     This is a $math \$ block$
             //
             // Should be rendered as:
-            //     <p>This is a <span class="math">\(math \$ inline\)</span></p>
+            //     <p>This is a <span class="math">\(math \$ block\)</span></p>
 
-            TestParser.TestSpec("This is a $math \\$ inline$", "<p>This is a <span class=\"math\">\\(math \\$ inline\\)</span></p>", "mathematics|advanced", context: "Example 12\nSection Extensions / Math Inline\n");
+            Console.WriteLine("Example 12\nSection Extensions / Math Inline\n");
+            TestParser.TestSpec("This is a $math \\$ block$", "<p>This is a <span class=\"math\">\\(math \\$ block\\)</span></p>", "mathematics|advanced");
         }
 
         // At most, two `$` will be matched for the opening and closing:
@@ -217,12 +229,13 @@ namespace Markdig.Tests.Specs.Math
             // Section: Extensions / Math Inline
             //
             // The following Markdown:
-            //     This is a $$$math inline$$$
+            //     This is a $$$math block$$$
             //
             // Should be rendered as:
-            //     <p>This is a <span class="math">\($math inline$\)</span></p>
+            //     <p>This is a <span class="math">\($math block$\)</span></p>
 
-            TestParser.TestSpec("This is a $$$math inline$$$", "<p>This is a <span class=\"math\">\\($math inline$\\)</span></p>", "mathematics|advanced", context: "Example 13\nSection Extensions / Math Inline\n");
+            Console.WriteLine("Example 13\nSection Extensions / Math Inline\n");
+            TestParser.TestSpec("This is a $$$math block$$$", "<p>This is a <span class=\"math\">\\($math block$\\)</span></p>", "mathematics|advanced");
         }
 
         // Regular text can come both before and after the math inline
@@ -233,15 +246,16 @@ namespace Markdig.Tests.Specs.Math
             // Section: Extensions / Math Inline
             //
             // The following Markdown:
-            //     This is a $math inline$ with text on both sides.
+            //     This is a $math block$ with text on both sides.
             //
             // Should be rendered as:
-            //     <p>This is a <span class="math">\(math inline\)</span> with text on both sides.</p>
+            //     <p>This is a <span class="math">\(math block\)</span> with text on both sides.</p>
 
-            TestParser.TestSpec("This is a $math inline$ with text on both sides.", "<p>This is a <span class=\"math\">\\(math inline\\)</span> with text on both sides.</p>", "mathematics|advanced", context: "Example 14\nSection Extensions / Math Inline\n");
+            Console.WriteLine("Example 14\nSection Extensions / Math Inline\n");
+            TestParser.TestSpec("This is a $math block$ with text on both sides.", "<p>This is a <span class=\"math\">\\(math block\\)</span> with text on both sides.</p>", "mathematics|advanced");
         }
 
-        // A mathematic inline block takes precedence over standard emphasis `*` `_`:
+        // A mathematic block takes precedence over standard emphasis `*` `_`:
         [Test]
         public void ExtensionsMathInline_Example015()
         {
@@ -249,15 +263,16 @@ namespace Markdig.Tests.Specs.Math
             // Section: Extensions / Math Inline
             //
             // The following Markdown:
-            //     This is *a $math* inline$
+            //     This is *a $math* block$
             //
             // Should be rendered as:
-            //     <p>This is *a <span class="math">\(math* inline\)</span></p>
+            //     <p>This is *a <span class="math">\(math* block\)</span></p>
 
-            TestParser.TestSpec("This is *a $math* inline$", "<p>This is *a <span class=\"math\">\\(math* inline\\)</span></p>", "mathematics|advanced", context: "Example 15\nSection Extensions / Math Inline\n");
+            Console.WriteLine("Example 15\nSection Extensions / Math Inline\n");
+            TestParser.TestSpec("This is *a $math* block$", "<p>This is *a <span class=\"math\">\\(math* block\\)</span></p>", "mathematics|advanced");
         }
 
-        // An opening $$ at the beginning of a line should not be interpreted as a Math inline:
+        // An opening $$ at the beginning of a line should not be interpreted as a Math block:
         [Test]
         public void ExtensionsMathInline_Example016()
         {
@@ -270,7 +285,8 @@ namespace Markdig.Tests.Specs.Math
             // Should be rendered as:
             //     <p><span class="math">\(math\)</span> starting at a line</p>
 
-            TestParser.TestSpec("$$ math $$ starting at a line", "<p><span class=\"math\">\\(math\\)</span> starting at a line</p>", "mathematics|advanced", context: "Example 16\nSection Extensions / Math Inline\n");
+            Console.WriteLine("Example 16\nSection Extensions / Math Inline\n");
+            TestParser.TestSpec("$$ math $$ starting at a line", "<p><span class=\"math\">\\(math\\)</span> starting at a line</p>", "mathematics|advanced");
         }
     }
 
@@ -279,7 +295,7 @@ namespace Markdig.Tests.Specs.Math
     {
         // ## Math Block
         // 
-        // The math block can spawn on multiple lines by having a $$ starting on a line.
+        // The match block can spawn on multiple lines by having a $$ starting on a line.
         // It is working as a fenced code block.
         [Test]
         public void ExtensionsMathBlock_Example017()
@@ -304,7 +320,8 @@ namespace Markdig.Tests.Specs.Math
             //     \end{equation}
             //     \]</div>
 
-            TestParser.TestSpec("$$\n\\begin{equation}\n  \\int_0^\\infty \\frac{x^3}{e^x-1}\\,dx = \\frac{\\pi^4}{15}\n  \\label{eq:sample}\n\\end{equation}\n$$", "<div class=\"math\">\n\\[\n\\begin{equation}\n  \\int_0^\\infty \\frac{x^3}{e^x-1}\\,dx = \\frac{\\pi^4}{15}\n  \\label{eq:sample}\n\\end{equation}\n\\]</div>", "mathematics|advanced", context: "Example 17\nSection Extensions / Math Block\n");
+            Console.WriteLine("Example 17\nSection Extensions / Math Block\n");
+            TestParser.TestSpec("$$\n\\begin{equation}\n  \\int_0^\\infty \\frac{x^3}{e^x-1}\\,dx = \\frac{\\pi^4}{15}\n  \\label{eq:sample}\n\\end{equation}\n$$", "<div class=\"math\">\n\\[\n\\begin{equation}\n  \\int_0^\\infty \\frac{x^3}{e^x-1}\\,dx = \\frac{\\pi^4}{15}\n  \\label{eq:sample}\n\\end{equation}\n\\]</div>", "mathematics|advanced");
         }
     }
 }

src/Markdig.Tests/Specs/MathSpecs.md

@@ -4,79 +4,79 @@ Adds support for mathematics spans:
 
 ## Math Inline
  
-Allows to define a mathematic inline block embraced by `$...$`
+Allows to define a mathematic block embraced by `$...$`
 
 ```````````````````````````````` example
-This is a $math inline$
+This is a $math block$
 .
-<p>This is a <span class="math">\(math inline\)</span></p>
+<p>This is a <span class="math">\(math block\)</span></p>
 ````````````````````````````````
 
 Or by `$$...$$` embracing it by:
 
 ```````````````````````````````` example
-This is a $$math inline$$
+This is a $$math block$$
 .
-<p>This is a <span class="math">\(math inline\)</span></p>
+<p>This is a <span class="math">\(math block\)</span></p>
 ````````````````````````````````
 
 Newlines inside an inline math are not allowed:
 
 ```````````````````````````````` example
 This is not a $$math 
-inline$$ and? this is a $$math inline$$
+block$$ and? this is a $$math block$$
 .
 <p>This is not a $$math
-inline$$ and? this is a <span class="math">\(math inline\)</span></p>
+block$$ and? this is a <span class="math">\(math block\)</span></p>
 ````````````````````````````````
 
 ```````````````````````````````` example
 This is not a $math 
-inline$ and? this is a $math inline$
+block$ and? this is a $math block$
 .
 <p>This is not a $math
-inline$ and? this is a <span class="math">\(math inline\)</span></p>
+block$ and? this is a <span class="math">\(math block\)</span></p>
 ````````````````````````````````
 An opening `$` can be followed by a space if the closing is also preceded by a space `$`:
 
 ```````````````````````````````` example
-This is a $ math inline $
+This is a $ math block $
 .
-<p>This is a <span class="math">\(math inline\)</span></p>
+<p>This is a <span class="math">\(math block\)</span></p>
 ````````````````````````````````
 
 ```````````````````````````````` example
-This is a $    math inline     $ after
+This is a $    math block     $ after
 .
-<p>This is a <span class="math">\(math inline\)</span> after</p>
+<p>This is a <span class="math">\(math block\)</span> after</p>
 ````````````````````````````````
 
 ```````````````````````````````` example
-This is a $$    math inline     $$ after
+This is a $$    math block     $$ after
 .
-<p>This is a <span class="math">\(math inline\)</span> after</p>
+<p>This is a <span class="math">\(math block\)</span> after</p>
 ````````````````````````````````
 
 ```````````````````````````````` example
-This is a not $ math inline$ because there is not a whitespace before the closing
+This is a not $ math block$ because there is not a whitespace before the closing
 .
-<p>This is a not $ math inline$ because there is not a whitespace before the closing</p>
+<p>This is a not $ math block$ because there is not a whitespace before the closing</p>
 ````````````````````````````````
 
 For the opening `$` it requires a space or a punctuation before (but cannot be used within a word):
 
 ```````````````````````````````` example
-This is not a m$ath inline$
+This is not a m$ath block$
 .
-<p>This is not a m$ath inline$</p>
+<p>This is not a m$ath block$</p>
 ````````````````````````````````
 
 For the closing `$` it requires a space after or a punctuation (but cannot be preceded by a space and cannot be used within a word):
 
 ```````````````````````````````` example
-This is not a $math inlin$e
+This is not a $math bloc$k
 .
-<p>This is not a $math inlin$e</p>
+<p>This is not a $math bloc$k</p>
 ````````````````````````````````
 
 For the closing `$` it requires a space after or a punctuation (but cannot be preceded by a space and cannot be used within a word):
@@ -90,34 +90,34 @@ This is should not match a 16$ or a $15
 A `$` can be escaped between a math inline block by using the escape `\\` 
 
 ```````````````````````````````` example
-This is a $math \$ inline$
+This is a $math \$ block$
 .
-<p>This is a <span class="math">\(math \$ inline\)</span></p>
+<p>This is a <span class="math">\(math \$ block\)</span></p>
 ````````````````````````````````
 
 At most, two `$` will be matched for the opening and closing:
 
 ```````````````````````````````` example
-This is a $$$math inline$$$
+This is a $$$math block$$$
 .
-<p>This is a <span class="math">\($math inline$\)</span></p>
+<p>This is a <span class="math">\($math block$\)</span></p>
 ````````````````````````````````
 
 Regular text can come both before and after the math inline
 
 ```````````````````````````````` example
-This is a $math inline$ with text on both sides.
+This is a $math block$ with text on both sides.
 .
-<p>This is a <span class="math">\(math inline\)</span> with text on both sides.</p>
+<p>This is a <span class="math">\(math block\)</span> with text on both sides.</p>
 ````````````````````````````````
-A mathematic inline block takes precedence over standard emphasis `*` `_`:
+A mathematic block takes precedence over standard emphasis `*` `_`:
 
 ```````````````````````````````` example
-This is *a $math* inline$
+This is *a $math* block$
 .
-<p>This is *a <span class="math">\(math* inline\)</span></p>
+<p>This is *a <span class="math">\(math* block\)</span></p>
 ````````````````````````````````
-An opening $$ at the beginning of a line should not be interpreted as a Math inline:
+An opening $$ at the beginning of a line should not be interpreted as a Math block:
 
 ```````````````````````````````` example
 $$ math $$ starting at a line
@@ -127,7 +127,7 @@ $$ math $$ starting at a line
 
 ## Math Block
 
-The math block can spawn on multiple lines by having a $$ starting on a line.
+The match block can spawn on multiple lines by having a $$ starting on a line.
 It is working as a fenced code block.
 
 ```````````````````````````````` example

src/Markdig.Tests/Specs/MediaSpecs.generated.cs

@@ -57,7 +57,8 @@ namespace Markdig.Tests.Specs.Media
             //     <p><iframe src="https://music.yandex.ru/iframe/#track/4402274/411845/" class="yandex" width="500" height="281" frameborder="0"></iframe></p>
             //     <p><iframe src="https://ok.ru/videoembed/26870090463" class="odnoklassniki" width="500" height="281" frameborder="0" allowfullscreen=""></iframe></p>
 
-            TestParser.TestSpec("![youtube.com](https://www.youtube.com/watch?v=mswPy5bt3TQ)\n\n![youtube.com with t](https://www.youtube.com/watch?v=mswPy5bt3TQ&t=100)\n\n![youtu.be](https://youtu.be/mswPy5bt3TQ)\n\n![youtu.be with t](https://youtu.be/mswPy5bt3TQ?t=100)\n\n![youtube.com/embed 1](https://www.youtube.com/embed/mswPy5bt3TQ?start=100&rel=0)\n\n![youtube.com/embed 2](https://www.youtube.com/embed?listType=playlist&list=PLC77007E23FF423C6)\n\n![vimeo](https://vimeo.com/8607834)\n\n![static mp4](https://sample.com/video.mp4)\n\n![yandex.ru](https://music.yandex.ru/album/411845/track/4402274)\n\n![ok.ru](https://ok.ru/video/26870090463)", "<p><iframe src=\"https://www.youtube.com/embed/mswPy5bt3TQ\" class=\"youtube\" width=\"500\" height=\"281\" frameborder=\"0\" allowfullscreen=\"\"></iframe></p>\n<p><iframe src=\"https://www.youtube.com/embed/mswPy5bt3TQ?start=100\" class=\"youtube\" width=\"500\" height=\"281\" frameborder=\"0\" allowfullscreen=\"\"></iframe></p>\n<p><iframe src=\"https://www.youtube.com/embed/mswPy5bt3TQ\" class=\"youtube\" width=\"500\" height=\"281\" frameborder=\"0\" allowfullscreen=\"\"></iframe></p>\n<p><iframe src=\"https://www.youtube.com/embed/mswPy5bt3TQ?start=100\" class=\"youtube\" width=\"500\" height=\"281\" frameborder=\"0\" allowfullscreen=\"\"></iframe></p>\n<p><iframe src=\"https://www.youtube.com/embed/mswPy5bt3TQ?start=100&amp;rel=0\" class=\"youtube\" width=\"500\" height=\"281\" frameborder=\"0\" allowfullscreen=\"\"></iframe></p>\n<p><iframe src=\"https://www.youtube.com/embed?listType=playlist&amp;list=PLC77007E23FF423C6\" class=\"youtube\" width=\"500\" height=\"281\" frameborder=\"0\" allowfullscreen=\"\"></iframe></p>\n<p><iframe src=\"https://player.vimeo.com/video/8607834\" class=\"vimeo\" width=\"500\" height=\"281\" frameborder=\"0\" allowfullscreen=\"\"></iframe></p>\n<p><video width=\"500\" height=\"281\" controls=\"\"><source type=\"video/mp4\" src=\"https://sample.com/video.mp4\"></source></video></p>\n<p><iframe src=\"https://music.yandex.ru/iframe/#track/4402274/411845/\" class=\"yandex\" width=\"500\" height=\"281\" frameborder=\"0\"></iframe></p>\n<p><iframe src=\"https://ok.ru/videoembed/26870090463\" class=\"odnoklassniki\" width=\"500\" height=\"281\" frameborder=\"0\" allowfullscreen=\"\"></iframe></p>", "medialinks|advanced+medialinks", context: "Example 1\nSection Extensions / Media links\n");
+            Console.WriteLine("Example 1\nSection Extensions / Media links\n");
+            TestParser.TestSpec("![youtube.com](https://www.youtube.com/watch?v=mswPy5bt3TQ)\n\n![youtube.com with t](https://www.youtube.com/watch?v=mswPy5bt3TQ&t=100)\n\n![youtu.be](https://youtu.be/mswPy5bt3TQ)\n\n![youtu.be with t](https://youtu.be/mswPy5bt3TQ?t=100)\n\n![youtube.com/embed 1](https://www.youtube.com/embed/mswPy5bt3TQ?start=100&rel=0)\n\n![youtube.com/embed 2](https://www.youtube.com/embed?listType=playlist&list=PLC77007E23FF423C6)\n\n![vimeo](https://vimeo.com/8607834)\n\n![static mp4](https://sample.com/video.mp4)\n\n![yandex.ru](https://music.yandex.ru/album/411845/track/4402274)\n\n![ok.ru](https://ok.ru/video/26870090463)", "<p><iframe src=\"https://www.youtube.com/embed/mswPy5bt3TQ\" class=\"youtube\" width=\"500\" height=\"281\" frameborder=\"0\" allowfullscreen=\"\"></iframe></p>\n<p><iframe src=\"https://www.youtube.com/embed/mswPy5bt3TQ?start=100\" class=\"youtube\" width=\"500\" height=\"281\" frameborder=\"0\" allowfullscreen=\"\"></iframe></p>\n<p><iframe src=\"https://www.youtube.com/embed/mswPy5bt3TQ\" class=\"youtube\" width=\"500\" height=\"281\" frameborder=\"0\" allowfullscreen=\"\"></iframe></p>\n<p><iframe src=\"https://www.youtube.com/embed/mswPy5bt3TQ?start=100\" class=\"youtube\" width=\"500\" height=\"281\" frameborder=\"0\" allowfullscreen=\"\"></iframe></p>\n<p><iframe src=\"https://www.youtube.com/embed/mswPy5bt3TQ?start=100&amp;rel=0\" class=\"youtube\" width=\"500\" height=\"281\" frameborder=\"0\" allowfullscreen=\"\"></iframe></p>\n<p><iframe src=\"https://www.youtube.com/embed?listType=playlist&amp;list=PLC77007E23FF423C6\" class=\"youtube\" width=\"500\" height=\"281\" frameborder=\"0\" allowfullscreen=\"\"></iframe></p>\n<p><iframe src=\"https://player.vimeo.com/video/8607834\" class=\"vimeo\" width=\"500\" height=\"281\" frameborder=\"0\" allowfullscreen=\"\"></iframe></p>\n<p><video width=\"500\" height=\"281\" controls=\"\"><source type=\"video/mp4\" src=\"https://sample.com/video.mp4\"></source></video></p>\n<p><iframe src=\"https://music.yandex.ru/iframe/#track/4402274/411845/\" class=\"yandex\" width=\"500\" height=\"281\" frameborder=\"0\"></iframe></p>\n<p><iframe src=\"https://ok.ru/videoembed/26870090463\" class=\"odnoklassniki\" width=\"500\" height=\"281\" frameborder=\"0\" allowfullscreen=\"\"></iframe></p>", "medialinks|advanced+medialinks");
         }
     }
 }

src/Markdig.Tests/Specs/NoHtmlSpecs.generated.cs

@@ -30,7 +30,8 @@ namespace Markdig.Tests.Specs.NoHtml
             // Should be rendered as:
             //     <p>this is some text&lt;/td&gt;&lt;/tr&gt;</p>
 
-            TestParser.TestSpec("this is some text</td></tr>", "<p>this is some text&lt;/td&gt;&lt;/tr&gt;</p>", "nohtml", context: "Example 1\nSection Extensions / NoHTML\n");
+            Console.WriteLine("Example 1\nSection Extensions / NoHTML\n");
+            TestParser.TestSpec("this is some text</td></tr>", "<p>this is some text&lt;/td&gt;&lt;/tr&gt;</p>", "nohtml");
         }
 
         // For Block HTML:
@@ -50,7 +51,8 @@ namespace Markdig.Tests.Specs.NoHtml
             //     this is some text
             //     &lt;/div&gt;</p>
 
-            TestParser.TestSpec("<div>\nthis is some text\n</div>", "<p>&lt;div&gt;\nthis is some text\n&lt;/div&gt;</p>", "nohtml", context: "Example 2\nSection Extensions / NoHTML\n");
+            Console.WriteLine("Example 2\nSection Extensions / NoHTML\n");
+            TestParser.TestSpec("<div>\nthis is some text\n</div>", "<p>&lt;div&gt;\nthis is some text\n&lt;/div&gt;</p>", "nohtml");
         }
     }
 }

src/Markdig.Tests/Specs/PipeTableGfmSpecs.generated.cs

@@ -58,7 +58,8 @@ namespace Markdig.Tests.Specs.GFMPipeTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec("a | b\n-- | -\n0 | 1", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>", "gfm-pipetables", context: "Example 1\nSection Extensions / Gfm Pipe Table\n");
+            Console.WriteLine("Example 1\nSection Extensions / Gfm Pipe Table\n");
+            TestParser.TestSpec("a | b\n-- | -\n0 | 1", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>", "gfm-pipetables");
         }
 
         // The following is also considered as a table, even if the second line starts like a list:
@@ -89,7 +90,8 @@ namespace Markdig.Tests.Specs.GFMPipeTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec("a | b\n- | -\n0 | 1", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>", "gfm-pipetables", context: "Example 2\nSection Extensions / Gfm Pipe Table\n");
+            Console.WriteLine("Example 2\nSection Extensions / Gfm Pipe Table\n");
+            TestParser.TestSpec("a | b\n- | -\n0 | 1", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>", "gfm-pipetables");
         }
 
         // A pipe table with only one header row is allowed:
@@ -113,7 +115,8 @@ namespace Markdig.Tests.Specs.GFMPipeTables
             //     </thead>
             //     </table>
 
-            TestParser.TestSpec("a | b\n-- | --", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n</table>", "gfm-pipetables", context: "Example 3\nSection Extensions / Gfm Pipe Table\n");
+            Console.WriteLine("Example 3\nSection Extensions / Gfm Pipe Table\n");
+            TestParser.TestSpec("a | b\n-- | --", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n</table>", "gfm-pipetables");
         }
 
         // After a row separator header, they will be interpreted as plain column:
@@ -144,7 +147,8 @@ namespace Markdig.Tests.Specs.GFMPipeTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec("a | b\n-- | --\n-- | --", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>--</td>\n<td>--</td>\n</tr>\n</tbody>\n</table>", "gfm-pipetables", context: "Example 4\nSection Extensions / Gfm Pipe Table\n");
+            Console.WriteLine("Example 4\nSection Extensions / Gfm Pipe Table\n");
+            TestParser.TestSpec("a | b\n-- | --\n-- | --", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>--</td>\n<td>--</td>\n</tr>\n</tbody>\n</table>", "gfm-pipetables");
         }
 
         // But if a table doesn't start with a column delimiter, it is not interpreted as a table, even if following lines have a column delimiter
@@ -164,7 +168,8 @@ namespace Markdig.Tests.Specs.GFMPipeTables
             //     c | d
             //     e | f</p>
 
-            TestParser.TestSpec("a b\nc | d\ne | f", "<p>a b\nc | d\ne | f</p>", "gfm-pipetables", context: "Example 5\nSection Extensions / Gfm Pipe Table\n");
+            Console.WriteLine("Example 5\nSection Extensions / Gfm Pipe Table\n");
+            TestParser.TestSpec("a b\nc | d\ne | f", "<p>a b\nc | d\ne | f</p>", "gfm-pipetables");
         }
 
         // If a line doesn't have a column delimiter `|` the table is not detected
@@ -182,7 +187,8 @@ namespace Markdig.Tests.Specs.GFMPipeTables
             //     <p>a | b
             //     c no d</p>
 
-            TestParser.TestSpec("a | b\nc no d", "<p>a | b\nc no d</p>", "gfm-pipetables", context: "Example 6\nSection Extensions / Gfm Pipe Table\n");
+            Console.WriteLine("Example 6\nSection Extensions / Gfm Pipe Table\n");
+            TestParser.TestSpec("a | b\nc no d", "<p>a | b\nc no d</p>", "gfm-pipetables");
         }
 
         // If a row contains more columns than the header row, the extra columns will be ignored:
@@ -223,7 +229,8 @@ namespace Markdig.Tests.Specs.GFMPipeTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec("a  | b \n-- | --\n0  | 1 | 2\n3  | 4\n5  |", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n<tr>\n<td>3</td>\n<td>4</td>\n</tr>\n<tr>\n<td>5</td>\n<td></td>\n</tr>\n</tbody>\n</table>", "gfm-pipetables", context: "Example 7\nSection Extensions / Gfm Pipe Table\n");
+            Console.WriteLine("Example 7\nSection Extensions / Gfm Pipe Table\n");
+            TestParser.TestSpec("a  | b \n-- | --\n0  | 1 | 2\n3  | 4\n5  |", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n<tr>\n<td>3</td>\n<td>4</td>\n</tr>\n<tr>\n<td>5</td>\n<td></td>\n</tr>\n</tbody>\n</table>", "gfm-pipetables");
         }
 
         // **Rule #2**
@@ -258,7 +265,8 @@ namespace Markdig.Tests.Specs.GFMPipeTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec("a          | b              |\n-- | --\n0      | 1       |", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>", "gfm-pipetables", context: "Example 8\nSection Extensions / Gfm Pipe Table\n");
+            Console.WriteLine("Example 8\nSection Extensions / Gfm Pipe Table\n");
+            TestParser.TestSpec("a          | b              |\n-- | --\n0      | 1       |", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>", "gfm-pipetables");
         }
 
         // **Rule #4**
@@ -300,7 +308,8 @@ namespace Markdig.Tests.Specs.GFMPipeTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec("  a     | b     |\n--      | --\n| 0     | 1\n| 2     | 3     |\n  4     | 5 ", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n<tr>\n<td>2</td>\n<td>3</td>\n</tr>\n<tr>\n<td>4</td>\n<td>5</td>\n</tr>\n</tbody>\n</table>", "gfm-pipetables", context: "Example 9\nSection Extensions / Gfm Pipe Table\n");
+            Console.WriteLine("Example 9\nSection Extensions / Gfm Pipe Table\n");
+            TestParser.TestSpec("  a     | b     |\n--      | --\n| 0     | 1\n| 2     | 3     |\n  4     | 5 ", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n<tr>\n<td>2</td>\n<td>3</td>\n</tr>\n<tr>\n<td>4</td>\n<td>5</td>\n</tr>\n</tbody>\n</table>", "gfm-pipetables");
         }
 
         // A pipe may be present at both the beginning/ending of each line:
@@ -331,7 +340,8 @@ namespace Markdig.Tests.Specs.GFMPipeTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec("|a|b|\n|-|-|\n|0|1|", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>", "gfm-pipetables", context: "Example 10\nSection Extensions / Gfm Pipe Table\n");
+            Console.WriteLine("Example 10\nSection Extensions / Gfm Pipe Table\n");
+            TestParser.TestSpec("|a|b|\n|-|-|\n|0|1|", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>", "gfm-pipetables");
         }
 
         // Or may be omitted on one side:
@@ -362,7 +372,8 @@ namespace Markdig.Tests.Specs.GFMPipeTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec("a|b|\n-|-|\n0|1|", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>", "gfm-pipetables", context: "Example 11\nSection Extensions / Gfm Pipe Table\n");
+            Console.WriteLine("Example 11\nSection Extensions / Gfm Pipe Table\n");
+            TestParser.TestSpec("a|b|\n-|-|\n0|1|", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>", "gfm-pipetables");
         }
 
         [Test]
@@ -392,7 +403,8 @@ namespace Markdig.Tests.Specs.GFMPipeTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec("|a|b\n|-|-\n|0|1", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>", "gfm-pipetables", context: "Example 12\nSection Extensions / Gfm Pipe Table\n");
+            Console.WriteLine("Example 12\nSection Extensions / Gfm Pipe Table\n");
+            TestParser.TestSpec("|a|b\n|-|-\n|0|1", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>", "gfm-pipetables");
         }
 
         // Single column table can be declared with lines starting only by a column delimiter: 
@@ -425,7 +437,8 @@ namespace Markdig.Tests.Specs.GFMPipeTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec("| a\n| --\n| b\n| c ", "<table>\n<thead>\n<tr>\n<th>a</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>b</td>\n</tr>\n<tr>\n<td>c</td>\n</tr>\n</tbody>\n</table>", "gfm-pipetables", context: "Example 13\nSection Extensions / Gfm Pipe Table\n");
+            Console.WriteLine("Example 13\nSection Extensions / Gfm Pipe Table\n");
+            TestParser.TestSpec("| a\n| --\n| b\n| c ", "<table>\n<thead>\n<tr>\n<th>a</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>b</td>\n</tr>\n<tr>\n<td>c</td>\n</tr>\n</tbody>\n</table>", "gfm-pipetables");
         }
 
         // **Rule #5**
@@ -469,7 +482,8 @@ namespace Markdig.Tests.Specs.GFMPipeTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec(" a     | b \n-------|-------\n 0     | 1 \n 2     | 3 ", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n<tr>\n<td>2</td>\n<td>3</td>\n</tr>\n</tbody>\n</table>", "gfm-pipetables", context: "Example 14\nSection Extensions / Gfm Pipe Table\n");
+            Console.WriteLine("Example 14\nSection Extensions / Gfm Pipe Table\n");
+            TestParser.TestSpec(" a     | b \n-------|-------\n 0     | 1 \n 2     | 3 ", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n<tr>\n<td>2</td>\n<td>3</td>\n</tr>\n</tbody>\n</table>", "gfm-pipetables");
         }
 
         // The text alignment is defined by default to be center for header and left for cells. If the left alignment is applied, it will force the column heading to be left aligned.
@@ -510,7 +524,8 @@ namespace Markdig.Tests.Specs.GFMPipeTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec(" a     | b       | c \n:------|:-------:| ----:\n 0     | 1       | 2 \n 3     | 4       | 5 ", "<table>\n<thead>\n<tr>\n<th style=\"text-align: left;\">a</th>\n<th style=\"text-align: center;\">b</th>\n<th style=\"text-align: right;\">c</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td style=\"text-align: left;\">0</td>\n<td style=\"text-align: center;\">1</td>\n<td style=\"text-align: right;\">2</td>\n</tr>\n<tr>\n<td style=\"text-align: left;\">3</td>\n<td style=\"text-align: center;\">4</td>\n<td style=\"text-align: right;\">5</td>\n</tr>\n</tbody>\n</table>", "gfm-pipetables", context: "Example 15\nSection Extensions / Gfm Pipe Table\n");
+            Console.WriteLine("Example 15\nSection Extensions / Gfm Pipe Table\n");
+            TestParser.TestSpec(" a     | b       | c \n:------|:-------:| ----:\n 0     | 1       | 2 \n 3     | 4       | 5 ", "<table>\n<thead>\n<tr>\n<th style=\"text-align: left;\">a</th>\n<th style=\"text-align: center;\">b</th>\n<th style=\"text-align: right;\">c</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td style=\"text-align: left;\">0</td>\n<td style=\"text-align: center;\">1</td>\n<td style=\"text-align: right;\">2</td>\n</tr>\n<tr>\n<td style=\"text-align: left;\">3</td>\n<td style=\"text-align: center;\">4</td>\n<td style=\"text-align: right;\">5</td>\n</tr>\n</tbody>\n</table>", "gfm-pipetables");
         }
 
         // Test alignment with starting and ending pipes:
@@ -543,7 +558,8 @@ namespace Markdig.Tests.Specs.GFMPipeTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec("| abc | def | ghi |\n|:---:|-----|----:|\n|  1  | 2   | 3   |", "<table>\n<thead>\n<tr>\n<th style=\"text-align: center;\">abc</th>\n<th>def</th>\n<th style=\"text-align: right;\">ghi</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td style=\"text-align: center;\">1</td>\n<td>2</td>\n<td style=\"text-align: right;\">3</td>\n</tr>\n</tbody>\n</table>", "gfm-pipetables", context: "Example 16\nSection Extensions / Gfm Pipe Table\n");
+            Console.WriteLine("Example 16\nSection Extensions / Gfm Pipe Table\n");
+            TestParser.TestSpec("| abc | def | ghi |\n|:---:|-----|----:|\n|  1  | 2   | 3   |", "<table>\n<thead>\n<tr>\n<th style=\"text-align: center;\">abc</th>\n<th>def</th>\n<th style=\"text-align: right;\">ghi</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td style=\"text-align: center;\">1</td>\n<td>2</td>\n<td style=\"text-align: right;\">3</td>\n</tr>\n</tbody>\n</table>", "gfm-pipetables");
         }
 
         // The following example shows a non matching header column separator:
@@ -565,7 +581,8 @@ namespace Markdig.Tests.Specs.GFMPipeTables
             //     0     | 1
             //     2     | 3</p> 
 
-            TestParser.TestSpec(" a     | b\n-------|---x---\n 0     | 1\n 2     | 3 ", "<p>a     | b\n-------|---x---\n0     | 1\n2     | 3</p> ", "gfm-pipetables", context: "Example 17\nSection Extensions / Gfm Pipe Table\n");
+            Console.WriteLine("Example 17\nSection Extensions / Gfm Pipe Table\n");
+            TestParser.TestSpec(" a     | b\n-------|---x---\n 0     | 1\n 2     | 3 ", "<p>a     | b\n-------|---x---\n0     | 1\n2     | 3</p> ", "gfm-pipetables");
         }
 
         // **Rule #6**
@@ -603,7 +620,8 @@ namespace Markdig.Tests.Specs.GFMPipeTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec(" *a*   | b\n-----  |-----\n 0     | _1_\n _2    | 3* ", "<table>\n<thead>\n<tr>\n<th><em>a</em></th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td><em>1</em></td>\n</tr>\n<tr>\n<td>_2</td>\n<td>3*</td>\n</tr>\n</tbody>\n</table>", "gfm-pipetables", context: "Example 18\nSection Extensions / Gfm Pipe Table\n");
+            Console.WriteLine("Example 18\nSection Extensions / Gfm Pipe Table\n");
+            TestParser.TestSpec(" *a*   | b\n-----  |-----\n 0     | _1_\n _2    | 3* ", "<table>\n<thead>\n<tr>\n<th><em>a</em></th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td><em>1</em></td>\n</tr>\n<tr>\n<td>_2</td>\n<td>3*</td>\n</tr>\n</tbody>\n</table>", "gfm-pipetables");
         }
 
         // **Rule #7**
@@ -622,7 +640,8 @@ namespace Markdig.Tests.Specs.GFMPipeTables
             // Should be rendered as:
             //     <p>a | b <code>0 |</code></p> 
 
-            TestParser.TestSpec("a | b `\n0 | ` ", "<p>a | b <code>0 |</code></p> ", "gfm-pipetables", context: "Example 19\nSection Extensions / Gfm Pipe Table\n");
+            Console.WriteLine("Example 19\nSection Extensions / Gfm Pipe Table\n");
+            TestParser.TestSpec("a | b `\n0 | ` ", "<p>a | b <code>0 |</code></p> ", "gfm-pipetables");
         }
 
         // **Rule #8**
@@ -655,7 +674,8 @@ namespace Markdig.Tests.Specs.GFMPipeTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec("a <a href=\"\" title=\"|\"></a> | b\n-- | --\n0  | 1", "<table>\n<thead>\n<tr>\n<th>a <a href=\"\" title=\"|\"></a></th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>", "gfm-pipetables", context: "Example 20\nSection Extensions / Gfm Pipe Table\n");
+            Console.WriteLine("Example 20\nSection Extensions / Gfm Pipe Table\n");
+            TestParser.TestSpec("a <a href=\"\" title=\"|\"></a> | b\n-- | --\n0  | 1", "<table>\n<thead>\n<tr>\n<th>a <a href=\"\" title=\"|\"></a></th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>", "gfm-pipetables");
         }
 
         // **Rule #9**
@@ -688,7 +708,8 @@ namespace Markdig.Tests.Specs.GFMPipeTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec("a  | b\n-- | --\n[This is a link with a | inside the label](http://google.com) | 1", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><a href=\"http://google.com\">This is a link with a | inside the label</a></td>\n<td>1</td>\n</tr>\n</tbody>\n</table>", "gfm-pipetables", context: "Example 21\nSection Extensions / Gfm Pipe Table\n");
+            Console.WriteLine("Example 21\nSection Extensions / Gfm Pipe Table\n");
+            TestParser.TestSpec("a  | b\n-- | --\n[This is a link with a | inside the label](http://google.com) | 1", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><a href=\"http://google.com\">This is a link with a | inside the label</a></td>\n<td>1</td>\n</tr>\n</tbody>\n</table>", "gfm-pipetables");
         }
 
         // **Rule #10**
@@ -714,7 +735,8 @@ namespace Markdig.Tests.Specs.GFMPipeTables
             //     </thead>
             //     </table>
 
-            TestParser.TestSpec("a  | b\n-- | --", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n</table>", "gfm-pipetables", context: "Example 22\nSection Extensions / Gfm Pipe Table\n");
+            Console.WriteLine("Example 22\nSection Extensions / Gfm Pipe Table\n");
+            TestParser.TestSpec("a  | b\n-- | --", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n</table>", "gfm-pipetables");
         }
 
         [Test]
@@ -738,7 +760,8 @@ namespace Markdig.Tests.Specs.GFMPipeTables
             //     </thead>
             //     </table>
 
-            TestParser.TestSpec("|a|b|c\n|---|---|---|", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n<th>c</th>\n</tr>\n</thead>\n</table>", "gfm-pipetables", context: "Example 23\nSection Extensions / Gfm Pipe Table\n");
+            Console.WriteLine("Example 23\nSection Extensions / Gfm Pipe Table\n");
+            TestParser.TestSpec("|a|b|c\n|---|---|---|", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n<th>c</th>\n</tr>\n</thead>\n</table>", "gfm-pipetables");
         }
 
         // **Tests**
@@ -786,7 +809,8 @@ namespace Markdig.Tests.Specs.GFMPipeTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec("| abc | def | \n|---|---|\n| cde| ddd| \n| eee| fff|\n| fff | fffff   | \n|gggg  | ffff | ", "<table>\n<thead>\n<tr>\n<th>abc</th>\n<th>def</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>cde</td>\n<td>ddd</td>\n</tr>\n<tr>\n<td>eee</td>\n<td>fff</td>\n</tr>\n<tr>\n<td>fff</td>\n<td>fffff</td>\n</tr>\n<tr>\n<td>gggg</td>\n<td>ffff</td>\n</tr>\n</tbody>\n</table>", "gfm-pipetables", context: "Example 24\nSection Extensions / Gfm Pipe Table\n");
+            Console.WriteLine("Example 24\nSection Extensions / Gfm Pipe Table\n");
+            TestParser.TestSpec("| abc | def | \n|---|---|\n| cde| ddd| \n| eee| fff|\n| fff | fffff   | \n|gggg  | ffff | ", "<table>\n<thead>\n<tr>\n<th>abc</th>\n<th>def</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>cde</td>\n<td>ddd</td>\n</tr>\n<tr>\n<td>eee</td>\n<td>fff</td>\n</tr>\n<tr>\n<td>fff</td>\n<td>fffff</td>\n</tr>\n<tr>\n<td>gggg</td>\n<td>ffff</td>\n</tr>\n</tbody>\n</table>", "gfm-pipetables");
         }
 
         // **Normalized columns count**
@@ -825,7 +849,8 @@ namespace Markdig.Tests.Specs.GFMPipeTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec("a | b\n-- | - \n0 | 1 | 2\n3 |", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n<tr>\n<td>3</td>\n<td></td>\n</tr>\n</tbody>\n</table>", "gfm-pipetables", context: "Example 25\nSection Extensions / Gfm Pipe Table\n");
+            Console.WriteLine("Example 25\nSection Extensions / Gfm Pipe Table\n");
+            TestParser.TestSpec("a | b\n-- | - \n0 | 1 | 2\n3 |", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n<tr>\n<td>3</td>\n<td></td>\n</tr>\n</tbody>\n</table>", "gfm-pipetables");
         }
     }
 }

src/Markdig.Tests/Specs/PipeTableSpecs.generated.cs

@@ -56,7 +56,8 @@ namespace Markdig.Tests.Specs.PipeTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec("a | b\n-- | -\n0 | 1", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>", "pipetables|advanced", context: "Example 1\nSection Extensions / Pipe Table\n");
+            Console.WriteLine("Example 1\nSection Extensions / Pipe Table\n");
+            TestParser.TestSpec("a | b\n-- | -\n0 | 1", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>", "pipetables|advanced");
         }
 
         // The following is also considered as a table, even if the second line starts like a list:
@@ -87,7 +88,8 @@ namespace Markdig.Tests.Specs.PipeTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec("a | b\n- | -\n0 | 1", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>", "pipetables|advanced", context: "Example 2\nSection Extensions / Pipe Table\n");
+            Console.WriteLine("Example 2\nSection Extensions / Pipe Table\n");
+            TestParser.TestSpec("a | b\n- | -\n0 | 1", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>", "pipetables|advanced");
         }
 
         // A pipe table with only one header row is allowed:
@@ -111,7 +113,8 @@ namespace Markdig.Tests.Specs.PipeTables
             //     </thead>
             //     </table>
 
-            TestParser.TestSpec("a | b\n-- | --", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n</table>", "pipetables|advanced", context: "Example 3\nSection Extensions / Pipe Table\n");
+            Console.WriteLine("Example 3\nSection Extensions / Pipe Table\n");
+            TestParser.TestSpec("a | b\n-- | --", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n</table>", "pipetables|advanced");
         }
 
         // After a row separator header, they will be interpreted as plain column:
@@ -142,7 +145,8 @@ namespace Markdig.Tests.Specs.PipeTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec("a | b\n-- | --\n-- | --", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>--</td>\n<td>--</td>\n</tr>\n</tbody>\n</table>", "pipetables|advanced", context: "Example 4\nSection Extensions / Pipe Table\n");
+            Console.WriteLine("Example 4\nSection Extensions / Pipe Table\n");
+            TestParser.TestSpec("a | b\n-- | --\n-- | --", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>--</td>\n<td>--</td>\n</tr>\n</tbody>\n</table>", "pipetables|advanced");
         }
 
         // But if a table doesn't start with a column delimiter, it is not interpreted as a table, even if following lines have a column delimiter
@@ -162,7 +166,8 @@ namespace Markdig.Tests.Specs.PipeTables
             //     c | d
             //     e | f</p>
 
-            TestParser.TestSpec("a b\nc | d\ne | f", "<p>a b\nc | d\ne | f</p>", "pipetables|advanced", context: "Example 5\nSection Extensions / Pipe Table\n");
+            Console.WriteLine("Example 5\nSection Extensions / Pipe Table\n");
+            TestParser.TestSpec("a b\nc | d\ne | f", "<p>a b\nc | d\ne | f</p>", "pipetables|advanced");
         }
 
         // If a line doesn't have a column delimiter `|` the table is not detected
@@ -180,7 +185,8 @@ namespace Markdig.Tests.Specs.PipeTables
             //     <p>a | b
             //     c no d</p>
 
-            TestParser.TestSpec("a | b\nc no d", "<p>a | b\nc no d</p>", "pipetables|advanced", context: "Example 6\nSection Extensions / Pipe Table\n");
+            Console.WriteLine("Example 6\nSection Extensions / Pipe Table\n");
+            TestParser.TestSpec("a | b\nc no d", "<p>a | b\nc no d</p>", "pipetables|advanced");
         }
 
         // If a row contains more column than the header row, it will still be added as a column:
@@ -225,7 +231,8 @@ namespace Markdig.Tests.Specs.PipeTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec("a  | b \n-- | --\n0  | 1 | 2\n3  | 4\n5  |", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n<th></th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n<td>2</td>\n</tr>\n<tr>\n<td>3</td>\n<td>4</td>\n<td></td>\n</tr>\n<tr>\n<td>5</td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>", "pipetables|advanced", context: "Example 7\nSection Extensions / Pipe Table\n");
+            Console.WriteLine("Example 7\nSection Extensions / Pipe Table\n");
+            TestParser.TestSpec("a  | b \n-- | --\n0  | 1 | 2\n3  | 4\n5  |", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n<th></th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n<td>2</td>\n</tr>\n<tr>\n<td>3</td>\n<td>4</td>\n<td></td>\n</tr>\n<tr>\n<td>5</td>\n<td></td>\n<td></td>\n</tr>\n</tbody>\n</table>", "pipetables|advanced");
         }
 
         // **Rule #2**
@@ -260,7 +267,8 @@ namespace Markdig.Tests.Specs.PipeTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec("a          | b              |\n-- | --\n0      | 1       |", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>", "pipetables|advanced", context: "Example 8\nSection Extensions / Pipe Table\n");
+            Console.WriteLine("Example 8\nSection Extensions / Pipe Table\n");
+            TestParser.TestSpec("a          | b              |\n-- | --\n0      | 1       |", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>", "pipetables|advanced");
         }
 
         // **Rule #4**
@@ -302,7 +310,8 @@ namespace Markdig.Tests.Specs.PipeTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec("  a     | b     |\n--      | --\n| 0     | 1\n| 2     | 3     |\n  4     | 5 ", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n<tr>\n<td>2</td>\n<td>3</td>\n</tr>\n<tr>\n<td>4</td>\n<td>5</td>\n</tr>\n</tbody>\n</table>", "pipetables|advanced", context: "Example 9\nSection Extensions / Pipe Table\n");
+            Console.WriteLine("Example 9\nSection Extensions / Pipe Table\n");
+            TestParser.TestSpec("  a     | b     |\n--      | --\n| 0     | 1\n| 2     | 3     |\n  4     | 5 ", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n<tr>\n<td>2</td>\n<td>3</td>\n</tr>\n<tr>\n<td>4</td>\n<td>5</td>\n</tr>\n</tbody>\n</table>", "pipetables|advanced");
         }
 
         // A pipe may be present at both the beginning/ending of each line:
@@ -333,7 +342,8 @@ namespace Markdig.Tests.Specs.PipeTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec("|a|b|\n|-|-|\n|0|1|", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>", "pipetables|advanced", context: "Example 10\nSection Extensions / Pipe Table\n");
+            Console.WriteLine("Example 10\nSection Extensions / Pipe Table\n");
+            TestParser.TestSpec("|a|b|\n|-|-|\n|0|1|", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>", "pipetables|advanced");
         }
 
         // Or may be omitted on one side:
@@ -364,7 +374,8 @@ namespace Markdig.Tests.Specs.PipeTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec("a|b|\n-|-|\n0|1|", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>", "pipetables|advanced", context: "Example 11\nSection Extensions / Pipe Table\n");
+            Console.WriteLine("Example 11\nSection Extensions / Pipe Table\n");
+            TestParser.TestSpec("a|b|\n-|-|\n0|1|", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>", "pipetables|advanced");
         }
 
         [Test]
@@ -394,7 +405,8 @@ namespace Markdig.Tests.Specs.PipeTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec("|a|b\n|-|-\n|0|1", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>", "pipetables|advanced", context: "Example 12\nSection Extensions / Pipe Table\n");
+            Console.WriteLine("Example 12\nSection Extensions / Pipe Table\n");
+            TestParser.TestSpec("|a|b\n|-|-\n|0|1", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>", "pipetables|advanced");
         }
 
         // Single column table can be declared with lines starting only by a column delimiter: 
@@ -427,7 +439,8 @@ namespace Markdig.Tests.Specs.PipeTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec("| a\n| --\n| b\n| c ", "<table>\n<thead>\n<tr>\n<th>a</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>b</td>\n</tr>\n<tr>\n<td>c</td>\n</tr>\n</tbody>\n</table>", "pipetables|advanced", context: "Example 13\nSection Extensions / Pipe Table\n");
+            Console.WriteLine("Example 13\nSection Extensions / Pipe Table\n");
+            TestParser.TestSpec("| a\n| --\n| b\n| c ", "<table>\n<thead>\n<tr>\n<th>a</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>b</td>\n</tr>\n<tr>\n<td>c</td>\n</tr>\n</tbody>\n</table>", "pipetables|advanced");
         }
 
         // **Rule #5**
@@ -471,7 +484,8 @@ namespace Markdig.Tests.Specs.PipeTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec(" a     | b \n-------|-------\n 0     | 1 \n 2     | 3 ", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n<tr>\n<td>2</td>\n<td>3</td>\n</tr>\n</tbody>\n</table>", "pipetables|advanced", context: "Example 14\nSection Extensions / Pipe Table\n");
+            Console.WriteLine("Example 14\nSection Extensions / Pipe Table\n");
+            TestParser.TestSpec(" a     | b \n-------|-------\n 0     | 1 \n 2     | 3 ", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n<tr>\n<td>2</td>\n<td>3</td>\n</tr>\n</tbody>\n</table>", "pipetables|advanced");
         }
 
         // The text alignment is defined by default to be center for header and left for cells. If the left alignment is applied, it will force the column heading to be left aligned.
@@ -512,7 +526,8 @@ namespace Markdig.Tests.Specs.PipeTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec(" a     | b       | c \n:------|:-------:| ----:\n 0     | 1       | 2 \n 3     | 4       | 5 ", "<table>\n<thead>\n<tr>\n<th style=\"text-align: left;\">a</th>\n<th style=\"text-align: center;\">b</th>\n<th style=\"text-align: right;\">c</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td style=\"text-align: left;\">0</td>\n<td style=\"text-align: center;\">1</td>\n<td style=\"text-align: right;\">2</td>\n</tr>\n<tr>\n<td style=\"text-align: left;\">3</td>\n<td style=\"text-align: center;\">4</td>\n<td style=\"text-align: right;\">5</td>\n</tr>\n</tbody>\n</table>", "pipetables|advanced", context: "Example 15\nSection Extensions / Pipe Table\n");
+            Console.WriteLine("Example 15\nSection Extensions / Pipe Table\n");
+            TestParser.TestSpec(" a     | b       | c \n:------|:-------:| ----:\n 0     | 1       | 2 \n 3     | 4       | 5 ", "<table>\n<thead>\n<tr>\n<th style=\"text-align: left;\">a</th>\n<th style=\"text-align: center;\">b</th>\n<th style=\"text-align: right;\">c</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td style=\"text-align: left;\">0</td>\n<td style=\"text-align: center;\">1</td>\n<td style=\"text-align: right;\">2</td>\n</tr>\n<tr>\n<td style=\"text-align: left;\">3</td>\n<td style=\"text-align: center;\">4</td>\n<td style=\"text-align: right;\">5</td>\n</tr>\n</tbody>\n</table>", "pipetables|advanced");
         }
 
         // Test alignment with starting and ending pipes:
@@ -545,7 +560,8 @@ namespace Markdig.Tests.Specs.PipeTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec("| abc | def | ghi |\n|:---:|-----|----:|\n|  1  | 2   | 3   |", "<table>\n<thead>\n<tr>\n<th style=\"text-align: center;\">abc</th>\n<th>def</th>\n<th style=\"text-align: right;\">ghi</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td style=\"text-align: center;\">1</td>\n<td>2</td>\n<td style=\"text-align: right;\">3</td>\n</tr>\n</tbody>\n</table>", "pipetables|advanced", context: "Example 16\nSection Extensions / Pipe Table\n");
+            Console.WriteLine("Example 16\nSection Extensions / Pipe Table\n");
+            TestParser.TestSpec("| abc | def | ghi |\n|:---:|-----|----:|\n|  1  | 2   | 3   |", "<table>\n<thead>\n<tr>\n<th style=\"text-align: center;\">abc</th>\n<th>def</th>\n<th style=\"text-align: right;\">ghi</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td style=\"text-align: center;\">1</td>\n<td>2</td>\n<td style=\"text-align: right;\">3</td>\n</tr>\n</tbody>\n</table>", "pipetables|advanced");
         }
 
         // The following example shows a non matching header column separator:
@@ -567,7 +583,8 @@ namespace Markdig.Tests.Specs.PipeTables
             //     0     | 1
             //     2     | 3</p> 
 
-            TestParser.TestSpec(" a     | b\n-------|---x---\n 0     | 1\n 2     | 3 ", "<p>a     | b\n-------|---x---\n0     | 1\n2     | 3</p> ", "pipetables|advanced", context: "Example 17\nSection Extensions / Pipe Table\n");
+            Console.WriteLine("Example 17\nSection Extensions / Pipe Table\n");
+            TestParser.TestSpec(" a     | b\n-------|---x---\n 0     | 1\n 2     | 3 ", "<p>a     | b\n-------|---x---\n0     | 1\n2     | 3</p> ", "pipetables|advanced");
         }
 
         // **Rule #6**
@@ -605,7 +622,8 @@ namespace Markdig.Tests.Specs.PipeTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec(" *a*   | b\n-----  |-----\n 0     | _1_\n _2    | 3* ", "<table>\n<thead>\n<tr>\n<th><em>a</em></th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td><em>1</em></td>\n</tr>\n<tr>\n<td>_2</td>\n<td>3*</td>\n</tr>\n</tbody>\n</table>", "pipetables|advanced", context: "Example 18\nSection Extensions / Pipe Table\n");
+            Console.WriteLine("Example 18\nSection Extensions / Pipe Table\n");
+            TestParser.TestSpec(" *a*   | b\n-----  |-----\n 0     | _1_\n _2    | 3* ", "<table>\n<thead>\n<tr>\n<th><em>a</em></th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td><em>1</em></td>\n</tr>\n<tr>\n<td>_2</td>\n<td>3*</td>\n</tr>\n</tbody>\n</table>", "pipetables|advanced");
         }
 
         // **Rule #7**
@@ -624,7 +642,8 @@ namespace Markdig.Tests.Specs.PipeTables
             // Should be rendered as:
             //     <p>a | b <code>0 |</code></p> 
 
-            TestParser.TestSpec("a | b `\n0 | ` ", "<p>a | b <code>0 |</code></p> ", "pipetables|advanced", context: "Example 19\nSection Extensions / Pipe Table\n");
+            Console.WriteLine("Example 19\nSection Extensions / Pipe Table\n");
+            TestParser.TestSpec("a | b `\n0 | ` ", "<p>a | b <code>0 |</code></p> ", "pipetables|advanced");
         }
 
         // **Rule #8**
@@ -657,7 +676,8 @@ namespace Markdig.Tests.Specs.PipeTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec("a <a href=\"\" title=\"|\"></a> | b\n-- | --\n0  | 1", "<table>\n<thead>\n<tr>\n<th>a <a href=\"\" title=\"|\"></a></th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>", "pipetables|advanced", context: "Example 20\nSection Extensions / Pipe Table\n");
+            Console.WriteLine("Example 20\nSection Extensions / Pipe Table\n");
+            TestParser.TestSpec("a <a href=\"\" title=\"|\"></a> | b\n-- | --\n0  | 1", "<table>\n<thead>\n<tr>\n<th>a <a href=\"\" title=\"|\"></a></th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>", "pipetables|advanced");
         }
 
         // **Rule #9**
@@ -690,7 +710,8 @@ namespace Markdig.Tests.Specs.PipeTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec("a  | b\n-- | --\n[This is a link with a | inside the label](http://google.com) | 1", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><a href=\"http://google.com\">This is a link with a | inside the label</a></td>\n<td>1</td>\n</tr>\n</tbody>\n</table>", "pipetables|advanced", context: "Example 21\nSection Extensions / Pipe Table\n");
+            Console.WriteLine("Example 21\nSection Extensions / Pipe Table\n");
+            TestParser.TestSpec("a  | b\n-- | --\n[This is a link with a | inside the label](http://google.com) | 1", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td><a href=\"http://google.com\">This is a link with a | inside the label</a></td>\n<td>1</td>\n</tr>\n</tbody>\n</table>", "pipetables|advanced");
         }
 
         // **Rule #10**
@@ -716,7 +737,8 @@ namespace Markdig.Tests.Specs.PipeTables
             //     </thead>
             //     </table>
 
-            TestParser.TestSpec("a  | b\n-- | --", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n</table>", "pipetables|advanced", context: "Example 22\nSection Extensions / Pipe Table\n");
+            Console.WriteLine("Example 22\nSection Extensions / Pipe Table\n");
+            TestParser.TestSpec("a  | b\n-- | --", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n</table>", "pipetables|advanced");
         }
 
         [Test]
@@ -740,7 +762,8 @@ namespace Markdig.Tests.Specs.PipeTables
             //     </thead>
             //     </table>
 
-            TestParser.TestSpec("|a|b|c\n|---|---|---|", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n<th>c</th>\n</tr>\n</thead>\n</table>", "pipetables|advanced", context: "Example 23\nSection Extensions / Pipe Table\n");
+            Console.WriteLine("Example 23\nSection Extensions / Pipe Table\n");
+            TestParser.TestSpec("|a|b|c\n|---|---|---|", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n<th>c</th>\n</tr>\n</thead>\n</table>", "pipetables|advanced");
         }
 
         // **Tests**
@@ -788,7 +811,8 @@ namespace Markdig.Tests.Specs.PipeTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec("| abc | def | \n|---|---|\n| cde| ddd| \n| eee| fff|\n| fff | fffff   | \n|gggg  | ffff | ", "<table>\n<thead>\n<tr>\n<th>abc</th>\n<th>def</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>cde</td>\n<td>ddd</td>\n</tr>\n<tr>\n<td>eee</td>\n<td>fff</td>\n</tr>\n<tr>\n<td>fff</td>\n<td>fffff</td>\n</tr>\n<tr>\n<td>gggg</td>\n<td>ffff</td>\n</tr>\n</tbody>\n</table>", "pipetables|advanced", context: "Example 24\nSection Extensions / Pipe Table\n");
+            Console.WriteLine("Example 24\nSection Extensions / Pipe Table\n");
+            TestParser.TestSpec("| abc | def | \n|---|---|\n| cde| ddd| \n| eee| fff|\n| fff | fffff   | \n|gggg  | ffff | ", "<table>\n<thead>\n<tr>\n<th>abc</th>\n<th>def</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>cde</td>\n<td>ddd</td>\n</tr>\n<tr>\n<td>eee</td>\n<td>fff</td>\n</tr>\n<tr>\n<td>fff</td>\n<td>fffff</td>\n</tr>\n<tr>\n<td>gggg</td>\n<td>ffff</td>\n</tr>\n</tbody>\n</table>", "pipetables|advanced");
         }
 
         // **Normalized columns count**
@@ -823,192 +847,8 @@ namespace Markdig.Tests.Specs.PipeTables
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec("a | b\n-- | - \n0 | 1 | 2", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n<th></th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n<td>2</td>\n</tr>\n</tbody>\n</table>", "pipetables|advanced", context: "Example 25\nSection Extensions / Pipe Table\n");
-        }
-
-        // A table may begin right after a paragraph without an empty line in between:
-        [Test]
-        public void ExtensionsPipeTable_Example026()
-        {
-            // Example 26
-            // Section: Extensions / Pipe Table
-            //
-            // The following Markdown:
-            //     Some
-            //     **text**.
-            //     | A |
-            //     |---|
-            //     | B |
-            //
-            // Should be rendered as:
-            //     <p>Some
-            //     <strong>text</strong>.</p>
-            //     <table>
-            //     <thead>
-            //     <tr>
-            //     <th>A</th>
-            //     </tr>
-            //     </thead>
-            //     <tbody>
-            //     <tr>
-            //     <td>B</td>
-            //     </tr>
-            //     </tbody>
-            //     </table>
-
-            TestParser.TestSpec("Some\n**text**.\n| A |\n|---|\n| B |", "<p>Some\n<strong>text</strong>.</p>\n<table>\n<thead>\n<tr>\n<th>A</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>B</td>\n</tr>\n</tbody>\n</table>", "pipetables|advanced", context: "Example 26\nSection Extensions / Pipe Table\n");
-        }
-
-        // Tables can be nested inside other blocks, like lists:
-        [Test]
-        public void ExtensionsPipeTable_Example027()
-        {
-            // Example 27
-            // Section: Extensions / Pipe Table
-            //
-            // The following Markdown:
-            //     Bullet list
-            //     * Table 1
-            //     
-            //         | Header 1       | Header 2       |
-            //         |----------------|----------------|
-            //         | Row 1 Column 1 | Row 1 Column 2 |
-            //     
-            //     * Table 2
-            //         | Header 1       | Header 2       |
-            //         |----------------|----------------|
-            //         | Row 1 Column 1 | Row 1 Column 2 |
-            //     
-            //     * Table 3
-            //       Lorem ipsum ...
-            //       Lorem ipsum ...
-            //         | Header 1       | Header 2       |
-            //         |----------------|----------------|
-            //         | Row 1 Column 1 | Row 1 Column 2 |
-            //     
-            //     
-            //     Ordered list
-            //     1. Table 1
-            //     
-            //         | Header 1       | Header 2       |
-            //         |----------------|----------------|
-            //         | Row 1 Column 1 | Row 1 Column 2 |
-            //     
-            //     2. Table 2
-            //         | Header 1       | Header 2       |
-            //         |----------------|----------------|
-            //         | Row 1 Column 1 | Row 1 Column 2 |
-            //     
-            //     3. Table 3
-            //        Lorem ipsum ...
-            //        Lorem ipsum ...
-            //         | Header 1       | Header 2       |
-            //         |----------------|----------------|
-            //         | Row 1 Column 1 | Row 1 Column 2 |
-            //
-            // Should be rendered as:
-            //     <p>Bullet list</p>
-            //     <ul>
-            //     <li><p>Table 1</p>
-            //     <table>
-            //     <thead>
-            //     <tr>
-            //     <th>Header 1</th>
-            //     <th>Header 2</th>
-            //     </tr>
-            //     </thead>
-            //     <tbody>
-            //     <tr>
-            //     <td>Row 1 Column 1</td>
-            //     <td>Row 1 Column 2</td>
-            //     </tr>
-            //     </tbody>
-            //     </table></li>
-            //     <li><p>Table 2</p>
-            //     <table>
-            //     <thead>
-            //     <tr>
-            //     <th>Header 1</th>
-            //     <th>Header 2</th>
-            //     </tr>
-            //     </thead>
-            //     <tbody>
-            //     <tr>
-            //     <td>Row 1 Column 1</td>
-            //     <td>Row 1 Column 2</td>
-            //     </tr>
-            //     </tbody>
-            //     </table></li>
-            //     <li><p>Table 3
-            //     Lorem ipsum ...
-            //     Lorem ipsum ...</p>
-            //     <table>
-            //     <thead>
-            //     <tr>
-            //     <th>Header 1</th>
-            //     <th>Header 2</th>
-            //     </tr>
-            //     </thead>
-            //     <tbody>
-            //     <tr>
-            //     <td>Row 1 Column 1</td>
-            //     <td>Row 1 Column 2</td>
-            //     </tr>
-            //     </tbody>
-            //     </table></li>
-            //     </ul>
-            //     <p>Ordered list</p>
-            //     <ol>
-            //     <li><p>Table 1</p>
-            //     <table>
-            //     <thead>
-            //     <tr>
-            //     <th>Header 1</th>
-            //     <th>Header 2</th>
-            //     </tr>
-            //     </thead>
-            //     <tbody>
-            //     <tr>
-            //     <td>Row 1 Column 1</td>
-            //     <td>Row 1 Column 2</td>
-            //     </tr>
-            //     </tbody>
-            //     </table></li>
-            //     <li><p>Table 2</p>
-            //     <table>
-            //     <thead>
-            //     <tr>
-            //     <th>Header 1</th>
-            //     <th>Header 2</th>
-            //     </tr>
-            //     </thead>
-            //     <tbody>
-            //     <tr>
-            //     <td>Row 1 Column 1</td>
-            //     <td>Row 1 Column 2</td>
-            //     </tr>
-            //     </tbody>
-            //     </table></li>
-            //     <li><p>Table 3
-            //     Lorem ipsum ...
-            //     Lorem ipsum ...</p>
-            //     <table>
-            //     <thead>
-            //     <tr>
-            //     <th>Header 1</th>
-            //     <th>Header 2</th>
-            //     </tr>
-            //     </thead>
-            //     <tbody>
-            //     <tr>
-            //     <td>Row 1 Column 1</td>
-            //     <td>Row 1 Column 2</td>
-            //     </tr>
-            //     </tbody>
-            //     </table></li>
-            //     </ol>
-
-            TestParser.TestSpec("Bullet list\n* Table 1\n\n    | Header 1       | Header 2       |\n    |----------------|----------------|\n    | Row 1 Column 1 | Row 1 Column 2 |\n\n* Table 2\n    | Header 1       | Header 2       |\n    |----------------|----------------|\n    | Row 1 Column 1 | Row 1 Column 2 |\n\n* Table 3\n  Lorem ipsum ...\n  Lorem ipsum ...\n    | Header 1       | Header 2       |\n    |----------------|----------------|\n    | Row 1 Column 1 | Row 1 Column 2 |\n\n\nOrdered list\n1. Table 1\n\n    | Header 1       | Header 2       |\n    |----------------|----------------|\n    | Row 1 Column 1 | Row 1 Column 2 |\n\n2. Table 2\n    | Header 1       | Header 2       |\n    |----------------|----------------|\n    | Row 1 Column 1 | Row 1 Column 2 |\n\n3. Table 3\n   Lorem ipsum ...\n   Lorem ipsum ...\n    | Header 1       | Header 2       |\n    |----------------|----------------|\n    | Row 1 Column 1 | Row 1 Column 2 |", "<p>Bullet list</p>\n<ul>\n<li><p>Table 1</p>\n<table>\n<thead>\n<tr>\n<th>Header 1</th>\n<th>Header 2</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Row 1 Column 1</td>\n<td>Row 1 Column 2</td>\n</tr>\n</tbody>\n</table></li>\n<li><p>Table 2</p>\n<table>\n<thead>\n<tr>\n<th>Header 1</th>\n<th>Header 2</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Row 1 Column 1</td>\n<td>Row 1 Column 2</td>\n</tr>\n</tbody>\n</table></li>\n<li><p>Table 3\nLorem ipsum ...\nLorem ipsum ...</p>\n<table>\n<thead>\n<tr>\n<th>Header 1</th>\n<th>Header 2</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Row 1 Column 1</td>\n<td>Row 1 Column 2</td>\n</tr>\n</tbody>\n</table></li>\n</ul>\n<p>Ordered list</p>\n<ol>\n<li><p>Table 1</p>\n<table>\n<thead>\n<tr>\n<th>Header 1</th>\n<th>Header 2</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Row 1 Column 1</td>\n<td>Row 1 Column 2</td>\n</tr>\n</tbody>\n</table></li>\n<li><p>Table 2</p>\n<table>\n<thead>\n<tr>\n<th>Header 1</th>\n<th>Header 2</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Row 1 Column 1</td>\n<td>Row 1 Column 2</td>\n</tr>\n</tbody>\n</table></li>\n<li><p>Table 3\nLorem ipsum ...\nLorem ipsum ...</p>\n<table>\n<thead>\n<tr>\n<th>Header 1</th>\n<th>Header 2</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>Row 1 Column 1</td>\n<td>Row 1 Column 2</td>\n</tr>\n</tbody>\n</table></li>\n</ol>", "pipetables|advanced", context: "Example 27\nSection Extensions / Pipe Table\n");
+            Console.WriteLine("Example 25\nSection Extensions / Pipe Table\n");
+            TestParser.TestSpec("a | b\n-- | - \n0 | 1 | 2", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n<th></th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n<td>2</td>\n</tr>\n</tbody>\n</table>", "pipetables|advanced");
         }
     }
 }

src/Markdig.Tests/Specs/PipeTableSpecs.md

@@ -612,173 +612,4 @@ a | b
 </tr>
 </tbody>
 </table>
-````````````````````````````````
-
-A table may begin right after a paragraph without an empty line in between:
-
-```````````````````````````````` example
-Some
-**text**.
-| A |
-|---|
-| B |
-.
-<p>Some
-<strong>text</strong>.</p>
-<table>
-<thead>
-<tr>
-<th>A</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td>B</td>
-</tr>
-</tbody>
-</table>
-````````````````````````````````
-
-Tables can be nested inside other blocks, like lists:
-
-```````````````````````````````` example
-Bullet list
-* Table 1
-
-    | Header 1       | Header 2       |
-    |----------------|----------------|
-    | Row 1 Column 1 | Row 1 Column 2 |
-
-* Table 2
-    | Header 1       | Header 2       |
-    |----------------|----------------|
-    | Row 1 Column 1 | Row 1 Column 2 |
-
-* Table 3
-  Lorem ipsum ...
-  Lorem ipsum ...
-    | Header 1       | Header 2       |
-    |----------------|----------------|
-    | Row 1 Column 1 | Row 1 Column 2 |
-
-
-Ordered list
-1. Table 1
-
-    | Header 1       | Header 2       |
-    |----------------|----------------|
-    | Row 1 Column 1 | Row 1 Column 2 |
-
-2. Table 2
-    | Header 1       | Header 2       |
-    |----------------|----------------|
-    | Row 1 Column 1 | Row 1 Column 2 |
-
-3. Table 3
-   Lorem ipsum ...
-   Lorem ipsum ...
-    | Header 1       | Header 2       |
-    |----------------|----------------|
-    | Row 1 Column 1 | Row 1 Column 2 |
-.
-<p>Bullet list</p>
-<ul>
-<li><p>Table 1</p>
-<table>
-<thead>
-<tr>
-<th>Header 1</th>
-<th>Header 2</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td>Row 1 Column 1</td>
-<td>Row 1 Column 2</td>
-</tr>
-</tbody>
-</table></li>
-<li><p>Table 2</p>
-<table>
-<thead>
-<tr>
-<th>Header 1</th>
-<th>Header 2</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td>Row 1 Column 1</td>
-<td>Row 1 Column 2</td>
-</tr>
-</tbody>
-</table></li>
-<li><p>Table 3
-Lorem ipsum ...
-Lorem ipsum ...</p>
-<table>
-<thead>
-<tr>
-<th>Header 1</th>
-<th>Header 2</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td>Row 1 Column 1</td>
-<td>Row 1 Column 2</td>
-</tr>
-</tbody>
-</table></li>
-</ul>
-<p>Ordered list</p>
-<ol>
-<li><p>Table 1</p>
-<table>
-<thead>
-<tr>
-<th>Header 1</th>
-<th>Header 2</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td>Row 1 Column 1</td>
-<td>Row 1 Column 2</td>
-</tr>
-</tbody>
-</table></li>
-<li><p>Table 2</p>
-<table>
-<thead>
-<tr>
-<th>Header 1</th>
-<th>Header 2</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td>Row 1 Column 1</td>
-<td>Row 1 Column 2</td>
-</tr>
-</tbody>
-</table></li>
-<li><p>Table 3
-Lorem ipsum ...
-Lorem ipsum ...</p>
-<table>
-<thead>
-<tr>
-<th>Header 1</th>
-<th>Header 2</th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td>Row 1 Column 1</td>
-<td>Row 1 Column 2</td>
-</tr>
-</tbody>
-</table></li>
-</ol>
 ````````````````````````````````

src/Markdig.Tests/Specs/SmartyPantsSpecs.generated.cs

@@ -30,7 +30,8 @@ namespace Markdig.Tests.Specs.SmartyPants
             // Should be rendered as:
             //     <p>This is a &ldquo;text&rdquo;</p>
 
-            TestParser.TestSpec("This is a \"text\"", "<p>This is a &ldquo;text&rdquo;</p>", "pipetables+smartypants|advanced+smartypants", context: "Example 1\nSection Extensions / SmartyPants Quotes\n");
+            Console.WriteLine("Example 1\nSection Extensions / SmartyPants Quotes\n");
+            TestParser.TestSpec("This is a \"text\"", "<p>This is a &ldquo;text&rdquo;</p>", "pipetables+smartypants|advanced+smartypants");
         }
 
         [Test]
@@ -45,7 +46,8 @@ namespace Markdig.Tests.Specs.SmartyPants
             // Should be rendered as:
             //     <p>This is a &lsquo;text&rsquo;</p>
 
-            TestParser.TestSpec("This is a 'text'", "<p>This is a &lsquo;text&rsquo;</p>", "pipetables+smartypants|advanced+smartypants", context: "Example 2\nSection Extensions / SmartyPants Quotes\n");
+            Console.WriteLine("Example 2\nSection Extensions / SmartyPants Quotes\n");
+            TestParser.TestSpec("This is a 'text'", "<p>This is a &lsquo;text&rsquo;</p>", "pipetables+smartypants|advanced+smartypants");
         }
 
         [Test]
@@ -60,7 +62,8 @@ namespace Markdig.Tests.Specs.SmartyPants
             // Should be rendered as:
             //     <p>This is a &laquo;text&raquo;</p>
 
-            TestParser.TestSpec("This is a <<text>>", "<p>This is a &laquo;text&raquo;</p>", "pipetables+smartypants|advanced+smartypants", context: "Example 3\nSection Extensions / SmartyPants Quotes\n");
+            Console.WriteLine("Example 3\nSection Extensions / SmartyPants Quotes\n");
+            TestParser.TestSpec("This is a <<text>>", "<p>This is a &laquo;text&raquo;</p>", "pipetables+smartypants|advanced+smartypants");
         }
 
         // Unbalanced quotes are not changed:
@@ -76,7 +79,8 @@ namespace Markdig.Tests.Specs.SmartyPants
             // Should be rendered as:
             //     <p>This is a &quot;text</p>
 
-            TestParser.TestSpec("This is a \"text", "<p>This is a &quot;text</p>", "pipetables+smartypants|advanced+smartypants", context: "Example 4\nSection Extensions / SmartyPants Quotes\n");
+            Console.WriteLine("Example 4\nSection Extensions / SmartyPants Quotes\n");
+            TestParser.TestSpec("This is a \"text", "<p>This is a &quot;text</p>", "pipetables+smartypants|advanced+smartypants");
         }
 
         [Test]
@@ -91,7 +95,8 @@ namespace Markdig.Tests.Specs.SmartyPants
             // Should be rendered as:
             //     <p>This is a 'text</p>
 
-            TestParser.TestSpec("This is a 'text", "<p>This is a 'text</p>", "pipetables+smartypants|advanced+smartypants", context: "Example 5\nSection Extensions / SmartyPants Quotes\n");
+            Console.WriteLine("Example 5\nSection Extensions / SmartyPants Quotes\n");
+            TestParser.TestSpec("This is a 'text", "<p>This is a 'text</p>", "pipetables+smartypants|advanced+smartypants");
         }
 
         [Test]
@@ -106,7 +111,8 @@ namespace Markdig.Tests.Specs.SmartyPants
             // Should be rendered as:
             //     <p>This is a &lt;&lt;text</p>
 
-            TestParser.TestSpec("This is a <<text", "<p>This is a &lt;&lt;text</p>", "pipetables+smartypants|advanced+smartypants", context: "Example 6\nSection Extensions / SmartyPants Quotes\n");
+            Console.WriteLine("Example 6\nSection Extensions / SmartyPants Quotes\n");
+            TestParser.TestSpec("This is a <<text", "<p>This is a &lt;&lt;text</p>", "pipetables+smartypants|advanced+smartypants");
         }
 
         // Unbalanced quotes inside other quotes are not changed:
@@ -122,7 +128,8 @@ namespace Markdig.Tests.Specs.SmartyPants
             // Should be rendered as:
             //     <p>This is a &ldquo;text 'with&rdquo; a another text'</p>
 
-            TestParser.TestSpec("This is a \"text 'with\" a another text'", "<p>This is a &ldquo;text 'with&rdquo; a another text'</p>", "pipetables+smartypants|advanced+smartypants", context: "Example 7\nSection Extensions / SmartyPants Quotes\n");
+            Console.WriteLine("Example 7\nSection Extensions / SmartyPants Quotes\n");
+            TestParser.TestSpec("This is a \"text 'with\" a another text'", "<p>This is a &ldquo;text 'with&rdquo; a another text'</p>", "pipetables+smartypants|advanced+smartypants");
         }
 
         [Test]
@@ -137,7 +144,8 @@ namespace Markdig.Tests.Specs.SmartyPants
             // Should be rendered as:
             //     <p>This is &lsquo;a &ldquo;text 'with&rdquo; a another text&rsquo;</p>
 
-            TestParser.TestSpec("This is 'a \"text 'with\" a another text'", "<p>This is &lsquo;a &ldquo;text 'with&rdquo; a another text&rsquo;</p>", "pipetables+smartypants|advanced+smartypants", context: "Example 8\nSection Extensions / SmartyPants Quotes\n");
+            Console.WriteLine("Example 8\nSection Extensions / SmartyPants Quotes\n");
+            TestParser.TestSpec("This is 'a \"text 'with\" a another text'", "<p>This is &lsquo;a &ldquo;text 'with&rdquo; a another text&rsquo;</p>", "pipetables+smartypants|advanced+smartypants");
         }
 
         [Test]
@@ -152,7 +160,8 @@ namespace Markdig.Tests.Specs.SmartyPants
             // Should be rendered as:
             //     <p>This is a &lsquo;text &lt;&lt;with&rsquo; a another text&gt;&gt;</p>
 
-            TestParser.TestSpec("This is a 'text <<with' a another text>>", "<p>This is a &lsquo;text &lt;&lt;with&rsquo; a another text&gt;&gt;</p>", "pipetables+smartypants|advanced+smartypants", context: "Example 9\nSection Extensions / SmartyPants Quotes\n");
+            Console.WriteLine("Example 9\nSection Extensions / SmartyPants Quotes\n");
+            TestParser.TestSpec("This is a 'text <<with' a another text>>", "<p>This is a &lsquo;text &lt;&lt;with&rsquo; a another text&gt;&gt;</p>", "pipetables+smartypants|advanced+smartypants");
         }
 
         [Test]
@@ -167,7 +176,8 @@ namespace Markdig.Tests.Specs.SmartyPants
             // Should be rendered as:
             //     <p>This is a &laquo;text 'with&raquo; a another text'</p>
 
-            TestParser.TestSpec("This is a <<text 'with>> a another text'", "<p>This is a &laquo;text 'with&raquo; a another text'</p>", "pipetables+smartypants|advanced+smartypants", context: "Example 10\nSection Extensions / SmartyPants Quotes\n");
+            Console.WriteLine("Example 10\nSection Extensions / SmartyPants Quotes\n");
+            TestParser.TestSpec("This is a <<text 'with>> a another text'", "<p>This is a &laquo;text 'with&raquo; a another text'</p>", "pipetables+smartypants|advanced+smartypants");
         }
 
         // Quotes requires to have the same rules than emphasis `_` regarding left/right frankling rules:
@@ -183,7 +193,8 @@ namespace Markdig.Tests.Specs.SmartyPants
             // Should be rendered as:
             //     <p>It's not quotes'</p>
 
-            TestParser.TestSpec("It's not quotes'", "<p>It's not quotes'</p>", "pipetables+smartypants|advanced+smartypants", context: "Example 11\nSection Extensions / SmartyPants Quotes\n");
+            Console.WriteLine("Example 11\nSection Extensions / SmartyPants Quotes\n");
+            TestParser.TestSpec("It's not quotes'", "<p>It's not quotes'</p>", "pipetables+smartypants|advanced+smartypants");
         }
 
         [Test]
@@ -198,7 +209,8 @@ namespace Markdig.Tests.Specs.SmartyPants
             // Should be rendered as:
             //     <p>They are ' not matching quotes '</p>
 
-            TestParser.TestSpec("They are ' not matching quotes '", "<p>They are ' not matching quotes '</p>", "pipetables+smartypants|advanced+smartypants", context: "Example 12\nSection Extensions / SmartyPants Quotes\n");
+            Console.WriteLine("Example 12\nSection Extensions / SmartyPants Quotes\n");
+            TestParser.TestSpec("They are ' not matching quotes '", "<p>They are ' not matching quotes '</p>", "pipetables+smartypants|advanced+smartypants");
         }
 
         [Test]
@@ -213,7 +225,8 @@ namespace Markdig.Tests.Specs.SmartyPants
             // Should be rendered as:
             //     <p>They are' not matching 'quotes</p>
 
-            TestParser.TestSpec("They are' not matching 'quotes", "<p>They are' not matching 'quotes</p>", "pipetables+smartypants|advanced+smartypants", context: "Example 13\nSection Extensions / SmartyPants Quotes\n");
+            Console.WriteLine("Example 13\nSection Extensions / SmartyPants Quotes\n");
+            TestParser.TestSpec("They are' not matching 'quotes", "<p>They are' not matching 'quotes</p>", "pipetables+smartypants|advanced+smartypants");
         }
 
         // An emphasis starting inside left/right quotes will span over the right quote:
@@ -229,7 +242,8 @@ namespace Markdig.Tests.Specs.SmartyPants
             // Should be rendered as:
             //     <p>This is &ldquo;a <em>text&rdquo; with an emphasis</em></p>
 
-            TestParser.TestSpec("This is \"a *text\" with an emphasis*", "<p>This is &ldquo;a <em>text&rdquo; with an emphasis</em></p>", "pipetables+smartypants|advanced+smartypants", context: "Example 14\nSection Extensions / SmartyPants Quotes\n");
+            Console.WriteLine("Example 14\nSection Extensions / SmartyPants Quotes\n");
+            TestParser.TestSpec("This is \"a *text\" with an emphasis*", "<p>This is &ldquo;a <em>text&rdquo; with an emphasis</em></p>", "pipetables+smartypants|advanced+smartypants");
         }
 
         // Multiple sets of quotes can be used
@@ -245,7 +259,8 @@ namespace Markdig.Tests.Specs.SmartyPants
             // Should be rendered as:
             //     <p>&ldquo;aaa&rdquo; &ldquo;bbb&rdquo; &ldquo;ccc&rdquo; &ldquo;ddd&rdquo;</p>
 
-            TestParser.TestSpec("\"aaa\" \"bbb\" \"ccc\" \"ddd\"", "<p>&ldquo;aaa&rdquo; &ldquo;bbb&rdquo; &ldquo;ccc&rdquo; &ldquo;ddd&rdquo;</p>", "pipetables+smartypants|advanced+smartypants", context: "Example 15\nSection Extensions / SmartyPants Quotes\n");
+            Console.WriteLine("Example 15\nSection Extensions / SmartyPants Quotes\n");
+            TestParser.TestSpec("\"aaa\" \"bbb\" \"ccc\" \"ddd\"", "<p>&ldquo;aaa&rdquo; &ldquo;bbb&rdquo; &ldquo;ccc&rdquo; &ldquo;ddd&rdquo;</p>", "pipetables+smartypants|advanced+smartypants");
         }
     }
 
@@ -265,7 +280,8 @@ namespace Markdig.Tests.Specs.SmartyPants
             // Should be rendered as:
             //     <p>This is a &ndash; text</p>
 
-            TestParser.TestSpec("This is a -- text", "<p>This is a &ndash; text</p>", "pipetables+smartypants|advanced+smartypants", context: "Example 16\nSection Extensions / SmartyPants Separators\n");
+            Console.WriteLine("Example 16\nSection Extensions / SmartyPants Separators\n");
+            TestParser.TestSpec("This is a -- text", "<p>This is a &ndash; text</p>", "pipetables+smartypants|advanced+smartypants");
         }
 
         [Test]
@@ -280,7 +296,8 @@ namespace Markdig.Tests.Specs.SmartyPants
             // Should be rendered as:
             //     <p>This is a &mdash; text</p>
 
-            TestParser.TestSpec("This is a --- text", "<p>This is a &mdash; text</p>", "pipetables+smartypants|advanced+smartypants", context: "Example 17\nSection Extensions / SmartyPants Separators\n");
+            Console.WriteLine("Example 17\nSection Extensions / SmartyPants Separators\n");
+            TestParser.TestSpec("This is a --- text", "<p>This is a &mdash; text</p>", "pipetables+smartypants|advanced+smartypants");
         }
 
         [Test]
@@ -295,7 +312,8 @@ namespace Markdig.Tests.Specs.SmartyPants
             // Should be rendered as:
             //     <p>This is a en ellipsis&hellip;</p>
 
-            TestParser.TestSpec("This is a en ellipsis...", "<p>This is a en ellipsis&hellip;</p>", "pipetables+smartypants|advanced+smartypants", context: "Example 18\nSection Extensions / SmartyPants Separators\n");
+            Console.WriteLine("Example 18\nSection Extensions / SmartyPants Separators\n");
+            TestParser.TestSpec("This is a en ellipsis...", "<p>This is a en ellipsis&hellip;</p>", "pipetables+smartypants|advanced+smartypants");
         }
 
         // Check that a smartypants are not breaking pipetable parsing:
@@ -326,7 +344,8 @@ namespace Markdig.Tests.Specs.SmartyPants
             //     </tbody>
             //     </table>
 
-            TestParser.TestSpec("a  | b\n-- | --\n0  | 1", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>", "pipetables+smartypants|advanced+smartypants", context: "Example 19\nSection Extensions / SmartyPants Separators\n");
+            Console.WriteLine("Example 19\nSection Extensions / SmartyPants Separators\n");
+            TestParser.TestSpec("a  | b\n-- | --\n0  | 1", "<table>\n<thead>\n<tr>\n<th>a</th>\n<th>b</th>\n</tr>\n</thead>\n<tbody>\n<tr>\n<td>0</td>\n<td>1</td>\n</tr>\n</tbody>\n</table>", "pipetables+smartypants|advanced+smartypants");
         }
 
         // Check quotes and dash:
@@ -342,7 +361,8 @@ namespace Markdig.Tests.Specs.SmartyPants
             // Should be rendered as:
             //     <p>A &ldquo;quote&rdquo; with a &mdash;</p>
 
-            TestParser.TestSpec("A \"quote\" with a ---", "<p>A &ldquo;quote&rdquo; with a &mdash;</p>", "pipetables+smartypants|advanced+smartypants", context: "Example 20\nSection Extensions / SmartyPants Separators\n");
+            Console.WriteLine("Example 20\nSection Extensions / SmartyPants Separators\n");
+            TestParser.TestSpec("A \"quote\" with a ---", "<p>A &ldquo;quote&rdquo; with a &mdash;</p>", "pipetables+smartypants|advanced+smartypants");
         }
     }
 }

src/Markdig.Tests/Specs/TaskListSpecs.generated.cs

@@ -38,7 +38,8 @@ namespace Markdig.Tests.Specs.TaskLists
             //     <li>Item4</li>
             //     </ul>
 
-            TestParser.TestSpec("- [ ] Item1\n- [x] Item2\n- [ ] Item3\n- Item4", "<ul class=\"contains-task-list\">\n<li class=\"task-list-item\"><input disabled=\"disabled\" type=\"checkbox\" /> Item1</li>\n<li class=\"task-list-item\"><input disabled=\"disabled\" type=\"checkbox\" checked=\"checked\" /> Item2</li>\n<li class=\"task-list-item\"><input disabled=\"disabled\" type=\"checkbox\" /> Item3</li>\n<li>Item4</li>\n</ul>", "tasklists|advanced", context: "Example 1\nSection Extensions / TaskLists\n");
+            Console.WriteLine("Example 1\nSection Extensions / TaskLists\n");
+            TestParser.TestSpec("- [ ] Item1\n- [x] Item2\n- [ ] Item3\n- Item4", "<ul class=\"contains-task-list\">\n<li class=\"task-list-item\"><input disabled=\"disabled\" type=\"checkbox\" /> Item1</li>\n<li class=\"task-list-item\"><input disabled=\"disabled\" type=\"checkbox\" checked=\"checked\" /> Item2</li>\n<li class=\"task-list-item\"><input disabled=\"disabled\" type=\"checkbox\" /> Item3</li>\n<li>Item4</li>\n</ul>", "tasklists|advanced");
         }
 
         // A task is not recognized outside a list item:
@@ -54,7 +55,8 @@ namespace Markdig.Tests.Specs.TaskLists
             // Should be rendered as:
             //     <p>[ ] This is not a task list</p>
 
-            TestParser.TestSpec("[ ] This is not a task list", "<p>[ ] This is not a task list</p>", "tasklists|advanced", context: "Example 2\nSection Extensions / TaskLists\n");
+            Console.WriteLine("Example 2\nSection Extensions / TaskLists\n");
+            TestParser.TestSpec("[ ] This is not a task list", "<p>[ ] This is not a task list</p>", "tasklists|advanced");
         }
     }
 }

src/Markdig.Tests/Specs/YamlSpecs.generated.cs

@@ -33,7 +33,8 @@ namespace Markdig.Tests.Specs.Yaml
             // Should be rendered as:
             //     <p>This is a text</p>
 
-            TestParser.TestSpec("---\nthis: is a frontmatter\n---\nThis is a text", "<p>This is a text</p>", "yaml", context: "Example 1\nSection Extensions / YAML frontmatter discard\n");
+            Console.WriteLine("Example 1\nSection Extensions / YAML frontmatter discard\n");
+            TestParser.TestSpec("---\nthis: is a frontmatter\n---\nThis is a text", "<p>This is a text</p>", "yaml");
         }
 
         // But if a frontmatter doesn't happen on the first line, it will be parse as regular Markdown content
@@ -55,7 +56,8 @@ namespace Markdig.Tests.Specs.Yaml
             //     <h2>this: is a frontmatter</h2>
             //     <p>This is a text2</p>
 
-            TestParser.TestSpec("This is a text1\n---\nthis: is a frontmatter\n---\nThis is a text2", "<h2>This is a text1</h2>\n<h2>this: is a frontmatter</h2>\n<p>This is a text2</p>", "yaml", context: "Example 2\nSection Extensions / YAML frontmatter discard\n");
+            Console.WriteLine("Example 2\nSection Extensions / YAML frontmatter discard\n");
+            TestParser.TestSpec("This is a text1\n---\nthis: is a frontmatter\n---\nThis is a text2", "<h2>This is a text1</h2>\n<h2>this: is a frontmatter</h2>\n<p>This is a text2</p>", "yaml");
         }
 
         // It expects an exact 3 dashes `---`:
@@ -76,7 +78,8 @@ namespace Markdig.Tests.Specs.Yaml
             //     <h2>this: is a frontmatter</h2>
             //     <p>This is a text</p>
 
-            TestParser.TestSpec("----\nthis: is a frontmatter\n----\nThis is a text", "<hr />\n<h2>this: is a frontmatter</h2>\n<p>This is a text</p>", "yaml", context: "Example 3\nSection Extensions / YAML frontmatter discard\n");
+            Console.WriteLine("Example 3\nSection Extensions / YAML frontmatter discard\n");
+            TestParser.TestSpec("----\nthis: is a frontmatter\n----\nThis is a text", "<hr />\n<h2>this: is a frontmatter</h2>\n<p>This is a text</p>", "yaml");
         }
 
         // It can end with three dots `...`:
@@ -96,7 +99,8 @@ namespace Markdig.Tests.Specs.Yaml
             // Should be rendered as:
             //     <p>This is a text</p>
 
-            TestParser.TestSpec("---\nthis: is a frontmatter\n\n...\nThis is a text", "<p>This is a text</p>", "yaml", context: "Example 4\nSection Extensions / YAML frontmatter discard\n");
+            Console.WriteLine("Example 4\nSection Extensions / YAML frontmatter discard\n");
+            TestParser.TestSpec("---\nthis: is a frontmatter\n\n...\nThis is a text", "<p>This is a text</p>", "yaml");
         }
 
         // If the end front matter marker (`...` or `---`) is not present, it will render the `---` has a `<hr>`:
@@ -116,7 +120,8 @@ namespace Markdig.Tests.Specs.Yaml
             //     <p>this: is a frontmatter
             //     This is a text</p>
 
-            TestParser.TestSpec("---\nthis: is a frontmatter\nThis is a text", "<hr />\n<p>this: is a frontmatter\nThis is a text</p>", "yaml", context: "Example 5\nSection Extensions / YAML frontmatter discard\n");
+            Console.WriteLine("Example 5\nSection Extensions / YAML frontmatter discard\n");
+            TestParser.TestSpec("---\nthis: is a frontmatter\nThis is a text", "<hr />\n<p>this: is a frontmatter\nThis is a text</p>", "yaml");
         }
 
         // It expects exactly three dots `...`:
@@ -138,7 +143,8 @@ namespace Markdig.Tests.Specs.Yaml
             //     ....
             //     This is a text</p>
 
-            TestParser.TestSpec("---\nthis: is a frontmatter\n....\nThis is a text", "<hr />\n<p>this: is a frontmatter\n....\nThis is a text</p>", "yaml", context: "Example 6\nSection Extensions / YAML frontmatter discard\n");
+            Console.WriteLine("Example 6\nSection Extensions / YAML frontmatter discard\n");
+            TestParser.TestSpec("---\nthis: is a frontmatter\n....\nThis is a text", "<hr />\n<p>this: is a frontmatter\n....\nThis is a text</p>", "yaml");
         }
 
         // Front matter ends with the first line containing three dots `...` or three dashes `---`:
@@ -160,7 +166,8 @@ namespace Markdig.Tests.Specs.Yaml
             // Should be rendered as:
             //     <p>This is a text</p>
 
-            TestParser.TestSpec("---\nthis: is a frontmatter\n....\n\nHello\n---\nThis is a text", "<p>This is a text</p>", "yaml", context: "Example 7\nSection Extensions / YAML frontmatter discard\n");
+            Console.WriteLine("Example 7\nSection Extensions / YAML frontmatter discard\n");
+            TestParser.TestSpec("---\nthis: is a frontmatter\n....\n\nHello\n---\nThis is a text", "<p>This is a text</p>", "yaml");
         }
 
         // It expects whitespace can exist after the leading characters
@@ -179,7 +186,8 @@ namespace Markdig.Tests.Specs.Yaml
             // Should be rendered as:
             //     <p>This is a text</p>
 
-            TestParser.TestSpec("---   \nthis: is a frontmatter\n...\nThis is a text", "<p>This is a text</p>", "yaml", context: "Example 8\nSection Extensions / YAML frontmatter discard\n");
+            Console.WriteLine("Example 8\nSection Extensions / YAML frontmatter discard\n");
+            TestParser.TestSpec("---   \nthis: is a frontmatter\n...\nThis is a text", "<p>This is a text</p>", "yaml");
         }
 
         // It expects whitespace can exist after the trailing characters
@@ -198,7 +206,8 @@ namespace Markdig.Tests.Specs.Yaml
             // Should be rendered as:
             //     <p>This is a text</p>
 
-            TestParser.TestSpec("---\nthis: is a frontmatter\n...     \nThis is a text", "<p>This is a text</p>", "yaml", context: "Example 9\nSection Extensions / YAML frontmatter discard\n");
+            Console.WriteLine("Example 9\nSection Extensions / YAML frontmatter discard\n");
+            TestParser.TestSpec("---\nthis: is a frontmatter\n...     \nThis is a text", "<p>This is a text</p>", "yaml");
         }
     }
 }

src/Markdig.Tests/TestAutoLinks.cs

@@ -1,24 +0,0 @@
-using Markdig.Extensions.AutoLinks;
-
-namespace Markdig.Tests;
-
-[TestFixture]
-public class TestAutoLinks
-{
-    [Test]
-    [TestCase("https://localhost", "<p><a href=\"https://localhost\">https://localhost</a></p>")]
-    [TestCase("http://localhost", "<p><a href=\"http://localhost\">http://localhost</a></p>")]
-    [TestCase("https://l", "<p><a href=\"https://l\">https://l</a></p>")]
-    [TestCase("www.l", "<p><a href=\"http://www.l\">www.l</a></p>")]
-    [TestCase("https://localhost:5000", "<p><a href=\"https://localhost:5000\">https://localhost:5000</a></p>")]
-    [TestCase("www.l:5000", "<p><a href=\"http://www.l:5000\">www.l:5000</a></p>")]
-    public void TestLinksWithAllowDomainWithoutPeriod(string markdown, string expected)
-    {
-        var pipeline = new MarkdownPipelineBuilder()
-            .UseAutoLinks(new AutoLinkOptions { AllowDomainWithoutPeriod = true })
-            .Build();
-        var html = Markdown.ToHtml(markdown, pipeline);
-
-        Assert.That(html, Is.EqualTo(expected).IgnoreWhiteSpace);
-    }
-}

src/Markdig.Tests/TestCharHelper.cs

@@ -1,262 +0,0 @@
-using System.Globalization;
-
-using Markdig.Helpers;
-
-namespace Markdig.Tests;
-
-public class TestCharHelper
-{
-    // An ASCII punctuation character is
-    // !, ", #, $, %, &, ', (, ), *, +, ,, -, ., / (U+0021–2F),
-    // :, ;, <, =, >, ?, @ (U+003A–0040),
-    // [, \, ], ^, _, ` (U+005B–0060),
-    // {, |, }, or ~ (U+007B–007E).
-    private static readonly HashSet<char> s_asciiPunctuation = new()
-    {
-        '!', '"', '#', '$', '%', '&', '\'', '(', ')', '*', '+', ',', '-', '.', '/',
-        ':', ';', '<', '=', '>', '?', '@',
-        '[', '\\', ']', '^', '_', '`',
-        '{', '|', '}', '~'
-    };
-
-    // A Unicode punctuation character is a character in the Unicode P (punctuation) or S (symbol) general categories.
-    private static readonly HashSet<UnicodeCategory> s_punctuationCategories =
-    [
-        UnicodeCategory.ConnectorPunctuation,
-        UnicodeCategory.DashPunctuation,
-        UnicodeCategory.OpenPunctuation,
-        UnicodeCategory.ClosePunctuation,
-        UnicodeCategory.InitialQuotePunctuation,
-        UnicodeCategory.FinalQuotePunctuation,
-        UnicodeCategory.OtherPunctuation,
-        UnicodeCategory.MathSymbol,
-        UnicodeCategory.CurrencySymbol,
-        UnicodeCategory.ModifierSymbol,
-        UnicodeCategory.OtherSymbol,
-    ];
-
-    private static readonly HashSet<UnicodeCategory> s_punctuationWithoutSymbolsCategories =
-    [
-        UnicodeCategory.ConnectorPunctuation,
-        UnicodeCategory.DashPunctuation,
-        UnicodeCategory.OpenPunctuation,
-        UnicodeCategory.ClosePunctuation,
-        UnicodeCategory.InitialQuotePunctuation,
-        UnicodeCategory.FinalQuotePunctuation,
-        UnicodeCategory.OtherPunctuation,
-    ];
-
-    private static bool ExpectedIsPunctuation(char c)
-    {
-        return c <= 127
-            ? s_asciiPunctuation.Contains(c)
-            : s_punctuationCategories.Contains(CharUnicodeInfo.GetUnicodeCategory(c));
-    }
-
-    private static bool ExpectedIsPunctuationWithoutSymbols(char c)
-    {
-        return c <= 127
-            ? s_asciiPunctuation.Contains(c)
-            : s_punctuationWithoutSymbolsCategories.Contains(CharUnicodeInfo.GetUnicodeCategory(c));
-    }
-
-    private static bool ExpectedIsWhitespace(char c)
-    {
-        // A Unicode whitespace character is any code point in the Unicode Zs general category,
-        // or a tab (U+0009), line feed (U+000A), form feed (U+000C), or carriage return (U+000D).
-        return c == '\t' || c == '\n' || c == '\f' || c == '\r' ||
-            CharUnicodeInfo.GetUnicodeCategory(c) == UnicodeCategory.SpaceSeparator;
-    }
-
-    [Test]
-    public void IsAcrossTab()
-    {
-        Assert.False(CharHelper.IsAcrossTab(0));
-        Assert.True(CharHelper.IsAcrossTab(1));
-        Assert.True(CharHelper.IsAcrossTab(2));
-        Assert.True(CharHelper.IsAcrossTab(3));
-        Assert.False(CharHelper.IsAcrossTab(4));
-    }
-
-    [Test]
-    public void AddTab()
-    {
-        Assert.AreEqual(4, CharHelper.AddTab(0));
-        Assert.AreEqual(4, CharHelper.AddTab(1));
-        Assert.AreEqual(4, CharHelper.AddTab(2));
-        Assert.AreEqual(4, CharHelper.AddTab(3));
-        Assert.AreEqual(8, CharHelper.AddTab(4));
-        Assert.AreEqual(8, CharHelper.AddTab(5));
-    }
-
-    [Test]
-    public void IsWhitespace()
-    {
-        Test(
-            ExpectedIsWhitespace,
-            CharHelper.IsWhitespace);
-
-        Test(
-            ExpectedIsWhitespace,
-            CharHelper.WhitespaceChars.Contains);
-    }
-
-    [Test]
-    public void IsWhiteSpaceOrZero()
-    {
-        Test(
-            c => ExpectedIsWhitespace(c) || c == 0,
-            CharHelper.IsWhiteSpaceOrZero);
-    }
-
-    [Test]
-    public void IsAsciiPunctuation()
-    {
-        Test(
-            c => char.IsAscii(c) && ExpectedIsPunctuation(c),
-            CharHelper.IsAsciiPunctuation);
-    }
-
-    [Test]
-    public void IsAsciiPunctuationOrZero()
-    {
-        Test(
-            c => char.IsAscii(c) && (ExpectedIsPunctuation(c) || c == 0),
-            CharHelper.IsAsciiPunctuationOrZero);
-    }
-
-    [Test]
-    public void IsSpaceOrPunctuationForGFMAutoLink()
-    {
-        Test(
-            c => c == 0 || ExpectedIsWhitespace(c) || ExpectedIsPunctuationWithoutSymbols(c),
-            CharHelper.IsSpaceOrPunctuationForGFMAutoLink);
-    }
-
-    [Test]
-    public void InvalidAutoLinkCharacters()
-    {
-        // 6.5 Autolinks - https://spec.commonmark.org/0.31.2/#autolinks
-        // An absolute URI, for these purposes, consists of a scheme followed by a colon (:) followed by
-        // zero or more characters other than ASCII control characters, space, <, and >.
-        //
-        // 2.1 Characters and lines
-        // An ASCII control character is a character between U+0000–1F (both including) or U+007F.
-        Test(
-            c => c != 0 && c is < (char)0x20 or ' ' or '<' or '>' or '\u007F',
-            CharHelper.InvalidAutoLinkCharacters.Contains);
-    }
-
-    [Test]
-    public void CheckUnicodeCategory()
-    {
-        for (int i = char.MinValue; i <= char.MaxValue; i++)
-        {
-            char c = (char)i;
-
-            bool expectedSpace = c == 0 || ExpectedIsWhitespace(c);
-            bool expectedPunctuation = c == 0 || ExpectedIsPunctuation(c);
-
-            CharHelper.CheckUnicodeCategory(c, out bool spaceActual, out bool punctuationActual);
-
-            Assert.AreEqual(expectedSpace, spaceActual);
-            Assert.AreEqual(expectedPunctuation, punctuationActual);
-        }
-    }
-
-    [Test]
-    public void IsControl()
-    {
-        Test(
-            char.IsControl,
-            CharHelper.IsControl);
-    }
-
-    [Test]
-    public void IsAlpha()
-    {
-        Test(
-            c => (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'),
-            CharHelper.IsAlpha);
-    }
-
-    [Test]
-    public void IsAlphaUpper()
-    {
-        Test(
-            c => c >= 'A' && c <= 'Z',
-            CharHelper.IsAlphaUpper);
-    }
-
-    [Test]
-    public void IsAlphaNumeric()
-    {
-        Test(
-            c => (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9'),
-            CharHelper.IsAlphaNumeric);
-    }
-
-    [Test]
-    public void IsDigit()
-    {
-        Test(
-            c => c >= '0' && c <= '9',
-            CharHelper.IsDigit);
-    }
-
-    [Test]
-    public void IsNewLineOrLineFeed()
-    {
-        Test(
-            c => c is '\r' or '\n',
-            CharHelper.IsNewLineOrLineFeed);
-    }
-
-    [Test]
-    public void IsSpaceOrTab()
-    {
-        Test(
-            c => c is ' ' or '\t',
-            CharHelper.IsSpaceOrTab);
-    }
-
-    [Test]
-    public void IsEscapableSymbol()
-    {
-        Test(
-            "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~•".Contains,
-            CharHelper.IsEscapableSymbol);
-    }
-
-    [Test]
-    public void IsEmailUsernameSpecialChar()
-    {
-        Test(
-            ".!#$%&'*+/=?^_`{|}~-+.~".Contains,
-            CharHelper.IsEmailUsernameSpecialChar);
-    }
-
-    [Test]
-    public void IsEmailUsernameSpecialCharOrDigit()
-    {
-        Test(
-            c => CharHelper.IsDigit(c) || ".!#$%&'*+/=?^_`{|}~-+.~".Contains(c),
-            CharHelper.IsEmailUsernameSpecialCharOrDigit);
-    }
-
-    private static void Test(Func<char, bool> expected, Func<char, bool> actual)
-    {
-        for (int i = char.MinValue; i <= char.MaxValue; i++)
-        {
-            char c = (char)i;
-
-            bool expectedResult = expected(c);
-            bool actualResult = actual(c);
-
-            if (expectedResult != actualResult)
-            {
-                Assert.AreEqual(expectedResult, actualResult, $"Char: '{c}' ({i})");
-            }
-        }
-    }
-}

src/Markdig.Tests/TestCodeInline.cs

@@ -1,10 +0,0 @@
-namespace Markdig.Tests;
-
-public class TestCodeInline
-{
-    [Test]
-    public void UnpairedCodeInlineWithTrailingChars()
-    {
-        TestParser.TestSpec("*`\n\f", "<p>*`</p>");
-    }
-}

src/Markdig.Tests/TestConfigureNewLine.cs

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

src/Markdig.Tests/TestContainerBlocks.cs

@@ -1,186 +1,92 @@
+using System;
 using Markdig.Syntax;
+using NUnit.Framework;
 
-namespace Markdig.Tests;
-
-public class TestContainerBlocks
+namespace Markdig.Tests
 {
-    private class MockContainerBlock : ContainerBlock
+    public class TestContainerBlocks
     {
-        public MockContainerBlock()
-            : base(null)
+        private class MockContainerBlock : ContainerBlock
         {
+            public MockContainerBlock()
+                : base(null)
+            {
 
+            }
+        }
+
+        [Test]
+        public void CanBeCleared()
+        {
+            ContainerBlock container = new MockContainerBlock();
+            Assert.AreEqual(0, container.Count);
+            Assert.Null(container.LastChild);
+
+            var paragraph = new ParagraphBlock();
+            Assert.Null(paragraph.Parent);
+
+            container.Add(paragraph);
+
+            Assert.AreEqual(1, container.Count);
+            Assert.AreSame(container, paragraph.Parent);
+            Assert.AreSame(paragraph, container.LastChild);
+
+            container.Clear();
+
+            Assert.AreEqual(0, container.Count);
+            Assert.Null(container.LastChild);
+            Assert.Null(paragraph.Parent);
+        }
+
+        [Test]
+        public void CanBeInsertedInto()
+        {
+            ContainerBlock container = new MockContainerBlock();
+
+            var one = new ParagraphBlock();
+            container.Insert(0, one);
+            Assert.AreEqual(1, container.Count);
+            Assert.AreSame(container[0], one);
+            Assert.AreSame(container, one.Parent);
+
+            var two = new ParagraphBlock();
+            container.Insert(1, two);
+            Assert.AreEqual(2, container.Count);
+            Assert.AreSame(container[0], one);
+            Assert.AreSame(container[1], two);
+            Assert.AreSame(container, two.Parent);
+
+            var three = new ParagraphBlock();
+            container.Insert(0, three);
+            Assert.AreEqual(3, container.Count);
+            Assert.AreSame(container[0], three);
+            Assert.AreSame(container[1], one);
+            Assert.AreSame(container[2], two);
+            Assert.AreSame(container, three.Parent);
+
+            Assert.Throws<ArgumentNullException>(() => container.Insert(0, null));
+            Assert.Throws<ArgumentOutOfRangeException>(() => container.Insert(4, new ParagraphBlock()));
+            Assert.Throws<ArgumentOutOfRangeException>(() => container.Insert(-1, new ParagraphBlock()));
+            Assert.Throws<ArgumentException>(() => container.Insert(0, one)); // one already has a parent
+        }
+
+        [Test]
+        public void CanBeSet()
+        {
+            ContainerBlock container = new MockContainerBlock();
+
+            var one = new ParagraphBlock();
+            container.Insert(0, one);
+            Assert.AreEqual(1, container.Count);
+            Assert.AreSame(container[0], one);
+            Assert.AreSame(container, one.Parent);
+
+            var two = new ParagraphBlock();
+            container[0] = two;
+            Assert.AreSame(container, two.Parent);
+            Assert.Null(one.Parent);
+
+            Assert.Throws<ArgumentException>(() => container[0] = two); // two already has a parent
         }
     }
-
-    [Test]
-    public void CanBeCleared()
-    {
-        ContainerBlock container = new MockContainerBlock();
-        Assert.AreEqual(0, container.Count);
-        Assert.Null(container.LastChild);
-
-        var paragraph = new ParagraphBlock();
-        Assert.Null(paragraph.Parent);
-
-        container.Add(paragraph);
-
-        Assert.AreEqual(1, container.Count);
-        Assert.AreSame(container, paragraph.Parent);
-        Assert.AreSame(paragraph, container.LastChild);
-
-        container.Clear();
-
-        Assert.AreEqual(0, container.Count);
-        Assert.Null(container.LastChild);
-        Assert.Null(paragraph.Parent);
-    }
-
-    [Test]
-    public void CanBeInsertedInto()
-    {
-        ContainerBlock container = new MockContainerBlock();
-
-        var one = new ParagraphBlock();
-        container.Insert(0, one);
-        Assert.AreEqual(1, container.Count);
-        Assert.AreSame(container[0], one);
-        Assert.AreSame(container, one.Parent);
-
-        var two = new ParagraphBlock();
-        container.Insert(1, two);
-        Assert.AreEqual(2, container.Count);
-        Assert.AreSame(container[0], one);
-        Assert.AreSame(container[1], two);
-        Assert.AreSame(container, two.Parent);
-
-        var three = new ParagraphBlock();
-        container.Insert(0, three);
-        Assert.AreEqual(3, container.Count);
-        Assert.AreSame(container[0], three);
-        Assert.AreSame(container[1], one);
-        Assert.AreSame(container[2], two);
-        Assert.AreSame(container, three.Parent);
-
-        Assert.Throws<ArgumentNullException>(() => container.Insert(0, null));
-        Assert.Throws<ArgumentOutOfRangeException>(() => container.Insert(4, new ParagraphBlock()));
-        Assert.Throws<ArgumentOutOfRangeException>(() => container.Insert(-1, new ParagraphBlock()));
-        Assert.Throws<ArgumentException>(() => container.Insert(0, one)); // one already has a parent
-    }
-
-    [Test]
-    public void CanBeSet()
-    {
-        ContainerBlock container = new MockContainerBlock();
-
-        var one = new ParagraphBlock();
-        container.Insert(0, one);
-        Assert.AreEqual(1, container.Count);
-        Assert.AreSame(container[0], one);
-        Assert.AreSame(container, one.Parent);
-
-        var two = new ParagraphBlock();
-        container[0] = two;
-        Assert.AreSame(container, two.Parent);
-        Assert.Null(one.Parent);
-
-        Assert.Throws<ArgumentException>(() => container[0] = two); // two already has a parent
-    }
-
-    [Test]
-    public void Contains()
-    {
-        var container = new MockContainerBlock();
-        var block = new ParagraphBlock();
-
-        Assert.False(container.Contains(block));
-
-        container.Add(block);
-        Assert.True(container.Contains(block));
-
-        container.Add(new ParagraphBlock());
-        Assert.True(container.Contains(block));
-
-        container.Insert(0, new ParagraphBlock());
-        Assert.True(container.Contains(block));
-    }
-
-    [Test]
-    public void Remove()
-    {
-        var container = new MockContainerBlock();
-        var block = new ParagraphBlock();
-
-        Assert.False(container.Remove(block));
-        Assert.AreEqual(0, container.Count);
-        Assert.Throws<ArgumentOutOfRangeException>(() => container.RemoveAt(0));
-        Assert.AreEqual(0, container.Count);
-
-        container.Add(block);
-        Assert.AreEqual(1, container.Count);
-        Assert.True(container.Remove(block));
-        Assert.AreEqual(0, container.Count);
-        Assert.False(container.Remove(block));
-        Assert.AreEqual(0, container.Count);
-
-        container.Add(block);
-        Assert.AreEqual(1, container.Count);
-        container.RemoveAt(0);
-        Assert.AreEqual(0, container.Count);
-        Assert.Throws<ArgumentOutOfRangeException>(() => container.RemoveAt(0));
-        Assert.AreEqual(0, container.Count);
-
-        container.Add(new ParagraphBlock { Column = 1 });
-        container.Add(new ParagraphBlock { Column = 2 });
-        container.Add(new ParagraphBlock { Column = 3 });
-        container.Add(new ParagraphBlock { Column = 4 });
-        Assert.AreEqual(4, container.Count);
-
-        container.RemoveAt(2);
-        Assert.AreEqual(3, container.Count);
-        Assert.AreEqual(4, container[2].Column);
-
-        Assert.True(container.Remove(container[1]));
-        Assert.AreEqual(2, container.Count);
-        Assert.AreEqual(1, container[0].Column);
-        Assert.AreEqual(4, container[1].Column);
-        Assert.Throws<IndexOutOfRangeException>(() => _ = container[2]);
-    }
-
-    [Test]
-    public void CopyTo()
-    {
-        var container = new MockContainerBlock();
-
-        var destination = new Block[4];
-        container.CopyTo(destination, 0);
-        container.CopyTo(destination, 1);
-        container.CopyTo(destination, -1);
-        container.CopyTo(destination, 5);
-        Assert.Null(destination[0]);
-
-        container.Add(new ParagraphBlock());
-        container.CopyTo(destination, 0);
-        Assert.NotNull(destination[0]);
-        Assert.Null(destination[1]);
-        Assert.Null(destination[2]);
-        Assert.Null(destination[3]);
-
-        container.CopyTo(destination, 2);
-        Assert.NotNull(destination[0]);
-        Assert.Null(destination[1]);
-        Assert.NotNull(destination[2]);
-        Assert.Null(destination[3]);
-
-        Array.Clear(destination);
-
-        container.Add(new ParagraphBlock());
-        container.CopyTo(destination, 1);
-        Assert.Null(destination[0]);
-        Assert.NotNull(destination[1]);
-        Assert.NotNull(destination[2]);
-        Assert.Null(destination[3]);
-
-        Assert.Throws<IndexOutOfRangeException>(() => container.CopyTo(destination, 3));
-    }
 }

src/Markdig.Tests/TestContainerInlines.cs

@@ -1,38 +1,41 @@
+using System;
 using Markdig.Syntax;
 using Markdig.Syntax.Inlines;
+using NUnit.Framework;
 
-namespace Markdig.Tests;
-
-public class TestContainerInlines
+namespace Markdig.Tests
 {
-    private class MockLeafBlock : LeafBlock
+    public class TestContainerInlines
     {
-        public MockLeafBlock()
-            : base(null)
+        private class MockLeafBlock : LeafBlock
         {
+            public MockLeafBlock()
+                : base(null)
+            {
 
+            }
+        }
+
+        [Test]
+        public void CanBeAddedToLeafBlock()
+        {
+            var leafBlock1 = new MockLeafBlock();
+
+            var one = new ContainerInline();
+            Assert.Null(one.ParentBlock);
+
+            leafBlock1.Inline = one;
+            Assert.AreSame(leafBlock1, one.ParentBlock);
+
+            var two = new ContainerInline();
+            Assert.Null(two.ParentBlock);
+
+            leafBlock1.Inline = two;
+            Assert.AreSame(leafBlock1, two.ParentBlock);
+            Assert.Null(one.ParentBlock);
+
+            var leafBlock2 = new MockLeafBlock();
+            Assert.Throws<ArgumentException>(() => leafBlock2.Inline = two);
         }
     }
-
-    [Test]
-    public void CanBeAddedToLeafBlock()
-    {
-        var leafBlock1 = new MockLeafBlock();
-
-        var one = new ContainerInline();
-        Assert.Null(one.ParentBlock);
-
-        leafBlock1.Inline = one;
-        Assert.AreSame(leafBlock1, one.ParentBlock);
-
-        var two = new ContainerInline();
-        Assert.Null(two.ParentBlock);
-
-        leafBlock1.Inline = two;
-        Assert.AreSame(leafBlock1, two.ParentBlock);
-        Assert.Null(one.ParentBlock);
-
-        var leafBlock2 = new MockLeafBlock();
-        Assert.Throws<ArgumentException>(() => leafBlock2.Inline = two);
-    }
 }

src/Markdig.Tests/TestCustomEmojis.cs

@@ -1,124 +1,128 @@
+using System;
+using System.Collections.Generic;
 using Markdig.Extensions.Emoji;
+using NUnit.Framework;
 
-namespace Markdig.Tests;
-
-[TestFixture]
-public class TestCustomEmojis
+namespace Markdig.Tests
 {
-    [Test]
-    [TestCase(":smiley:", "<p>♥</p>\n")]
-    [TestCase(":confused:", "<p>:confused:</p>\n")] // default emoji does not work
-    [TestCase(":/", "<p>:/</p>\n")] // default smiley does not work
-    public void TestCustomEmoji(string input, string expected)
+    [TestFixture]
+    public class TestCustomEmojis
     {
-        var emojiToUnicode = new Dictionary<string, string>();
-        var smileyToEmoji = new Dictionary<string, string>();
+        [Test]
+        [TestCase(":smiley:", "<p>♥</p>\n")]
+        [TestCase(":confused:", "<p>:confused:</p>\n")] // default emoji does not work
+        [TestCase(":/", "<p>:/</p>\n")] // default smiley does not work
+        public void TestCustomEmoji(string input, string expected)
+        {
+            var emojiToUnicode = new Dictionary<string, string>();
+            var smileyToEmoji = new Dictionary<string, string>();
 
-        emojiToUnicode[":smiley:"] = "♥";
+            emojiToUnicode[":smiley:"] = "♥";
 
-        var customMapping = new EmojiMapping(emojiToUnicode, smileyToEmoji);
+            var customMapping = new EmojiMapping(emojiToUnicode, smileyToEmoji);
 
-        var pipeline = new MarkdownPipelineBuilder()
-            .UseEmojiAndSmiley(customEmojiMapping: customMapping)
-            .Build();
+            var pipeline = new MarkdownPipelineBuilder()
+                .UseEmojiAndSmiley(customEmojiMapping: customMapping)
+                .Build();
 
-        var actual = Markdown.ToHtml(input, pipeline);
-        Assert.AreEqual(expected, actual);
-    }
+            var actual = Markdown.ToHtml(input, pipeline);
+            Assert.AreEqual(expected, actual);
+        }
 
-    [Test]
-    [TestCase(":testheart:", "<p>♥</p>\n")]
-    [TestCase("hello", "<p>♥</p>\n")]
-    [TestCase(":confused:", "<p>:confused:</p>\n")] // default emoji does not work
-    [TestCase(":/", "<p>:/</p>\n")] // default smiley does not work
-    public void TestCustomSmiley(string input, string expected)
-    {
-        var emojiToUnicode = new Dictionary<string, string>();
-        var smileyToEmoji = new Dictionary<string, string>();
+        [Test]
+        [TestCase(":testheart:", "<p>♥</p>\n")]
+        [TestCase("hello", "<p>♥</p>\n")]
+        [TestCase(":confused:", "<p>:confused:</p>\n")] // default emoji does not work
+        [TestCase(":/", "<p>:/</p>\n")] // default smiley does not work
+        public void TestCustomSmiley(string input, string expected)
+        {
+            var emojiToUnicode = new Dictionary<string, string>();
+            var smileyToEmoji = new Dictionary<string, string>();
 
-        emojiToUnicode[":testheart:"] = "♥";
-        smileyToEmoji["hello"] = ":testheart:";
+            emojiToUnicode[":testheart:"] = "♥";
+            smileyToEmoji["hello"] = ":testheart:";
 
-        var customMapping = new EmojiMapping(emojiToUnicode, smileyToEmoji);
+            var customMapping = new EmojiMapping(emojiToUnicode, smileyToEmoji);
 
-        var pipeline = new MarkdownPipelineBuilder()
-            .UseEmojiAndSmiley(customEmojiMapping: customMapping)
-            .Build();
+            var pipeline = new MarkdownPipelineBuilder()
+                .UseEmojiAndSmiley(customEmojiMapping: customMapping)
+                .Build();
 
-        var actual = Markdown.ToHtml(input, pipeline);
-        Assert.AreEqual(expected, actual);
-    }
+            var actual = Markdown.ToHtml(input, pipeline);
+            Assert.AreEqual(expected, actual);
+        }
 
-    [Test]
-    [TestCase(":smiley:", "<p>♥</p>\n")]
-    [TestCase(":)", "<p>♥</p>\n")]
-    [TestCase(":confused:", "<p>😕</p>\n")] // default emoji still works
-    [TestCase(":/", "<p>😕</p>\n")] // default smiley still works
-    public void TestOverrideDefaultWithCustomEmoji(string input, string expected)
-    {
-        var emojiToUnicode = EmojiMapping.GetDefaultEmojiShortcodeToUnicode();
-        var smileyToEmoji = EmojiMapping.GetDefaultSmileyToEmojiShortcode();
+        [Test]
+        [TestCase(":smiley:", "<p>♥</p>\n")]
+        [TestCase(":)", "<p>♥</p>\n")]
+        [TestCase(":confused:", "<p>😕</p>\n")] // default emoji still works
+        [TestCase(":/", "<p>😕</p>\n")] // default smiley still works
+        public void TestOverrideDefaultWithCustomEmoji(string input, string expected)
+        {
+            var emojiToUnicode = EmojiMapping.GetDefaultEmojiShortcodeToUnicode();
+            var smileyToEmoji = EmojiMapping.GetDefaultSmileyToEmojiShortcode();
 
-        emojiToUnicode[":smiley:"] = "♥";
+            emojiToUnicode[":smiley:"] = "♥";
 
-        var customMapping = new EmojiMapping(emojiToUnicode, smileyToEmoji);
+            var customMapping = new EmojiMapping(emojiToUnicode, smileyToEmoji);
 
-        var pipeline = new MarkdownPipelineBuilder()
-            .UseEmojiAndSmiley(customEmojiMapping: customMapping)
-            .Build();
+            var pipeline = new MarkdownPipelineBuilder()
+                .UseEmojiAndSmiley(customEmojiMapping: customMapping)
+                .Build();
 
-        var actual = Markdown.ToHtml(input, pipeline);
-        Assert.AreEqual(expected, actual);
-    }
+            var actual = Markdown.ToHtml(input, pipeline);
+            Assert.AreEqual(expected, actual);
+        }
 
-    [Test]
-    [TestCase(":testheart:", "<p>♥</p>\n")]
-    [TestCase("hello", "<p>♥</p>\n")]
-    [TestCase(":confused:", "<p>😕</p>\n")] // default emoji still works
-    [TestCase(":/", "<p>😕</p>\n")] // default smiley still works
-    public void TestOverrideDefaultWithCustomSmiley(string input, string expected)
-    {
-        var emojiToUnicode = EmojiMapping.GetDefaultEmojiShortcodeToUnicode();
-        var smileyToEmoji = EmojiMapping.GetDefaultSmileyToEmojiShortcode();
+        [Test]
+        [TestCase(":testheart:", "<p>♥</p>\n")]
+        [TestCase("hello", "<p>♥</p>\n")]
+        [TestCase(":confused:", "<p>😕</p>\n")] // default emoji still works
+        [TestCase(":/", "<p>😕</p>\n")] // default smiley still works
+        public void TestOverrideDefaultWithCustomSmiley(string input, string expected)
+        {
+            var emojiToUnicode = EmojiMapping.GetDefaultEmojiShortcodeToUnicode();
+            var smileyToEmoji = EmojiMapping.GetDefaultSmileyToEmojiShortcode();
 
-        emojiToUnicode[":testheart:"] = "♥";
-        smileyToEmoji["hello"] = ":testheart:";
+            emojiToUnicode[":testheart:"] = "♥";
+            smileyToEmoji["hello"] = ":testheart:";
 
-        var customMapping = new EmojiMapping(emojiToUnicode, smileyToEmoji);
+            var customMapping = new EmojiMapping(emojiToUnicode, smileyToEmoji);
 
-        var pipeline = new MarkdownPipelineBuilder()
-            .UseEmojiAndSmiley(customEmojiMapping: customMapping)
-            .Build();
+            var pipeline = new MarkdownPipelineBuilder()
+                .UseEmojiAndSmiley(customEmojiMapping: customMapping)
+                .Build();
 
-        var actual = Markdown.ToHtml(input, pipeline);
-        Assert.AreEqual(expected, actual);
-    }
+            var actual = Markdown.ToHtml(input, pipeline);
+            Assert.AreEqual(expected, actual);
+        }
 
-    [Test]
-    public void TestCustomEmojiValidation()
-    {
-        var emojiToUnicode = new Dictionary<string, string>();
-        var smileyToEmoji = new Dictionary<string, string>();
+        [Test]
+        public void TestCustomEmojiValidation()
+        {
+            var emojiToUnicode = new Dictionary<string, string>();
+            var smileyToEmoji = new Dictionary<string, string>();
 
-        Assert.Throws<ArgumentNullException>(() => new EmojiMapping(null, smileyToEmoji));
-        Assert.Throws<ArgumentNullException>(() => new EmojiMapping(emojiToUnicode, null));
+            Assert.Throws<ArgumentNullException>(() => new EmojiMapping(null, smileyToEmoji));
+            Assert.Throws<ArgumentNullException>(() => new EmojiMapping(emojiToUnicode, null));
 
-        emojiToUnicode.Add("null-value", null);
-        Assert.Throws<ArgumentException>(() => new EmojiMapping(emojiToUnicode, smileyToEmoji));
-        emojiToUnicode.Clear();
+            emojiToUnicode.Add("null-value", null);
+            Assert.Throws<ArgumentException>(() => new EmojiMapping(emojiToUnicode, smileyToEmoji));
+            emojiToUnicode.Clear();
 
-        smileyToEmoji.Add("null-value", null);
-        Assert.Throws<ArgumentException>(() => new EmojiMapping(emojiToUnicode, smileyToEmoji));
-        smileyToEmoji.Clear();
+            smileyToEmoji.Add("null-value", null);
+            Assert.Throws<ArgumentException>(() => new EmojiMapping(emojiToUnicode, smileyToEmoji));
+            smileyToEmoji.Clear();
 
-        smileyToEmoji.Add("foo", "something-that-does-not-exist-in-emojiToUnicode");
-        Assert.Throws<ArgumentException>(() => new EmojiMapping(emojiToUnicode, smileyToEmoji));
-        smileyToEmoji.Clear();
+            smileyToEmoji.Add("foo", "something-that-does-not-exist-in-emojiToUnicode");
+            Assert.Throws<ArgumentException>(() => new EmojiMapping(emojiToUnicode, smileyToEmoji));
+            smileyToEmoji.Clear();
 
-        emojiToUnicode.Add("a", "aaa");
-        emojiToUnicode.Add("b", "bbb");
-        emojiToUnicode.Add("c", "ccc");
-        smileyToEmoji.Add("a", "c"); // "a" already exists in emojiToUnicode
-        Assert.Throws<ArgumentException>(() => new EmojiMapping(emojiToUnicode, smileyToEmoji));
+            emojiToUnicode.Add("a", "aaa");
+            emojiToUnicode.Add("b", "bbb");
+            emojiToUnicode.Add("c", "ccc");
+            smileyToEmoji.Add("a", "c"); // "a" already exists in emojiToUnicode
+            Assert.Throws<ArgumentException>(() => new EmojiMapping(emojiToUnicode, smileyToEmoji));
+        }
     }
 }

src/Markdig.Tests/TestDescendantsOrder.cs

@@ -1,145 +1,150 @@
+using NUnit.Framework;
+using Markdig.Helpers;
 using Markdig.Syntax;
 using Markdig.Syntax.Inlines;
+using System.Linq;
+using System.Collections.Generic;
 
-namespace Markdig.Tests;
-
-[TestFixture]
-public class TestDescendantsOrder
+namespace Markdig.Tests
 {
-    public static void TestSchemas(MarkdownDocument[] specsSyntaxTrees)
+    [TestFixture]
+    public class TestDescendantsOrder
     {
-        foreach (var syntaxTree in specsSyntaxTrees)
+        public static void TestSchemas(MarkdownDocument[] specsSyntaxTrees)
         {
-            AssertIEnumerablesAreEqual(
-                Descendants_Legacy(syntaxTree),
-                syntaxTree.Descendants());
-
-            AssertIEnumerablesAreEqual(
-                syntaxTree.Descendants().OfType<ParagraphBlock>(),
-                syntaxTree.Descendants<ParagraphBlock>());
-
-            AssertIEnumerablesAreEqual(
-                syntaxTree.Descendants().OfType<ParagraphBlock>(),
-                (syntaxTree as ContainerBlock).Descendants<ParagraphBlock>());
-
-            AssertIEnumerablesAreEqual(
-                syntaxTree.Descendants().OfType<LiteralInline>(),
-                syntaxTree.Descendants<LiteralInline>());
-
-            foreach (LiteralInline literalInline in syntaxTree.Descendants<LiteralInline>())
-            {
-                Assert.AreSame(Array.Empty<ListBlock>(), literalInline.Descendants<ListBlock>());
-                Assert.AreSame(Array.Empty<ParagraphBlock>(), literalInline.Descendants<ParagraphBlock>());
-                Assert.AreSame(Array.Empty<ContainerInline>(), literalInline.Descendants<ContainerInline>());
-            }
-
-            foreach (ContainerInline containerInline in syntaxTree.Descendants<ContainerInline>())
+            foreach (var syntaxTree in specsSyntaxTrees)
             {
                 AssertIEnumerablesAreEqual(
-                    containerInline.FindDescendants<LiteralInline>(),
-                    containerInline.Descendants<LiteralInline>());
+                    Descendants_Legacy(syntaxTree),
+                    syntaxTree.Descendants());
 
                 AssertIEnumerablesAreEqual(
-                    containerInline.FindDescendants<LiteralInline>(),
-                    (containerInline as MarkdownObject).Descendants<LiteralInline>());
+                    syntaxTree.Descendants().OfType<ParagraphBlock>(),
+                    syntaxTree.Descendants<ParagraphBlock>());
 
-                if (containerInline.FirstChild is null)
+                AssertIEnumerablesAreEqual(
+                    syntaxTree.Descendants().OfType<ParagraphBlock>(),
+                    (syntaxTree as ContainerBlock).Descendants<ParagraphBlock>());
+
+                AssertIEnumerablesAreEqual(
+                    syntaxTree.Descendants().OfType<LiteralInline>(),
+                    syntaxTree.Descendants<LiteralInline>());
+
+                foreach (LiteralInline literalInline in syntaxTree.Descendants<LiteralInline>())
                 {
-                    Assert.AreSame(Array.Empty<LiteralInline>(), containerInline.Descendants<LiteralInline>());
-                    Assert.AreSame(Array.Empty<LiteralInline>(), containerInline.FindDescendants<LiteralInline>());
-                    Assert.AreSame(Array.Empty<LiteralInline>(), (containerInline as MarkdownObject).Descendants<LiteralInline>());
+                    Assert.AreSame(ArrayHelper.Empty<ListBlock>(), literalInline.Descendants<ListBlock>());
+                    Assert.AreSame(ArrayHelper.Empty<ParagraphBlock>(), literalInline.Descendants<ParagraphBlock>());
+                    Assert.AreSame(ArrayHelper.Empty<ContainerInline>(), literalInline.Descendants<ContainerInline>());
                 }
 
-                Assert.AreSame(Array.Empty<ListBlock>(), containerInline.Descendants<ListBlock>());
-                Assert.AreSame(Array.Empty<ParagraphBlock>(), containerInline.Descendants<ParagraphBlock>());
-            }
-
-            foreach (ParagraphBlock paragraphBlock in syntaxTree.Descendants<ParagraphBlock>())
-            {
-                AssertIEnumerablesAreEqual(
-                    (paragraphBlock as MarkdownObject).Descendants<LiteralInline>(),
-                    paragraphBlock.Descendants<LiteralInline>());
-
-                Assert.AreSame(Array.Empty<ParagraphBlock>(), paragraphBlock.Descendants<ParagraphBlock>());
-            }
-
-            foreach (ContainerBlock containerBlock in syntaxTree.Descendants<ContainerBlock>())
-            {
-                AssertIEnumerablesAreEqual(
-                    containerBlock.Descendants<LiteralInline>(),
-                    (containerBlock as MarkdownObject).Descendants<LiteralInline>());
-
-                AssertIEnumerablesAreEqual(
-                    containerBlock.Descendants<ParagraphBlock>(),
-                    (containerBlock as MarkdownObject).Descendants<ParagraphBlock>());
-
-                if (containerBlock.Count == 0)
+                foreach (ContainerInline containerInline in syntaxTree.Descendants<ContainerInline>())
                 {
-                    Assert.AreSame(Array.Empty<LiteralInline>(), containerBlock.Descendants<LiteralInline>());
-                    Assert.AreSame(Array.Empty<LiteralInline>(), (containerBlock as Block).Descendants<LiteralInline>());
-                    Assert.AreSame(Array.Empty<LiteralInline>(), (containerBlock as MarkdownObject).Descendants<LiteralInline>());
-                }
-            }
-        }
-    }
+                    AssertIEnumerablesAreEqual(
+                        containerInline.FindDescendants<LiteralInline>(),
+                        containerInline.Descendants<LiteralInline>());
 
-    private static void AssertIEnumerablesAreEqual<T>(IEnumerable<T> first, IEnumerable<T> second)
-    {
-        var firstList = new List<T>(first);
-        var secondList = new List<T>(second);
+                    AssertIEnumerablesAreEqual(
+                        containerInline.FindDescendants<LiteralInline>(),
+                        (containerInline as MarkdownObject).Descendants<LiteralInline>());
 
-        Assert.AreEqual(firstList.Count, secondList.Count);
-
-        for (int i = 0; i < firstList.Count; i++)
-        {
-            Assert.AreSame(firstList[i], secondList[i]);
-        }
-    }
-
-    private static IEnumerable<MarkdownObject> Descendants_Legacy(MarkdownObject markdownObject)
-    {
-        // TODO: implement a recursiveless method
-
-        var block = markdownObject as ContainerBlock;
-        if (block != null)
-        {
-            foreach (var subBlock in block)
-            {
-                yield return subBlock;
-
-                foreach (var sub in Descendants_Legacy(subBlock))
-                {
-                    yield return sub;
-                }
-
-                // Visit leaf block that have inlines
-                var leafBlock = subBlock as LeafBlock;
-                if (leafBlock?.Inline != null)
-                {
-                    foreach (var subInline in Descendants_Legacy(leafBlock.Inline))
+                    if (containerInline.FirstChild is null)
                     {
-                        yield return subInline;
+                        Assert.AreSame(ArrayHelper.Empty<LiteralInline>(), containerInline.Descendants<LiteralInline>());
+                        Assert.AreSame(ArrayHelper.Empty<LiteralInline>(), containerInline.FindDescendants<LiteralInline>());
+                        Assert.AreSame(ArrayHelper.Empty<LiteralInline>(), (containerInline as MarkdownObject).Descendants<LiteralInline>());
+                    }
+
+                    Assert.AreSame(ArrayHelper.Empty<ListBlock>(), containerInline.Descendants<ListBlock>());
+                    Assert.AreSame(ArrayHelper.Empty<ParagraphBlock>(), containerInline.Descendants<ParagraphBlock>());
+                }
+
+                foreach (ParagraphBlock paragraphBlock in syntaxTree.Descendants<ParagraphBlock>())
+                {
+                    AssertIEnumerablesAreEqual(
+                        (paragraphBlock as MarkdownObject).Descendants<LiteralInline>(),
+                        paragraphBlock.Descendants<LiteralInline>());
+
+                    Assert.AreSame(ArrayHelper.Empty<ParagraphBlock>(), paragraphBlock.Descendants<ParagraphBlock>());
+                }
+
+                foreach (ContainerBlock containerBlock in syntaxTree.Descendants<ContainerBlock>())
+                {
+                    AssertIEnumerablesAreEqual(
+                        containerBlock.Descendants<LiteralInline>(),
+                        (containerBlock as MarkdownObject).Descendants<LiteralInline>());
+
+                    AssertIEnumerablesAreEqual(
+                        containerBlock.Descendants<ParagraphBlock>(),
+                        (containerBlock as MarkdownObject).Descendants<ParagraphBlock>());
+
+                    if (containerBlock.Count == 0)
+                    {
+                        Assert.AreSame(ArrayHelper.Empty<LiteralInline>(), containerBlock.Descendants<LiteralInline>());
+                        Assert.AreSame(ArrayHelper.Empty<LiteralInline>(), (containerBlock as Block).Descendants<LiteralInline>());
+                        Assert.AreSame(ArrayHelper.Empty<LiteralInline>(), (containerBlock as MarkdownObject).Descendants<LiteralInline>());
                     }
                 }
             }
         }
-        else
-        {
-            var inline = markdownObject as ContainerInline;
-            if (inline != null)
-            {
-                var child = inline.FirstChild;
-                while (child != null)
-                {
-                    var next = child.NextSibling;
-                    yield return child;
 
-                    foreach (var sub in Descendants_Legacy(child))
+        private static void AssertIEnumerablesAreEqual<T>(IEnumerable<T> first, IEnumerable<T> second)
+        {
+            var firstList = new List<T>(first);
+            var secondList = new List<T>(second);
+
+            Assert.AreEqual(firstList.Count, secondList.Count);
+
+            for (int i = 0; i < firstList.Count; i++)
+            {
+                Assert.AreSame(firstList[i], secondList[i]);
+            }
+        }
+
+        private static IEnumerable<MarkdownObject> Descendants_Legacy(MarkdownObject markdownObject)
+        {
+            // TODO: implement a recursiveless method
+
+            var block = markdownObject as ContainerBlock;
+            if (block != null)
+            {
+                foreach (var subBlock in block)
+                {
+                    yield return subBlock;
+
+                    foreach (var sub in Descendants_Legacy(subBlock))
                     {
                         yield return sub;
                     }
 
-                    child = next;
+                    // Visit leaf block that have inlines
+                    var leafBlock = subBlock as LeafBlock;
+                    if (leafBlock?.Inline != null)
+                    {
+                        foreach (var subInline in Descendants_Legacy(leafBlock.Inline))
+                        {
+                            yield return subInline;
+                        }
+                    }
+                }
+            }
+            else
+            {
+                var inline = markdownObject as ContainerInline;
+                if (inline != null)
+                {
+                    var child = inline.FirstChild;
+                    while (child != null)
+                    {
+                        var next = child.NextSibling;
+                        yield return child;
+
+                        foreach (var sub in Descendants_Legacy(child))
+                        {
+                            yield return sub;
+                        }
+
+                        child = next;
+                    }
                 }
             }
         }

src/Markdig.Tests/TestEmphasisExtended.cs

@@ -1,169 +1,169 @@
-using System.Diagnostics;
-
 using Markdig.Parsers.Inlines;
 using Markdig.Renderers;
 using Markdig.Renderers.Html;
 using Markdig.Syntax.Inlines;
+using NUnit.Framework;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
 
-namespace Markdig.Tests;
-
-[TestFixture]
-public class TestEmphasisExtended
+namespace Markdig.Tests
 {
-    class EmphasisTestExtension : IMarkdownExtension
+    [TestFixture]
+    public class TestEmphasisExtended
     {
-        public void Setup(MarkdownPipelineBuilder pipeline)
+        class EmphasisTestExtension : IMarkdownExtension
         {
-            var emphasisParser = pipeline.InlineParsers.Find<EmphasisInlineParser>();
-            Debug.Assert(emphasisParser != null);
-
-            foreach (var emphasis in EmphasisTestDescriptors)
+            public void Setup(MarkdownPipelineBuilder pipeline)
             {
-                emphasisParser.EmphasisDescriptors.Add(
-                    new EmphasisDescriptor(emphasis.Character, emphasis.Minimum, emphasis.Maximum, true));
+                var emphasisParser = pipeline.InlineParsers.Find<EmphasisInlineParser>();
+                Debug.Assert(emphasisParser != null);
+
+                foreach (var emphasis in EmphasisTestDescriptors)
+                {
+                    emphasisParser.EmphasisDescriptors.Add(
+                        new EmphasisDescriptor(emphasis.Character, emphasis.Minimum, emphasis.Maximum, true));
+                }
+                emphasisParser.TryCreateEmphasisInlineList.Add((delimiterChar, delimiterCount) =>
+                {
+                    return delimiterChar == '*' || delimiterChar == '_'
+                        ? null
+                        : new CustomEmphasisInline() { DelimiterChar = delimiterChar, DelimiterCount = delimiterCount };
+                });
             }
-            emphasisParser.TryCreateEmphasisInlineList.Add((delimiterChar, delimiterCount) =>
+
+            public void Setup(MarkdownPipeline pipeline, IMarkdownRenderer renderer)
             {
-                return delimiterChar is '*' or '_'
-                    ? null
-                    : new CustomEmphasisInline() { DelimiterChar = delimiterChar, DelimiterCount = delimiterCount };
-            });
-        }
+                renderer.ObjectRenderers.Insert(0, new EmphasisRenderer());
+            }
 
-        public void Setup(MarkdownPipeline pipeline, IMarkdownRenderer renderer)
-        {
-            renderer.ObjectRenderers.Insert(0, new EmphasisRenderer());
-        }
-
-        class EmphasisRenderer : HtmlObjectRenderer<CustomEmphasisInline>
-        {
-            protected override void Write(HtmlRenderer renderer, CustomEmphasisInline obj)
+            class EmphasisRenderer : HtmlObjectRenderer<CustomEmphasisInline>
             {
-                var tag = EmphasisTestDescriptors.First(test => test.Character == obj.DelimiterChar).Tags[obj.DelimiterCount];
+                protected override void Write(HtmlRenderer renderer, CustomEmphasisInline obj)
+                {
+                    var tag = EmphasisTestDescriptors.First(test => test.Character == obj.DelimiterChar).Tags[obj.DelimiterCount];
 
-                renderer.Write(tag.OpeningTag);
-                renderer.WriteChildren(obj);
-                renderer.Write(tag.ClosingTag);
+                    renderer.Write(tag.OpeningTag);
+                    renderer.WriteChildren(obj);
+                    renderer.Write(tag.ClosingTag);
+                }
             }
         }
-    }
-    class Tag
-    {
+        class Tag
+        {
 #pragma warning disable CS0649
-        public int Level;
+            public int Level;
 #pragma warning restore CS0649
-        public string RawTag;
-        public string OpeningTag;
-        public string ClosingTag;
+            public string RawTag;
+            public string OpeningTag;
+            public string ClosingTag;
 
-        public Tag(string tag)
-        {
-            RawTag = tag;
-            OpeningTag = "<" + tag + ">";
-            ClosingTag = "</" + tag + ">";
-        }
-
-        public static implicit operator Tag(string tag)
-            => new Tag(tag);
-    }
-    class EmphasisTestDescriptor
-    {
-        public char Character;
-        public int Minimum;
-        public int Maximum;
-        public Dictionary<int, Tag> Tags = new Dictionary<int, Tag>();
-
-        private EmphasisTestDescriptor(char character, int min, int max)
-        {
-            Character = character;
-            Minimum = min;
-            Maximum = max;
-        }
-        public EmphasisTestDescriptor(char character, int min, int max, params Tag[] tags)
-            : this(character, min, max)
-        {
-            Debug.Assert(tags.Length == max - min + 1);
-            foreach (var tag in tags)
+            public Tag(string tag)
             {
-                Tags.Add(min++, tag);
+                RawTag = tag;
+                OpeningTag = "<" + tag + ">";
+                ClosingTag = "</" + tag + ">";
             }
+
+            public static implicit operator Tag(string tag)
+                => new Tag(tag);
         }
-        public EmphasisTestDescriptor(char character, int min, int max, string tag)
-            : this(character, min, max, new Tag(tag)) { }
-    }
-    class CustomEmphasisInline : EmphasisInline { }
-    static readonly EmphasisTestDescriptor[] EmphasisTestDescriptors = new[]
-    {
-        //                            Min Max
-        new EmphasisTestDescriptor('"', 1, 1, "quotation"),
-        new EmphasisTestDescriptor(',', 1, 2, "comma", "extra-comma"),
-        new EmphasisTestDescriptor('!', 2, 3, "warning", "error"),
-        new EmphasisTestDescriptor('=', 1, 3, "equal", "really-equal", "congruent"),
-        new EmphasisTestDescriptor('1', 1, 1, "one-only"),
-        new EmphasisTestDescriptor('2', 2, 2, "two-only"),
-        new EmphasisTestDescriptor('3', 3, 3, "three-only"),
-    };
+        class EmphasisTestDescriptor
+        {
+            public char Character;
+            public int Minimum;
+            public int Maximum;
+            public Dictionary<int, Tag> Tags = new Dictionary<int, Tag>();
 
-    static readonly MarkdownPipeline Pipeline = new MarkdownPipelineBuilder().Use<EmphasisTestExtension>().Build();
+            private EmphasisTestDescriptor(char character, int min, int max)
+            {
+                Character = character;
+                Minimum = min;
+                Maximum = max;
+            }
+            public EmphasisTestDescriptor(char character, int min, int max, params Tag[] tags)
+                : this(character, min, max)
+            {
+                Debug.Assert(tags.Length == max - min + 1);
+                foreach (var tag in tags)
+                {
+                    Tags.Add(min++, tag);
+                }
+            }
+            public EmphasisTestDescriptor(char character, int min, int max, string tag)
+                : this(character, min, max, new Tag(tag)) { }
+        }
+        class CustomEmphasisInline : EmphasisInline { }
+        static readonly EmphasisTestDescriptor[] EmphasisTestDescriptors = new[]
+        {
+            //                            Min Max
+            new EmphasisTestDescriptor('"', 1, 1, "quotation"),
+            new EmphasisTestDescriptor(',', 1, 2, "comma", "extra-comma"),
+            new EmphasisTestDescriptor('!', 2, 3, "warning", "error"),
+            new EmphasisTestDescriptor('=', 1, 3, "equal", "really-equal", "congruent"),
+            new EmphasisTestDescriptor('1', 1, 1, "one-only"),
+            new EmphasisTestDescriptor('2', 2, 2, "two-only"),
+            new EmphasisTestDescriptor('3', 3, 3, "three-only"),
+        };
 
-    [Test]
-    [TestCase("*foo**",         "<em>foo</em>*")]
-    [TestCase("**foo*",         "*<em>foo</em>")]
-    [TestCase("***foo***",      "<em><strong>foo</strong></em>")]
-    [TestCase("**_foo_**",      "<strong><em>foo</em></strong>")]
-    [TestCase("_**foo**_",      "<em><strong>foo</strong></em>")]
-    [TestCase("\"foo\"",        "<quotation>foo</quotation>")]
-    [TestCase("\"\"foo\"\"",    "<quotation><quotation>foo</quotation></quotation>")]
-    [TestCase("\"foo\"\"",      "<quotation>foo</quotation>&quot;")]
-    [TestCase("\"\"foo\"",      "&quot;<quotation>foo</quotation>")]
-    [TestCase(", foo",          ", foo")]
-    [TestCase(", foo,",         ", foo,")]
-    [TestCase(",some, foo,",    "<comma>some</comma> foo,")]
-    [TestCase(",,foo,,",        "<extra-comma>foo</extra-comma>")]
-    [TestCase(",foo,,",         "<comma>foo</comma>,")]
-    [TestCase(",,,foo,,,",      "<comma><extra-comma>foo</extra-comma></comma>")]
-    [TestCase("*foo*&_foo_",     "<em>foo</em>&amp;<em>foo</em>")]
-    [TestCase("!1!",            "!1!")]
-    [TestCase("!!2!!",          "<warning>2</warning>")]
-    [TestCase("!!!3!!!",        "<error>3</error>")]
-    [TestCase("!!!34!!!!",      "<error>34</error>!")]
-    [TestCase("!!!!43!!!",      "!<error>43</error>")]
-    [TestCase("!!!!44!!!!",     "!<error>44!</error>")] // This is a new case - should the second ! be before or after </error>?
-    [TestCase("!!!!!5!!!!!",    "<warning><error>5</error></warning>")]
-    [TestCase("!!!!!!6!!!!!!",  "<error><error>6</error></error>")]
-    [TestCase("!! !mixed!!!",   "!! !mixed!!!")] // can't open the delimiter because of the whitespace
-    [TestCase("=",              "=")]
-    [TestCase("==",             "==")]
-    [TestCase("====",           "====")]
-    [TestCase("=a",             "=a")]
-    [TestCase("=a=",            "<equal>a</equal>")]
-    [TestCase("==a=",           "=<equal>a</equal>")]
-    [TestCase("==a==",          "<really-equal>a</really-equal>")]
-    [TestCase("==a===",         "<really-equal>a</really-equal>=")]
-    [TestCase("===a===",        "<congruent>a</congruent>")]
-    [TestCase("====a====",      "<equal><congruent>a</congruent></equal>")]
-    [TestCase("=====a=====",    "<really-equal><congruent>a</congruent></really-equal>")]
-    [TestCase("1",              "1")]
-    [TestCase("1 1",            "1 1")]
-    [TestCase("1Foo1",          "<one-only>Foo</one-only>")]
-    [TestCase("1121",           "1<one-only>2</one-only>")]
-    [TestCase("22322",          "<two-only>3</two-only>")]
-    [TestCase("2223222",        "2<two-only>32</two-only>")]
-    [TestCase("22223222",       "22<two-only>32</two-only>")]
-    [TestCase("22223223222",    "22223<two-only>3</two-only>2")]
-    [TestCase("2232",           "2232")]
-    [TestCase("333",            "333")]
-    [TestCase("3334333",        "<three-only>4</three-only>")]
-    [TestCase("33334333",       "3<three-only>4</three-only>")]
-    [TestCase("33343333",       "<three-only>4</three-only>3")]
-    [TestCase("122122",         "<one-only>22</one-only>22")]
-    [TestCase("221221",         "<two-only>1</two-only>1")]
-    [TestCase("122foo221",      "<one-only><two-only>foo</two-only></one-only>")]
-    [TestCase("122foo122",      "<one-only>22foo</one-only>22")]
-    [TestCase("!!!!!Attention:!! \"==1+1== 2\",but ===333 and 222===, mod 111!!!",
-        "<error><warning>Attention:</warning> <quotation><really-equal><one-only>+</one-only></really-equal> 2</quotation><comma>but <congruent>333 and 222</congruent></comma> mod 111</error>")]
-    public void TestEmphasis(string markdown, string expectedHtml)
-    {
-        TestParser.TestSpec(markdown, "<p>" + expectedHtml + "</p>", Pipeline);
+        static readonly MarkdownPipeline Pipeline = new MarkdownPipelineBuilder().Use<EmphasisTestExtension>().Build();
+
+        [Test]
+        [TestCase("*foo**",         "<em>foo</em>*")]
+        [TestCase("**foo*",         "*<em>foo</em>")]
+        [TestCase("***foo***",      "<em><strong>foo</strong></em>")]
+        [TestCase("**_foo_**",      "<strong><em>foo</em></strong>")]
+        [TestCase("_**foo**_",      "<em><strong>foo</strong></em>")]
+        [TestCase("\"foo\"",        "<quotation>foo</quotation>")]
+        [TestCase("\"\"foo\"\"",    "<quotation><quotation>foo</quotation></quotation>")]
+        [TestCase("\"foo\"\"",      "<quotation>foo</quotation>&quot;")]
+        [TestCase("\"\"foo\"",      "&quot;<quotation>foo</quotation>")]
+        [TestCase(", foo",          ", foo")]
+        [TestCase(", foo,",         ", foo,")]
+        [TestCase(",some, foo,",    "<comma>some</comma> foo,")]
+        [TestCase(",,foo,,",        "<extra-comma>foo</extra-comma>")]
+        [TestCase(",foo,,",         "<comma>foo</comma>,")]
+        [TestCase(",,,foo,,,",      "<comma><extra-comma>foo</extra-comma></comma>")]
+        [TestCase("*foo*&_foo_",     "<em>foo</em>&amp;<em>foo</em>")]
+        [TestCase("!1!",            "!1!")]
+        [TestCase("!!2!!",          "<warning>2</warning>")]
+        [TestCase("!!!3!!!",        "<error>3</error>")]
+        [TestCase("!!!34!!!!",      "<error>34</error>!")]
+        [TestCase("!!!!43!!!",      "!<error>43</error>")]
+        [TestCase("!!!!44!!!!",     "!<error>44!</error>")] // This is a new case - should the second ! be before or after </error>?
+        [TestCase("!!!!!5!!!!!",    "<warning><error>5</error></warning>")]
+        [TestCase("!!!!!!6!!!!!!",  "<error><error>6</error></error>")]
+        [TestCase("!! !mixed!!!",   "!! !mixed!!!")] // can't open the delimiter because of the whitespace
+        [TestCase("=",              "=")]
+        [TestCase("==",             "==")]
+        [TestCase("====",           "====")]
+        [TestCase("=a",             "=a")]
+        [TestCase("=a=",            "<equal>a</equal>")]
+        [TestCase("==a=",           "=<equal>a</equal>")]
+        [TestCase("==a==",          "<really-equal>a</really-equal>")]
+        [TestCase("==a===",         "<really-equal>a</really-equal>=")]
+        [TestCase("===a===",        "<congruent>a</congruent>")]
+        [TestCase("====a====",      "<equal><congruent>a</congruent></equal>")]
+        [TestCase("=====a=====",    "<really-equal><congruent>a</congruent></really-equal>")]
+        [TestCase("1",              "1")]
+        [TestCase("1 1",            "1 1")]
+        [TestCase("1Foo1",          "<one-only>Foo</one-only>")]
+        [TestCase("1121",           "1<one-only>2</one-only>")]
+        [TestCase("22322",          "<two-only>3</two-only>")]
+        [TestCase("2232",           "2232")]
+        [TestCase("333",            "333")]
+        [TestCase("3334333",        "<three-only>4</three-only>")]
+        [TestCase("33334333",       "3<three-only>4</three-only>")]
+        [TestCase("33343333",       "<three-only>4</three-only>3")]
+        [TestCase("122122",         "<one-only>22</one-only>22")]
+        [TestCase("221221",         "<two-only>1</two-only>1")]
+        [TestCase("122foo221",      "<one-only><two-only>foo</two-only></one-only>")]
+        [TestCase("122foo122",      "<one-only>22foo</one-only>22")]
+        [TestCase("!!!!!Attention:!! \"==1+1== 2\",but ===333 and 222===, mod 111!!!",
+            "<error><warning>Attention:</warning> <quotation><really-equal><one-only>+</one-only></really-equal> 2</quotation><comma>but <congruent>333 and 222</congruent></comma> mod 111</error>")]
+        public void TestEmphasis(string markdown, string expectedHtml)
+        {
+            TestParser.TestSpec(markdown, "<p>" + expectedHtml + "</p>", Pipeline);
+        }
     }
 }

src/Markdig.Tests/TestEmphasisExtraOptions.cs

@@ -1,43 +1,45 @@
+using NUnit.Framework;
 using Markdig.Extensions.EmphasisExtras;
 
-namespace Markdig.Tests;
-
-[TestFixture]
-public class TestEmphasisExtraOptions
+namespace Markdig.Tests
 {
-    [Test]
-    public void OnlyStrikethrough_Single()
+    [TestFixture]
+    public class TestEmphasisExtraOptions
     {
-        TestParser.TestSpec("~foo~", "<p>~foo~</p>", new MarkdownPipelineBuilder().UseEmphasisExtras(EmphasisExtraOptions.Strikethrough).Build());
-    }
+        [Test]
+        public void OnlyStrikethrough_Single()
+        {
+            TestParser.TestSpec("~foo~", "<p>~foo~</p>", new MarkdownPipelineBuilder().UseEmphasisExtras(EmphasisExtraOptions.Strikethrough).Build());
+        }
 
-    [Test]
-    public void OnlyStrikethrough_Double()
-    {
-        TestParser.TestSpec("~~foo~~", "<p><del>foo</del></p>", new MarkdownPipelineBuilder().UseEmphasisExtras(EmphasisExtraOptions.Strikethrough).Build());
-    }
+        [Test]
+        public void OnlyStrikethrough_Double()
+        {
+            TestParser.TestSpec("~~foo~~", "<p><del>foo</del></p>", new MarkdownPipelineBuilder().UseEmphasisExtras(EmphasisExtraOptions.Strikethrough).Build());
+        }
 
-    [Test]
-    public void OnlySubscript_Single()
-    {
-        TestParser.TestSpec("~foo~", "<p><sub>foo</sub></p>", new MarkdownPipelineBuilder().UseEmphasisExtras(EmphasisExtraOptions.Subscript).Build());
-    }
+        [Test]
+        public void OnlySubscript_Single()
+        {
+            TestParser.TestSpec("~foo~", "<p><sub>foo</sub></p>", new MarkdownPipelineBuilder().UseEmphasisExtras(EmphasisExtraOptions.Subscript).Build());
+        }
 
-    [Test]
-    public void OnlySubscript_Double()
-    {
-        TestParser.TestSpec("~~foo~~", "<p><sub><sub>foo</sub></sub></p>", new MarkdownPipelineBuilder().UseEmphasisExtras(EmphasisExtraOptions.Subscript).Build());
-    }
+        [Test]
+        public void OnlySubscript_Double()
+        {
+            TestParser.TestSpec("~~foo~~", "<p><sub><sub>foo</sub></sub></p>", new MarkdownPipelineBuilder().UseEmphasisExtras(EmphasisExtraOptions.Subscript).Build());
+        }
 
-    [Test]
-    public void SubscriptAndStrikethrough_Single()
-    {
-        TestParser.TestSpec("~foo~", "<p><sub>foo</sub></p>", new MarkdownPipelineBuilder().UseEmphasisExtras(EmphasisExtraOptions.Strikethrough | EmphasisExtraOptions.Subscript).Build());
-    }
+        [Test]
+        public void SubscriptAndStrikethrough_Single()
+        {
+            TestParser.TestSpec("~foo~", "<p><sub>foo</sub></p>", new MarkdownPipelineBuilder().UseEmphasisExtras(EmphasisExtraOptions.Strikethrough | EmphasisExtraOptions.Subscript).Build());
+        }
 
-    [Test]
-    public void SubscriptAndStrikethrough_Double()
-    {
-        TestParser.TestSpec("~~foo~~", "<p><del>foo</del></p>", new MarkdownPipelineBuilder().UseEmphasisExtras(EmphasisExtraOptions.Strikethrough | EmphasisExtraOptions.Subscript).Build());
+        [Test]
+        public void SubscriptAndStrikethrough_Double()
+        {
+            TestParser.TestSpec("~~foo~~", "<p><del>foo</del></p>", new MarkdownPipelineBuilder().UseEmphasisExtras(EmphasisExtraOptions.Strikethrough | EmphasisExtraOptions.Subscript).Build());
+        }
     }
 }

src/Markdig.Tests/TestEmphasisPlus.cs

@@ -1,49 +1,23 @@
 // Copyright (c) Alexandre Mutel. All rights reserved.
-// This file is licensed under the BSD-Clause 2 license.
+// This file is licensed under the BSD-Clause 2 license. 
 // See the license.txt file in the project root for more information.
+using NUnit.Framework;
 
-using Markdig.Syntax;
-using Markdig.Syntax.Inlines;
-
-namespace Markdig.Tests;
-
-[TestFixture]
-public partial class TestEmphasisPlus
+namespace Markdig.Tests
 {
-    [Test]
-    public void StrongNormal()
+    [TestFixture]
+    public partial class TestEmphasisPlus
     {
-        TestParser.TestSpec("***Strong emphasis*** normal", "<p><em><strong>Strong emphasis</strong></em> normal</p>", "");
-    }
+        [Test]
+        public void StrongNormal()
+        {
+            TestParser.TestSpec("***Strong emphasis*** normal", "<p><em><strong>Strong emphasis</strong></em> normal</p>", "");
+        }
 
-    [Test]
-    public void NormalStrongNormal()
-    {
-        TestParser.TestSpec("normal ***Strong emphasis*** normal", "<p>normal <em><strong>Strong emphasis</strong></em> normal</p>", "");
-    }
-
-    [Test]
-    public void SupplementaryPunctuation()
-    {
-        TestParser.TestSpec("a*a∇*a\n\na*∇a*a\n\na*a𝜵*a\n\na*𝜵a*a\n\na*𐬼a*a\n\na*a𐬼*a", "<p>a*a∇*a</p>\n<p>a*∇a*a</p>\n<p>a*a𝜵*a</p>\n<p>a*𝜵a*a</p>\n<p>a*𐬼a*a</p>\n<p>a*a𐬼*a</p>", "");
-    }
-
-    [Test]
-    public void RecognizeSupplementaryChars()
-    {
-        TestParser.TestSpec("🌶️**𰻞**🍜**𰻞**🌶️**麺**🍜", "<p>🌶️<strong>𰻞</strong>🍜<strong>𰻞</strong>🌶️<strong>麺</strong>🍜</p>", "");
-    }
-
-    [Test]
-    public void OpenEmphasisHasConvenientContentStringSlice()
-    {
-        var pipeline = new MarkdownPipelineBuilder().Build();
-
-        var document = Markdown.Parse("test*test", pipeline);
-
-        var emphasisDelimiterLiteral = (LiteralInline)((ParagraphBlock)document.LastChild).Inline.ElementAt(1);
-        Assert.That(emphasisDelimiterLiteral.Content.Text == "test*test");
-        Assert.That(emphasisDelimiterLiteral.Content.Start == 4);
-        Assert.That(emphasisDelimiterLiteral.Content.End == 4);
+        [Test]
+        public void NormalStrongNormal()
+        {
+            TestParser.TestSpec("normal ***Strong emphasis*** normal", "<p>normal <em><strong>Strong emphasis</strong></em> normal</p>", "");
+        }
     }
 }