Example API doc generation

.github/workflows/ci.yml

@@ -11,11 +11,22 @@ 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@v2
+      with:
+        submodules: true
+        fetch-depth: 0
+
+    - name: Install .NET 6.0
+      uses: actions/setup-dotnet@v1
+      with:
+        dotnet-version: '6.0.x'
+
+    - name: Build, Test, Pack, Publish
+      shell: bash
+      run: |
+        dotnet tool install -g dotnet-releaser
+        dotnet-releaser run --nuget-token "${{secrets.NUGET_TOKEN}}" --github-token "${{secrets.GITHUB_TOKEN}}" src/dotnet-releaser.toml

.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>

.gitignore

@@ -242,3 +242,6 @@ _Pvt_Extensions
 
 # Remove artifacts produced by dotnet-releaser
 artifacts-dotnet-releaser/
+
+# Remove .lunet temp folder
+.lunet/build

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-extensions.md

@@ -1,6 +1,6 @@
 # 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.
+Markdig was [implemented in such a way](http://xoofx.com/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.
 

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.30)](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`.
@@ -70,7 +70,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,10 +101,6 @@ 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)
@@ -144,16 +140,16 @@ AMD Ryzen 9 5950X, 1 CPU, 32 logical and 16 physical cores
 - Markdig is roughly **x100 times faster than MarkdownSharp**
 - **20% faster than the reference cmark C implementation** 
 
-## Sponsors
 
-Supports this project with a monthly donation and help me continue improving it. \[[Become a sponsor](https://github.com/sponsors/xoofx)\]
+## Donate
 
-[<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)
+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 +157,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)

site/.lunet/css/main.css

@@ -0,0 +1,162 @@
+/* main */
+:root {
+  --base-html-font-size: 62.5%;
+  --base-font-size: 1.65rem;
+  --container-xl-max-width: 160rem;
+  --site-logo-size: 45px;
+  --site-logo-url: url("/img/markdig.png");
+}
+
+/* make tocbot working with halfmoon */
+html, body, .page-wrapper, .content-wrapper {
+  position: static;
+}
+
+.page-wrapper {
+  overflow: visible;
+}
+
+/* disable any box around active headers with tocbot */
+h1:focus, h1:active,
+h2:focus, h2:active,
+h3:focus, h3:active,
+h4:focus, h4:active,
+h5:focus, h5:active,
+h6:focus, h6:active
+{
+  outline: none;
+}
+
+.nav-item.active {
+  border-bottom-width: 2px;
+  border-bottom-style: solid;
+  border-bottom-color: var(--lm-navbar-link-active-text-color);
+}
+
+.main-row {
+  min-height: 92vh;
+}
+
+.nav-item.active .nav-link {
+    color: var(--lm-navbar-link-active-text-color);
+    background-color: var(--lm-navbar-link-active-bg-color);
+}
+
+.site-logo {
+  background: transparent var(--site-logo-url) no-repeat scroll 0px 0px / var(--site-logo-size) var(--site-logo-size);
+  display: block;
+  width: var(--site-logo-size);
+  height: var(--site-logo-size);
+}
+
+.in-this-article-nav {
+  position: fixed;
+  margin-right: 2rem;
+  z-index: 20;
+  padding: 0.5rem;
+  border-radius: 0.4rem;
+}
+
+.in-this-article-nav .title {
+  font-weight: bold;
+  font-size: 1em;
+  padding-bottom: 1em;
+}
+
+.content .is-active-link::before {
+  background-color: var(--primary-color);
+}
+
+.heading-anchor-hidden {
+  display: none !important;
+}
+
+@media (min-width: 1600px) {
+  html {
+      font-size: var(--base-html-font-size);
+  }
+}
+@media (min-width: 1920px) {
+  html {
+      font-size: var(--base-html-font-size);
+  }
+}
+
+table.api-dotnet-inherit, table.api-dotnet-implements, table.api-dotnet-derived {
+  margin-bottom: 1em;
+}
+
+.api-dotnet-inherit td, .api-dotnet-implements td, .api-dotnet-derived td {
+  vertical-align: top;
+}
+
+.api-dotnet-inherit div:not(:first-child):before {
+  content: " ᐅ ";
+  white-space: pre;
+}
+
+/*.api-dotnet-inherit td, .api-dotnet-inherit tr, .api-dotnet-implements td, .api-dotnet-implements tr, .api-dotnet-derived tr  {
+  display: flex;
+}
+*/
+
+.api-dotnet-inherit div, .api-dotnet-implements div
+{
+  display: inline-block;
+}
+
+.api-dotnet-inherit td:not(:first-child), .api-dotnet-implements td:not(:first-child), .api-dotnet-derived td:not(:first-child) {
+  padding-left: 1em;
+}
+
+.api-dotnet-implements div:not(:first-child):before {
+  content: ", ";
+  white-space: pre;
+}
+
+.api-dotnet-parameter-list {
+  display: flex;
+}
+
+.api-dotnet-parameter-list dd {
+  margin-left: 1em;
+}
+
+dl.api-dotnet-parameter-list {
+  margin-bottom: 0px;
+}
+
+table.api-dotnet-members-table {
+  width: 100%;
+}
+
+table.api-dotnet-members-table p {
+  margin-top: 0px;
+  margin-bottom: 0px;
+}
+
+.api-dotnet-members-table tr td:first-child {
+  width: 33%;
+}
+
+div.api-dotnet {
+  width: 100%;
+}
+
+.api-dotnet-members-table tr:not(:first-child) {
+  border-top: 1px solid #ddd;
+}
+
+.api-dotnet-members-table td {
+  padding-top: 0.5rem;
+  padding-bottom: 0.5rem;
+}
+
+@media (prefers-color-scheme: dark) {
+  .api-dotnet-members-table tr:not(:first-child) {
+    border-top: 1px solid #777;
+  }
+}
+
+
+

site/.lunet/css/prism.css

@@ -0,0 +1,701 @@
+/* PrismJS 1.15.0
+https://prismjs.com/download.html#themes=prism-coy&languages=markup+clike+c+csharp+cpp+fsharp+markdown&plugins=line-highlight+line-numbers+toolbar+show-language */
+/**
+ * prism.js Coy theme for JavaScript, CoffeeScript, CSS and HTML
+ * Based on https://github.com/tshedor/workshop-wp-theme (Example: http://workshop.kansan.com/category/sessions/basics or http://workshop.timshedor.com/category/sessions/basics);
+ * @author Tim  Shedor
+ */
+
+@media (prefers-color-scheme: light) {
+code[class*="language-"],
+pre[class*="language-"] {
+	color: #393A34;
+	background: none;
+	font-family: Consolas, Monaco, 'Andale Mono', 'Ubuntu Mono', monospace;
+	text-align: left;
+	white-space: pre-wrap;
+	word-spacing: normal;
+	word-break: break-word;
+	word-wrap: normal;
+	line-height: 1.5;
+
+	-moz-tab-size: 4;
+	-o-tab-size: 4;
+	tab-size: 4;
+
+	-webkit-hyphens: none;
+	-moz-hyphens: none;
+	-ms-hyphens: none;
+	hyphens: none;
+}
+
+/* Code blocks */
+pre[class*="language-"] {
+	position: relative;
+	margin: .5em 0;
+	overflow: visible;
+	padding: 0;
+}
+pre[class*="language-"]>code {
+	position: relative;
+	border-left: 4px solid #358ccb;
+	box-shadow: -1px 0px 0px 0px #358ccb, 0px 0px 0px 1px #dfdfdf;
+	background-color: #fdfdfd;
+	background-image: linear-gradient(transparent 50%, rgba(69, 142, 209, 0.04) 50%);
+	background-size: 3em 3em;
+	background-origin: content-box;
+	background-attachment: local;
+}
+
+code[class*="language"] {
+	max-height: inherit;
+	height: inherit;
+	padding: 0 1em;
+	display: block;
+	overflow: auto;
+}
+
+/* Margin bottom to accommodate shadow */
+:not(pre) > code[class*="language-"],
+pre[class*="language-"] {
+	background-color: #fdfdfd;
+	-webkit-box-sizing: border-box;
+	-moz-box-sizing: border-box;
+	box-sizing: border-box;
+	margin-bottom: 1em;
+}
+
+/* Inline code */
+:not(pre) > code[class*="language-"] {
+	position: relative;
+	padding: .2em;
+	border-radius: 0.3em;
+	color: #c92c2c;
+	border: 1px solid #dddddd;
+	display: inline;
+	white-space: normal;
+}
+
+pre[class*="language-"]:before,
+pre[class*="language-"]:after {
+	content: '';
+	z-index: -2;
+	display: block;
+	position: absolute;
+	bottom: 0.75em;
+	left: 0.18em;
+	width: 40%;
+	height: 20%;
+  max-height: 13em;
+}
+
+:not(pre) > code[class*="language-"]:after,
+pre[class*="language-"]:after {
+	right: 0.75em;
+	left: auto;
+	-webkit-transform: rotate(2deg);
+	-moz-transform: rotate(2deg);
+	-ms-transform: rotate(2deg);
+	-o-transform: rotate(2deg);
+	transform: rotate(2deg);
+}
+
+.token.comment,
+.token.block-comment,
+.token.prolog,
+.token.doctype,
+.token.cdata {
+    color: #008000; font-style: italic;
+}
+
+.token.char,
+.token.string {
+    color: #A31515;
+}
+
+.token.punctuation {
+	color: #393A34; /* no highlight */
+}
+
+.token.deleted {
+	color: #c92c2c;
+}
+
+.token.function-name,
+.token.function {
+    color: #393A34;
+}
+
+
+.token.tag,
+.token.selector {
+    color: #800000;
+}
+
+.token.attr-name,
+.token.regex,
+.token.entity {
+    color: #ff0000;
+}
+
+.token.builtin,
+.token.url,
+.token.symbol,
+.token.number,
+.token.boolean,
+.token.variable,
+.token.constant,
+.token.inserted {
+    color: #36acaa;
+}
+
+.token.operator,
+.token.variable {
+	color: #a67f59;
+	background: rgba(255, 255, 255, 0.5);
+}
+
+.token.atrule,
+.token.attr-value,
+.token.keyword,
+.token.class-name {
+    color: #0000ff;
+}
+
+.token.directive.tag  .tag {
+    background: #ffff00;
+    color: #393A34;
+}
+
+.token.class-name,
+.token.property {
+    color: #2B91AF;
+}
+
+.token.important {
+	color: #e90;
+}
+
+.language-css .token.string,
+.style .token.string {
+	color: #a67f59;
+	background: rgba(255, 255, 255, 0.5);
+}
+
+.token.important,
+.token.bold {
+    font-weight: bold;
+}
+
+.token.bold {
+	font-weight: bold;
+}
+.token.italic {
+	font-style: italic;
+}
+
+.token.entity {
+	cursor: help;
+}
+
+.namespace {
+	opacity: .7;
+}
+
+@media screen and (max-width: 767px) {
+	pre[class*="language-"]:before,
+	pre[class*="language-"]:after {
+		bottom: 14px;
+		box-shadow: none;
+	}
+
+}
+
+/* Plugin styles */
+.token.tab:not(:empty):before,
+.token.cr:before,
+.token.lf:before {
+	color: #e0d7d1;
+}
+
+/* Plugin styles: Line Numbers */
+pre[class*="language-"].line-numbers.line-numbers {
+	padding-left: 0;
+}
+
+pre[class*="language-"].line-numbers.line-numbers code {
+	padding-left: 3.8em;
+}
+
+pre[class*="language-"].line-numbers.line-numbers .line-numbers-rows {
+	left: 0;
+}
+
+/* Plugin styles: Line Highlight */
+pre[class*="language-"][data-line] {
+	padding-top: 0;
+	padding-bottom: 0;
+	padding-left: 0;
+}
+pre[data-line] code {
+	position: relative;
+	padding-left: 4em;
+}
+pre .line-highlight {
+	margin-top: 0;
+}
+
+pre[data-line] {
+	position: relative;
+	padding: 1em 0 1em 3em;
+}
+
+.line-highlight {
+	position: absolute;
+	left: 0;
+	right: 0;
+	padding: inherit 0;
+	margin-top: 1em; /* Same as .prism’s padding-top */
+
+	background: hsla(24, 20%, 50%,.08);
+	background: linear-gradient(to right, hsla(24, 20%, 50%,.1) 70%, hsla(24, 20%, 50%,0));
+
+	pointer-events: none;
+
+	line-height: inherit;
+	white-space: pre;
+}
+
+	.line-highlight:before,
+	.line-highlight[data-end]:after {
+		content: attr(data-start);
+		position: absolute;
+		top: .4em;
+		left: .6em;
+		min-width: 1em;
+		padding: 0 .5em;
+		background-color: hsla(24, 20%, 50%,.4);
+		color: hsl(24, 20%, 95%);
+		font: bold 65%/1.5 sans-serif;
+		text-align: center;
+		vertical-align: .3em;
+		border-radius: 999px;
+		text-shadow: none;
+		box-shadow: 0 1px white;
+	}
+
+	.line-highlight[data-end]:after {
+		content: attr(data-end);
+		top: auto;
+		bottom: .4em;
+	}
+
+.line-numbers .line-highlight:before,
+.line-numbers .line-highlight:after {
+	content: none;
+}
+
+pre[class*="language-"].line-numbers {
+	position: relative;
+	padding-left: 3.8em;
+	counter-reset: linenumber;
+}
+
+pre[class*="language-"].line-numbers > code {
+	position: relative;
+	white-space: inherit;
+}
+
+.line-numbers .line-numbers-rows {
+	position: absolute;
+	pointer-events: none;
+	top: 0;
+	font-size: 100%;
+	left: -3.8em;
+	width: 3em; /* works for line-numbers below 1000 lines */
+	letter-spacing: -1px;
+	border-right: 1px solid #a5a5a5;
+
+	-webkit-user-select: none;
+	-moz-user-select: none;
+	-ms-user-select: none;
+	user-select: none;
+
+}
+
+	.line-numbers-rows > span {
+		pointer-events: none;
+		display: block;
+		counter-increment: linenumber;
+	}
+
+		.line-numbers-rows > span:before {
+			content: counter(linenumber);
+			color: #2B91AF;
+			display: block;
+			padding-right: 0.8em;
+			text-align: right;
+		}
+
+div.code-toolbar {
+	position: relative;
+}
+
+div.code-toolbar > .toolbar {
+	position: absolute;
+	top: .3em;
+	right: .2em;
+	transition: opacity 0.3s ease-in-out;
+	opacity: 0;
+}
+
+div.code-toolbar:hover > .toolbar {
+	opacity: 1;
+}
+
+div.code-toolbar > .toolbar .toolbar-item {
+	display: inline-block;
+}
+
+div.code-toolbar > .toolbar a {
+	cursor: pointer;
+}
+
+div.code-toolbar > .toolbar button {
+	background: none;
+	border: 0;
+	color: inherit;
+	font: inherit;
+	line-height: normal;
+	overflow: visible;
+	padding: 0;
+	-webkit-user-select: none; /* for button */
+	-moz-user-select: none;
+	-ms-user-select: none;
+}
+
+div.code-toolbar > .toolbar a,
+div.code-toolbar > .toolbar button,
+div.code-toolbar > .toolbar span {
+	color: #bbb;
+	font-size: .8em;
+	padding: 0 .5em;
+	background: #f5f2f0;
+	background: rgba(224, 224, 224, 0.2);
+	box-shadow: 0 2px 0 0 rgba(0,0,0,0.2);
+	border-radius: .5em;
+}
+
+div.code-toolbar > .toolbar a:hover,
+div.code-toolbar > .toolbar a:focus,
+div.code-toolbar > .toolbar button:hover,
+div.code-toolbar > .toolbar button:focus,
+div.code-toolbar > .toolbar span:hover,
+div.code-toolbar > .toolbar span:focus {
+	color: inherit;
+	text-decoration: none;
+}
+}
+
+@media (prefers-color-scheme: dark) {
+/* https://github.com/PrismJS/prism-themes/blob/master/themes/prism-vsc-dark-plus.css */
+	pre[class*="language-"],
+	code[class*="language-"] {
+		color: #d4d4d4;
+		font-size: 13px;
+		text-shadow: none;
+		font-family: Menlo, Monaco, Consolas, "Andale Mono", "Ubuntu Mono", "Courier New", monospace;
+		direction: ltr;
+		text-align: left;
+		white-space: pre-wrap;
+		word-spacing: normal;
+    word-break: break-word;
+		line-height: 1.5;
+		-moz-tab-size: 4;
+		-o-tab-size: 4;
+		tab-size: 4;
+		-webkit-hyphens: none;
+		-moz-hyphens: none;
+		-ms-hyphens: none;
+		hyphens: none;
+  }
+
+  pre[class*="language-"] {
+    position: relative;
+    margin: .5em 0;
+    overflow: visible;
+		background: #1e1e1e;
+	}
+
+  pre[class*="language-"]>code {
+    border-left: 4px solid #358ccb;
+  }
+
+  code[class*="language"] {
+    max-height: inherit;
+    height: inherit;
+    padding: 0.5em 1em;
+    display: block;
+    overflow: auto;
+  }
+
+	pre[class*="language-"]::selection,
+	code[class*="language-"]::selection,
+	pre[class*="language-"] *::selection,
+	code[class*="language-"] *::selection {
+		text-shadow: none;
+		background: #75a7ca;
+	}
+
+	@media print {
+		pre[class*="language-"],
+		code[class*="language-"] {
+			text-shadow: none;
+		}
+	}
+
+	:not(pre) > code[class*="language-"] {
+		padding: .1em .3em;
+		border-radius: .3em;
+		color: #db4c69;
+		background: #f9f2f4;
+	}
+	/*********************************************************
+	* Tokens
+	*/
+	.namespace {
+		opacity: .7;
+	}
+
+	.token.doctype .token.doctype-tag {
+		color: #569CD6;
+	}
+
+	.token.doctype .token.name {
+		color: #9cdcfe;
+	}
+
+	.token.comment,
+	.token.prolog {
+		color: #6a9955;
+	}
+
+	.token.punctuation,
+	.language-html .language-css .token.punctuation,
+	.language-html .language-javascript .token.punctuation {
+		color: #d4d4d4;
+	}
+
+	.token.property,
+	.token.tag,
+	.token.boolean,
+	.token.number,
+	.token.constant,
+	.token.symbol,
+	.token.inserted,
+	.token.unit {
+		color: #b5cea8;
+	}
+
+	.token.selector,
+	.token.attr-name,
+	.token.string,
+	.token.char,
+	.token.builtin,
+	.token.deleted {
+		color: #ce9178;
+	}
+
+	.language-css .token.string.url {
+		text-decoration: underline;
+	}
+
+	.token.operator,
+	.token.entity {
+		color: #d4d4d4;
+	}
+
+	.token.operator.arrow {
+		color: #569CD6;
+	}
+
+	.token.atrule {
+		color: #ce9178;
+	}
+
+	.token.atrule .token.rule {
+		color: #c586c0;
+	}
+
+	.token.atrule .token.url {
+		color: #9cdcfe;
+	}
+
+	.token.atrule .token.url .token.function {
+		color: #dcdcaa;
+	}
+
+	.token.atrule .token.url .token.punctuation {
+		color: #d4d4d4;
+	}
+
+	.token.keyword {
+		color: #569CD6;
+	}
+
+	.token.keyword.module,
+	.token.keyword.control-flow {
+		color: #c586c0;
+	}
+
+	.token.function,
+	.token.function .token.maybe-class-name {
+		color: #dcdcaa;
+	}
+
+	.token.regex {
+		color: #d16969;
+	}
+
+	.token.important {
+		color: #569cd6;
+	}
+
+	.token.italic {
+		font-style: italic;
+	}
+
+	.token.constant {
+		color: #9cdcfe;
+	}
+
+	.token.class-name,
+	.token.maybe-class-name {
+		color: #4ec9b0;
+	}
+
+	.token.console {
+		color: #9cdcfe;
+	}
+
+	.token.parameter {
+		color: #9cdcfe;
+	}
+
+	.token.interpolation {
+		color: #9cdcfe;
+	}
+
+	.token.punctuation.interpolation-punctuation {
+		color: #569cd6;
+	}
+
+	.token.boolean {
+		color: #569cd6;
+	}
+
+	.token.property,
+	.token.variable,
+	.token.imports .token.maybe-class-name,
+	.token.exports .token.maybe-class-name {
+		color: #9cdcfe;
+	}
+
+	.token.selector {
+		color: #d7ba7d;
+	}
+
+	.token.escape {
+		color: #d7ba7d;
+	}
+
+	.token.tag {
+		color: #569cd6;
+	}
+
+	.token.tag .token.punctuation {
+		color: #808080;
+	}
+
+	.token.cdata {
+		color: #808080;
+	}
+
+	.token.attr-name {
+		color: #9cdcfe;
+	}
+
+	.token.attr-value,
+	.token.attr-value .token.punctuation {
+		color: #ce9178;
+	}
+
+	.token.attr-value .token.punctuation.attr-equals {
+		color: #d4d4d4;
+	}
+
+	.token.entity {
+		color: #569cd6;
+	}
+
+	.token.namespace {
+		color: #4ec9b0;
+	}
+	/*********************************************************
+	* Language Specific
+	*/
+
+	pre[class*="language-javascript"],
+	code[class*="language-javascript"],
+	pre[class*="language-jsx"],
+	code[class*="language-jsx"],
+	pre[class*="language-typescript"],
+	code[class*="language-typescript"],
+	pre[class*="language-tsx"],
+	code[class*="language-tsx"] {
+		color: #9cdcfe;
+	}
+
+	pre[class*="language-css"],
+	code[class*="language-css"] {
+		color: #ce9178;
+	}
+
+	pre[class*="language-html"],
+	code[class*="language-html"] {
+		color: #d4d4d4;
+	}
+
+	.language-regex .token.anchor {
+		color: #dcdcaa;
+	}
+
+	.language-html .token.punctuation {
+		color: #808080;
+	}
+	/*********************************************************
+	* Line highlighting
+	*/
+	pre[data-line] {
+		position: relative;
+	}
+
+	pre[class*="language-"] > code[class*="language-"] {
+		position: relative;
+		z-index: 1;
+	}
+
+	.line-highlight {
+		position: absolute;
+		left: 0;
+		right: 0;
+		padding: inherit 0;
+		margin-top: 1em;
+		background: #f7ebc6;
+		box-shadow: inset 5px 0 0 #f7d87c;
+		z-index: 0;
+		pointer-events: none;
+		line-height: inherit;
+		white-space: pre;
+	}
+}

site/.lunet/js/xoofx.js

@@ -0,0 +1,24 @@
+anchors.add();
+var jstoc = document.getElementsByClassName("js-toc");
+if (jstoc.length > 0)
+{
+    tocbot.init({
+        // Which headings to grab inside of the contentSelector element.
+        headingSelector: 'h2, h3, h4, h5',
+        collapseDepth: 3,
+        orderedList: true,
+        hasInnerContainers: true,
+    });
+}
+
+(function () {
+  const InitLunetTheme = function (e) {
+    if (halfmoon.darkModeOn != e.matches) {
+      halfmoon.toggleDarkMode();
+    }
+  }
+
+  let colorSchemeQueryList = window.matchMedia('(prefers-color-scheme: dark)')
+  InitLunetTheme(colorSchemeQueryList);
+  colorSchemeQueryList.addListener(InitLunetTheme);
+})();

site/.lunet/layouts/_default.sbn-html

@@ -0,0 +1,65 @@
+<!DOCTYPE html>
+<html lang="en" itemscope itemtype="http://schema.org/WebPage" class="my-html-setup">
+  <head>
+    {{~ Head ~}}
+  </head>
+  <body class="with-custom-webkit-scrollbars with-custom-css-scrollbars">
+    <div class="page-wrapper with-transitions">
+        <div class="sticky-alerts"></div>
+        <div class="content-wrapper bg-light-lm bg-dark-dm">
+            <div class="container-xl bg-white-lm bg-dark-light-dm">
+                <div class="row">
+                    <div class="col-xl-12">
+                        <nav class="navbar">
+                            <a class="site-logo navbar-brand" href="/"></a>
+                            <div id="navbarSupportedContent" class="collapse navbar-collapse justify-content-between">
+                                {{~ site.menu.home.render {
+                                        depth: 1,
+                                        kind: "nav",
+                                        list_class: "w-100"
+                                    }
+                                ~}}
+                            </div>
+                        </nav>
+                    </div>
+                </div>
+                <div class="row main-row">
+                    {{~ $main_content_col_size = 8 ~}}
+                    {{~ if page.nomenu; $main_content_col_size = $main_content_col_size + 2; end }}
+                    {{~ if page.notoc; $main_content_col_size = $main_content_col_size + 2; end }}
+                    {{~ if !page.nomenu ~}}
+                    <div class="col-xl-2 ">
+                        <div class="content">
+                            Menu
+                        </div>
+                    </div>
+                    {{~ end ~}}
+                    <div class="col-xl-{{ $main_content_col_size }} ">
+                        <div class="content js-toc-content">
+                            {{ content }}
+                        </div>
+                    </div>
+                    {{~ if !page.notoc ~}}
+                    <div class="col-xl-2 ">
+                        <div class="content">
+                            <div class="in-this-article-nav">
+                                <div class="title">In this article</div>
+                                <nav class="js-toc toc"></nav>
+                            </div>
+                        </div>
+                    </div>
+                    {{~ end ~}}
+                </div>
+                <div class="row">
+                    <div class="col-xl-12">
+                        <nav class="navbar navbar-fixed-bottom justify-content-center">
+                            <footer>Copyright &copy; 2009 - {{ date.now.year }}, Alexandre Mutel - Blog content licensed under the Creative Commons <a href="http://creativecommons.org/licenses/by/2.5/">CC BY 2.5</a> | Site powered by <a href="https://github.com/lunet-io/lunet">lunet</a></footer>
+                        </nav>
+                    </div>
+                </div>
+            </div>
+        </div>
+    </div>
+  </body>
+</html>
+

site/.lunet/layouts/simple.sbn-html

@@ -0,0 +1,5 @@
+---
+layout: _default
+---
+<h1 class="title">{{ page.title_html ?? page.title }}</h1>
+{{ content }}

site/config.scriban

@@ -0,0 +1,70 @@
+# Site Settings
+author = "Alexandre Mutel"
+title = "markdig"
+description = "markdig website"
+
+html.head.title = do; ret page.title + " | " + site.title; end
+
+basepath = ""
+baseurl = baseurl ?? "https://markdig.net"
+
+# Github repository
+github_user = "xoofx"
+github_repo_url = "https://github.com/lunet-io/markdig/"
+
+with cards.twitter
+    enable = true
+    card = "summary_large_image"
+    user = "markdig"
+    image = "/images/twitter-banner.png"
+end
+
+# Resources bundle
+with bundle
+    fontawesome = resource "npm:font-awesome" "4.7.0"
+    halfmoon = resource "npm:halfmoon" "1.1.0"
+    tocbot = resource "npm:tocbot" "4.12.1"
+    anchorjs = resource "npm:anchor-js" "4.2.2"
+    prismjs = resource "npm:prismjs" "1.20.0"
+
+    # scss.includes.add fontawesome.path + "/scss"
+
+    # css files
+    css halfmoon "/css/halfmoon-variables.min.css"
+    css tocbot "/dist/tocbot.css"
+    css fontawesome "/css/font-awesome.min.css"
+    css "/css/prism.css"
+    css "/css/main.css"
+
+    # js files
+    js anchorjs "/anchor.min.js"
+    js halfmoon "/js/halfmoon.min.js"
+    js tocbot "/dist/tocbot.min.js"
+    js prismjs "/prism.js"
+    js prismjs "/components/prism-shell-session.min.js"
+    js prismjs "/components/prism-clike.min.js"
+    js prismjs "/components/prism-c.min.js"
+    js prismjs "/components/prism-cpp.min.js"
+    js prismjs "/components/prism-csharp.min.js"
+    js "/js/prism-stark.js"
+    js "/js/xoofx.js"
+
+    # copy font files
+    content fontawesome "/fonts/fontawesome-webfont.*" "/fonts/"
+
+    # concatenate css/js files
+    concat = true
+    minify = true
+end
+
+with attributes
+    # match "/blog/**/[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]*.md" {
+    #    url: "/:section/:year/:month/:day/:title:output_ext"
+    #}
+end
+
+with api.dotnet
+    title = "Markdig .NET API Reference"
+    projects = ["../src/Markdig/Markdig.csproj"]
+    properties = {TargetFramework: "netstandard2.0"}
+end

site/menu.yml

@@ -0,0 +1,3 @@
+home:
+  - {path: readme.md}
+  - {path: api/readme.md, title: "Markdig API"}

site/readme.md

@@ -0,0 +1,10 @@
+---
+layout: simple
+title: Home
+title_html: Hi and Welcome!
+---
+
+Hello World!
+
+Test: <xref:system.object>
+

site/system.md

@@ -0,0 +1,8 @@
+---
+uid: system.object
+layout: simple
+title: Home
+title_html: Hi and Welcome!
+---
+
+Hello World from system.object!

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,10 +1,9 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFramework>net6.0</TargetFramework>
     <OutputType>Exe</OutputType>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <IsPackable>false</IsPackable>
-    <ImplicitUsings>enable</ImplicitUsings>
   </PropertyGroup>
   <ItemGroup>
     <None Remove="spec.md" />
@@ -19,12 +18,12 @@
     </Content>
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="BenchmarkDotNet" Version="0.14.0" />
-    <PackageReference Include="BenchmarkDotNet.Diagnostics.Windows" Version="0.14.0" />
+    <PackageReference Include="BenchmarkDotNet" Version="0.13.1" />
+    <PackageReference Include="BenchmarkDotNet.Diagnostics.Windows" Version="0.13.1" />
     <PackageReference Include="CommonMark.NET" Version="0.15.1" />
     <PackageReference Include="Markdown" Version="2.2.1" />
     <PackageReference Include="MarkdownSharp" Version="2.0.5" />
-    <PackageReference Include="Microsoft.Diagnostics.Runtime" Version="3.1.512801" />
+    <PackageReference Include="Microsoft.Diagnostics.Runtime" Version="2.0.226801" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\Markdig\Markdig.csproj" />

src/Markdig.Benchmarks/Program.cs

@@ -2,75 +2,76 @@
 // This file is licensed under the BSD-Clause 2 license. 
 // See the license.txt file in the project root for more information.
 
+using System.IO;
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Configs;
 using BenchmarkDotNet.Running;
-
 using Markdig;
 
 
-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());
-    }
+        public Program()
+        {
+            //text = File.ReadAllText("progit.md");
+            text = File.ReadAllText("spec.md");
+        }
 
-    [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 = "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 = "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 = "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 = "MarkdownSharp")]
-    public void TestMarkdownSharp()
-    {
-        new MarkdownSharp.Markdown().Transform(text);
-    }
+        [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();
+        }
 
-    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);
+        [Benchmark(Description = "MarkdownSharp")]
+        public void TestMarkdownSharp()
+        {
+            new MarkdownSharp.Markdown().Transform(text);
+        }
 
-        //var  config = DefaultConfig.Instance;
-        BenchmarkRunner.Run<Program>(config);
-        //BenchmarkRunner.Run<TestDictionary>(config);
-        //BenchmarkRunner.Run<TestMatchPerf>();
-        //BenchmarkRunner.Run<TestStringPerf>();
+        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;
+            BenchmarkRunner.Run<Program>(config);
+            //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.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,20 +1,18 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net6.0;net8.0;net9.0</TargetFrameworks>
+    <TargetFramework>net6.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>
+    <SpecExecutable>$(MSBuildProjectDirectory)\..\SpecFileGen\bin\$(Configuration)\net6.0\SpecFileGen.dll</SpecExecutable>
+    <SpecTimestamp>$(MSBuildProjectDirectory)\..\SpecFileGen\bin\$(Configuration)\net6.0\SpecFileGen.timestamp</SpecTimestamp>
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.12.0" />
-    <PackageReference Include="NUnit" Version="4.3.2" />
-    <PackageReference Include="NUnit3TestAdapter" Version="4.6.0" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.1.0" />
+    <PackageReference Include="NUnit" Version="3.13.3" />
+    <PackageReference Include="NUnit3TestAdapter" Version="4.2.1" />
   </ItemGroup>
 
   <ItemGroup>
@@ -22,10 +20,6 @@
     <ProjectReference Include="..\SpecFileGen\SpecFileGen.csproj" />
   </ItemGroup>
 
-  <ItemGroup>
-    <Using Include="NUnit.Framework" />
-  </ItemGroup>
-
   <ItemGroup>
     <ItemSpecExecutable Include="$(SpecExecutable)" />
     <InputSpecFiles Include="Specs\*.md" />

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,98 @@ $$
 <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");
+            var pl = new MarkdownPipelineBuilder().UseMathematics().Build(); // UseEmphasisExtras(EmphasisExtraOptions.Subscript).Build()
+            var html = Markdown.ToHtml(math, pl);
+            //Console.WriteLine(html);
+        }
 
-    [Test]
-    public void InlineMathExpression()
-    {
-        string math = @"Math expressions
+        [Test]
+        public void InlineMathExpression()
+        {
+            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 html = Markdown.ToHtml(math, pl);
 
-        var test1 = html.Contains("<p><span class=\"math\">\\(");
-        var test2 = html.Contains("\\)</span></p>");
-        if (!test1 || !test2)
-        {
-            Console.WriteLine(html);
+            var test1 = html.Contains("<p><span class=\"math\">\\(");
+            var test2 = html.Contains("\\)</span></p>");
+            if (!test1 || !test2)
+            {
+                Console.WriteLine(html);
+            }
+
+            Assert.IsTrue(test1, "Leading bracket missing");
+            Assert.IsTrue(test2, "Trailing bracket missing");
         }
 
-        Assert.IsTrue(test1, "Leading bracket missing");
-        Assert.IsTrue(test2, "Trailing bracket missing");
-    }
-
-    [Test]
-    public void BlockMathExpression()
-    {
-        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 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)
-        {
-            Console.WriteLine(html);
+            var html = Markdown.ToHtml(math, pl);
+            var test1 = html.Contains("<div class=\"math\">\n\\[");
+            var test2 = html.Contains("\\]</div>");
+            if (!test1 || !test2)
+            {
+                Console.WriteLine(html);
+            }
+
+            Assert.IsTrue(test1, "Leading bracket missing");
+            Assert.IsTrue(test2, "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/Program.cs

@@ -2,15 +2,18 @@
 // 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;
 
-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();
+        }
     }
 }

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 +1,25 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Markdig.Renderers.Roundtrip;
+using Markdig.Syntax;
+using NUnit.Framework;
 using static Markdig.Tests.TestRoundtrip;
 
-namespace Markdig.Tests.RoundtripSpecs;
-
-[TestFixture]
-public class TestYamlFrontMatterBlock
+namespace Markdig.Tests.RoundtripSpecs
 {
-    [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)
+    [TestFixture]
+    public class TestYamlFrontMatterBlock
     {
-        RoundTrip(value);
+        [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/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/AutoLinks.generated.cs

@@ -533,28 +533,5 @@ namespace Markdig.Tests.Specs.AutoLinks
 
             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");
-        }
     }
 }

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/CommonMark.md

@@ -1,9 +1,9 @@
 ---
 title: CommonMark Spec
 author: John MacFarlane
-version: '0.31.2'
-date: '2024-01-28'
-license: '[CC-BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/)'
+version: '0.30'
+date: '2021-06-19'
+license: '[CC-BY-SA 4.0](http://creativecommons.org/licenses/by-sa/4.0/)'
 ...
 
 # Introduction
@@ -14,7 +14,7 @@ Markdown is a plain text format for writing structured documents,
 based on conventions for indicating formatting in email
 and usenet posts.  It was developed by John Gruber (with
 help from Aaron Swartz) and released in 2004 in the form of a
-[syntax description](https://daringfireball.net/projects/markdown/syntax)
+[syntax description](http://daringfireball.net/projects/markdown/syntax)
 and a Perl script (`Markdown.pl`) for converting Markdown to
 HTML.  In the next decade, dozens of implementations were
 developed in many languages.  Some extended the original
@@ -34,10 +34,10 @@ As Gruber writes:
 > Markdown-formatted document should be publishable as-is, as
 > plain text, without looking like it's been marked up with tags
 > or formatting instructions.
-> (<https://daringfireball.net/projects/markdown/>)
+> (<http://daringfireball.net/projects/markdown/>)
 
 The point can be illustrated by comparing a sample of
-[AsciiDoc](https://asciidoc.org/) with
+[AsciiDoc](http://www.methods.co.nz/asciidoc/) with
 an equivalent sample of Markdown.  Here is a sample of
 AsciiDoc from the AsciiDoc manual:
 
@@ -103,7 +103,7 @@ source, not just in the processed document.
 ## Why is a spec needed?
 
 John Gruber's [canonical description of Markdown's
-syntax](https://daringfireball.net/projects/markdown/syntax)
+syntax](http://daringfireball.net/projects/markdown/syntax)
 does not specify the syntax unambiguously.  Here are some examples of
 questions it does not answer:
 
@@ -316,9 +316,9 @@ A line containing no characters, or a line containing only spaces
 
 The following definitions of character classes will be used in this spec:
 
-A [Unicode whitespace character](@) is a character in the Unicode `Zs` general
-category, or a tab (`U+0009`), line feed (`U+000A`), form feed (`U+000C`), or
-carriage return (`U+000D`).
+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`).
 
 [Unicode whitespace](@) is a sequence of one or more
 [Unicode whitespace characters].
@@ -337,8 +337,9 @@ is `!`, `"`, `#`, `$`, `%`, `&`, `'`, `(`, `)`,
 `[`, `\`, `]`, `^`, `_`, `` ` `` (U+005B–0060), 
 `{`, `|`, `}`, or `~` (U+007B–007E).
 
-A [Unicode punctuation character](@) is a character in the Unicode `P`
-(puncuation) or `S` (symbol) general categories.
+A [Unicode punctuation character](@) is an [ASCII
+punctuation character] or anything in
+the general Unicode categories  `Pc`, `Pd`, `Pe`, `Pf`, `Pi`, `Po`, or `Ps`.
 
 ## Tabs
 
@@ -578,9 +579,9 @@ raw HTML:
 
 
 ```````````````````````````````` example
-<https://example.com?find=\*>
+<http://example.com?find=\*>
 .
-<p><a href="https://example.com?find=%5C*">https://example.com?find=\*</a></p>
+<p><a href="http://example.com?find=%5C*">http://example.com?find=\*</a></p>
 ````````````````````````````````
 
 
@@ -1963,7 +1964,7 @@ has been found, the code block contains all of the lines after the
 opening code fence until the end of the containing block (or
 document).  (An alternative spec would require backtracking in the
 event that a closing code fence is not found.  But this makes parsing
-much less efficient, and there seems to be no real downside to the
+much less efficient, and there seems to be no real down side to the
 behavior described here.)
 
 A fenced code block may interrupt a paragraph, and does not require
@@ -2402,7 +2403,7 @@ followed by one of the strings (case-insensitive) `address`,
 `h1`, `h2`, `h3`, `h4`, `h5`, `h6`, `head`, `header`, `hr`,
 `html`, `iframe`, `legend`, `li`, `link`, `main`, `menu`, `menuitem`,
 `nav`, `noframes`, `ol`, `optgroup`, `option`, `p`, `param`,
-`search`, `section`, `summary`, `table`, `tbody`, `td`,
+`section`, `source`, `summary`, `table`, `tbody`, `td`,
 `tfoot`, `th`, `thead`, `title`, `tr`, `track`, `ul`, followed
 by a space, a tab, the end of the line, the string `>`, or
 the string `/>`.\
@@ -4114,7 +4115,7 @@ The following rules define [list items]:
     blocks *Bs* starting with a character other than a space or tab, and *M* is
     a list marker of width *W* followed by 1 ≤ *N* ≤ 4 spaces of indentation,
     then the result of prepending *M* and the following spaces to the first line
-    of *Ls*, and indenting subsequent lines of *Ls* by *W + N* spaces, is a
+    of Ls*, and indenting subsequent lines of *Ls* by *W + N* spaces, is a
     list item with *Bs* as its contents.  The type of the list item
     (bullet or ordered) is determined by the type of its list marker.
     If the list item is ordered, then it is also assigned a start
@@ -5349,11 +5350,11 @@ by itself should be a paragraph followed by a nested sublist.
 Since it is well established Markdown practice to allow lists to
 interrupt paragraphs inside list items, the [principle of
 uniformity] requires us to allow this outside list items as
-well.  ([reStructuredText](https://docutils.sourceforge.net/rst.html)
+well.  ([reStructuredText](http://docutils.sourceforge.net/rst.html)
 takes a different approach, requiring blank lines before lists
 even inside other list items.)
 
-In order to solve the problem of unwanted lists in paragraphs with
+In order to solve of unwanted lists in paragraphs with
 hard-wrapped numerals, we allow only lists starting with `1` to
 interrupt paragraphs.  Thus,
 
@@ -6054,18 +6055,18 @@ But this is an HTML tag:
 And this is code:
 
 ```````````````````````````````` example
-`<https://foo.bar.`baz>`
+`<http://foo.bar.`baz>`
 .
-<p><code>&lt;https://foo.bar.</code>baz&gt;`</p>
+<p><code>&lt;http://foo.bar.</code>baz&gt;`</p>
 ````````````````````````````````
 
 
 But this is an autolink:
 
 ```````````````````````````````` example
-<https://foo.bar.`baz>`
+<http://foo.bar.`baz>`
 .
-<p><a href="https://foo.bar.%60baz">https://foo.bar.`baz</a>`</p>
+<p><a href="http://foo.bar.%60baz">http://foo.bar.`baz</a>`</p>
 ````````````````````````````````
 
 
@@ -6098,7 +6099,7 @@ closing backtick strings to be equal in length:
 ## Emphasis and strong emphasis
 
 John Gruber's original [Markdown syntax
-description](https://daringfireball.net/projects/markdown/syntax#em) says:
+description](http://daringfireball.net/projects/markdown/syntax#em) says:
 
 > Markdown treats asterisks (`*`) and underscores (`_`) as indicators of
 > emphasis. Text wrapped with one `*` or `_` will be wrapped with an HTML
@@ -6200,7 +6201,7 @@ Here are some examples of delimiter runs.
 (The idea of distinguishing left-flanking and right-flanking
 delimiter runs based on the character before and the character
 after comes from Roopesh Chander's
-[vfmd](https://web.archive.org/web/20220608143320/http://www.vfmd.org/vfmd-spec/specification/#procedure-for-identifying-emphasis-tags).
+[vfmd](http://www.vfmd.org/vfmd-spec/specification/#procedure-for-identifying-emphasis-tags).
 vfmd uses the terminology "emphasis indicator string" instead of "delimiter
 run," and its rules for distinguishing left- and right-flanking runs
 are a bit more complex than the ones given here.)
@@ -6342,21 +6343,6 @@ Unicode nonbreaking spaces count as whitespace, too:
 ````````````````````````````````
 
 
-Unicode symbols count as punctuation, too:
-
-```````````````````````````````` example
-*$*alpha.
-
-*£*bravo.
-
-*€*charlie.
-.
-<p>*$*alpha.</p>
-<p>*£*bravo.</p>
-<p>*€*charlie.</p>
-````````````````````````````````
-
-
 Intraword emphasis with `*` is permitted:
 
 ```````````````````````````````` example
@@ -7442,16 +7428,16 @@ _a `_`_
 
 
 ```````````````````````````````` example
-**a<https://foo.bar/?q=**>
+**a<http://foo.bar/?q=**>
 .
-<p>**a<a href="https://foo.bar/?q=**">https://foo.bar/?q=**</a></p>
+<p>**a<a href="http://foo.bar/?q=**">http://foo.bar/?q=**</a></p>
 ````````````````````````````````
 
 
 ```````````````````````````````` example
-__a<https://foo.bar/?q=__>
+__a<http://foo.bar/?q=__>
 .
-<p>__a<a href="https://foo.bar/?q=__">https://foo.bar/?q=__</a></p>
+<p>__a<a href="http://foo.bar/?q=__">http://foo.bar/?q=__</a></p>
 ````````````````````````````````
 
 
@@ -7699,13 +7685,13 @@ A link can contain fragment identifiers and queries:
 ```````````````````````````````` example
 [link](#fragment)
 
-[link](https://example.com#fragment)
+[link](http://example.com#fragment)
 
-[link](https://example.com?foo=3#frag)
+[link](http://example.com?foo=3#frag)
 .
 <p><a href="#fragment">link</a></p>
-<p><a href="https://example.com#fragment">link</a></p>
-<p><a href="https://example.com?foo=3#frag">link</a></p>
+<p><a href="http://example.com#fragment">link</a></p>
+<p><a href="http://example.com?foo=3#frag">link</a></p>
 ````````````````````````````````
 
 
@@ -7949,9 +7935,9 @@ and autolinks over link grouping:
 
 
 ```````````````````````````````` example
-[foo<https://example.com/?search=](uri)>
+[foo<http://example.com/?search=](uri)>
 .
-<p>[foo<a href="https://example.com/?search=%5D(uri)">https://example.com/?search=](uri)</a></p>
+<p>[foo<a href="http://example.com/?search=%5D(uri)">http://example.com/?search=](uri)</a></p>
 ````````````````````````````````
 
 
@@ -8105,11 +8091,11 @@ and autolinks over link grouping:
 
 
 ```````````````````````````````` example
-[foo<https://example.com/?search=][ref]>
+[foo<http://example.com/?search=][ref]>
 
 [ref]: /uri
 .
-<p>[foo<a href="https://example.com/?search=%5D%5Bref%5D">https://example.com/?search=][ref]</a></p>
+<p>[foo<a href="http://example.com/?search=%5D%5Bref%5D">http://example.com/?search=][ref]</a></p>
 ````````````````````````````````
 
 
@@ -8309,7 +8295,7 @@ A [collapsed reference link](@)
 consists of a [link label] that [matches] a
 [link reference definition] elsewhere in the
 document, followed by the string `[]`.
-The contents of the link label are parsed as inlines,
+The contents of the first link label are parsed as inlines,
 which are used as the link's text.  The link's URI and title are
 provided by the matching reference link definition.  Thus,
 `[foo][]` is equivalent to `[foo][foo]`.
@@ -8362,7 +8348,7 @@ A [shortcut reference link](@)
 consists of a [link label] that [matches] a
 [link reference definition] elsewhere in the
 document and is not followed by `[]` or a link label.
-The contents of the link label are parsed as inlines,
+The contents of the first link label are parsed as inlines,
 which are used as the link's text.  The link's URI and title
 are provided by the matching link reference definition.
 Thus, `[foo]` is equivalent to `[foo][]`.
@@ -8449,7 +8435,7 @@ following closing bracket:
 ````````````````````````````````
 
 
-Full and collapsed references take precedence over shortcut
+Full and compact references take precedence over shortcut
 references:
 
 ```````````````````````````````` example
@@ -8785,9 +8771,9 @@ Here are some valid autolinks:
 
 
 ```````````````````````````````` example
-<https://foo.bar.baz/test?q=hello&id=22&boolean>
+<http://foo.bar.baz/test?q=hello&id=22&boolean>
 .
-<p><a href="https://foo.bar.baz/test?q=hello&amp;id=22&amp;boolean">https://foo.bar.baz/test?q=hello&amp;id=22&amp;boolean</a></p>
+<p><a href="http://foo.bar.baz/test?q=hello&amp;id=22&amp;boolean">http://foo.bar.baz/test?q=hello&amp;id=22&amp;boolean</a></p>
 ````````````````````````````````
 
 
@@ -8827,9 +8813,9 @@ with their syntax:
 
 
 ```````````````````````````````` example
-<https://../>
+<http://../>
 .
-<p><a href="https://../">https://../</a></p>
+<p><a href="http://../">http://../</a></p>
 ````````````````````````````````
 
 
@@ -8843,18 +8829,18 @@ with their syntax:
 Spaces are not allowed in autolinks:
 
 ```````````````````````````````` example
-<https://foo.bar/baz bim>
+<http://foo.bar/baz bim>
 .
-<p>&lt;https://foo.bar/baz bim&gt;</p>
+<p>&lt;http://foo.bar/baz bim&gt;</p>
 ````````````````````````````````
 
 
 Backslash-escapes do not work inside autolinks:
 
 ```````````````````````````````` example
-<https://example.com/\[\>
+<http://example.com/\[\>
 .
-<p><a href="https://example.com/%5C%5B%5C">https://example.com/\[\</a></p>
+<p><a href="http://example.com/%5C%5B%5C">http://example.com/\[\</a></p>
 ````````````````````````````````
 
 
@@ -8906,9 +8892,9 @@ These are not autolinks:
 
 
 ```````````````````````````````` example
-< https://foo.bar >
+< http://foo.bar >
 .
-<p>&lt; https://foo.bar &gt;</p>
+<p>&lt; http://foo.bar &gt;</p>
 ````````````````````````````````
 
 
@@ -8927,9 +8913,9 @@ These are not autolinks:
 
 
 ```````````````````````````````` example
-https://example.com
+http://example.com
 .
-<p>https://example.com</p>
+<p>http://example.com</p>
 ````````````````````````````````
 
 
@@ -8991,9 +8977,10 @@ A [closing tag](@) consists of the string `</`, a
 [tag name], optional spaces, tabs, and up to one line ending, and the character
 `>`.
 
-An [HTML comment](@) consists of `<!-->`, `<!--->`, or  `<!--`, a string of
-characters not including the string `-->`, and `-->` (see the
-[HTML spec](https://html.spec.whatwg.org/multipage/parsing.html#markup-declaration-open-state)).
+An [HTML comment](@) consists of `<!--` + *text* + `-->`,
+where *text* does not start with `>` or `->`, does not end with `-`,
+and does not contain `--`.  (See the
+[HTML5 spec](http://www.w3.org/TR/html5/syntax.html#comments).)
 
 A [processing instruction](@)
 consists of the string `<?`, a string
@@ -9132,20 +9119,30 @@ Illegal attributes in closing tag:
 Comments:
 
 ```````````````````````````````` example
-foo <!-- this is a --
-comment - with hyphens -->
+foo <!-- this is a
+comment - with hyphen -->
 .
-<p>foo <!-- this is a --
-comment - with hyphens --></p>
+<p>foo <!-- this is a
+comment - with hyphen --></p>
 ````````````````````````````````
 
+
+```````````````````````````````` example
+foo <!-- not a comment -- two hyphens -->
+.
+<p>foo &lt;!-- not a comment -- two hyphens --&gt;</p>
+````````````````````````````````
+
+
+Not comments:
+
 ```````````````````````````````` example
 foo <!--> foo -->
 
-foo <!---> foo -->
+foo <!-- foo--->
 .
-<p>foo <!--> foo --&gt;</p>
-<p>foo <!---> foo --&gt;</p>
+<p>foo &lt;!--&gt; foo --&gt;</p>
+<p>foo &lt;!-- foo---&gt;</p>
 ````````````````````````````````
 
 
@@ -9674,7 +9671,7 @@ through the stack for an opening `[` or `![` delimiter.
   delimiter from the stack, and return a literal text node `]`.
 
 - If we find one and it's active, then we parse ahead to see if
-  we have an inline link/image, reference link/image, collapsed reference
+  we have an inline link/image, reference link/image, compact reference
   link/image, or shortcut reference link/image.
 
   + If we don't, then we remove the opening delimiter from the

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,14 @@ 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");
+            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", context: "Example 1\nSection Extensions / Mermaid diagrams\n");
         }
     }
 

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/EmphasisExtraSpecs.generated.cs

@@ -123,8 +123,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 +132,14 @@ namespace Markdig.Tests.Specs.EmphasisExtra
             // The following Markdown:
             //     This is text MyBrand ^®^ and MyTrademark ^™^
             //     This is text MyBrand^®^ and MyTrademark^™^
-            //     This is text MyBrand ~®~ and MyCopyright ^©^
+            //     This is text MyBrand~®~ and MyCopyright^©^
             //
             // 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");
+            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", context: "Example 6\nSection Extensions / Emphasis on Html Entities\n");
         }
     }
 }

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/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()
         {
@@ -78,7 +74,7 @@ namespace Markdig.Tests.Specs.GridTables
             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");
         }
 
-        // The following is not a valid row separator:
+        // The following is not a valid row separator 
         [Test]
         public void ExtensionsGridTable_Example002()
         {
@@ -97,8 +93,7 @@ namespace Markdig.Tests.Specs.GridTables
         }
 
         // **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()
         {
@@ -192,13 +187,15 @@ namespace Markdig.Tests.Specs.GridTables
             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");
         }
 
-        // 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()
         {
@@ -299,7 +296,7 @@ namespace Markdig.Tests.Specs.GridTables
             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");
         }
 
-        // 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()
         {

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
 +
 .

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,12 @@ 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");
+            TestParser.TestSpec("This is a $math block$", "<p>This is a <span class=\"math\">\\(math block\\)</span></p>", "mathematics|advanced", context: "Example 1\nSection Extensions / Math Inline\n");
         }
 
         // Or by `$$...$$` embracing it by:
@@ -41,12 +41,12 @@ 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");
+            TestParser.TestSpec("This is a $$math block$$", "<p>This is a <span class=\"math\">\\(math block\\)</span></p>", "mathematics|advanced", context: "Example 2\nSection Extensions / Math Inline\n");
         }
 
         // Newlines inside an inline math are not allowed:
@@ -58,13 +58,13 @@ 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");
+            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", context: "Example 3\nSection Extensions / Math Inline\n");
         }
 
         [Test]
@@ -75,13 +75,13 @@ 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");
+            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", context: "Example 4\nSection Extensions / Math Inline\n");
         }
 
         // An opening `$` can be followed by a space if the closing is also preceded by a space `$`:
@@ -92,12 +92,12 @@ 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");
+            TestParser.TestSpec("This is a $ math block $", "<p>This is a <span class=\"math\">\\(math block\\)</span></p>", "mathematics|advanced", context: "Example 5\nSection Extensions / Math Inline\n");
         }
 
         [Test]
@@ -107,12 +107,12 @@ 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");
+            TestParser.TestSpec("This is a $    math block     $ after", "<p>This is a <span class=\"math\">\\(math block\\)</span> after</p>", "mathematics|advanced", context: "Example 6\nSection Extensions / Math Inline\n");
         }
 
         [Test]
@@ -122,12 +122,12 @@ 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");
+            TestParser.TestSpec("This is a $$    math block     $$ after", "<p>This is a <span class=\"math\">\\(math block\\)</span> after</p>", "mathematics|advanced", context: "Example 7\nSection Extensions / Math Inline\n");
         }
 
         [Test]
@@ -137,12 +137,12 @@ 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");
+            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", context: "Example 8\nSection Extensions / Math Inline\n");
         }
 
         // For the opening `$` it requires a space or a punctuation before (but cannot be used within a word):
@@ -153,12 +153,12 @@ 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");
+            TestParser.TestSpec("This is not a m$ath block$", "<p>This is not a m$ath block$</p>", "mathematics|advanced", context: "Example 9\nSection Extensions / Math Inline\n");
         }
 
         // 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 +169,12 @@ 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");
+            TestParser.TestSpec("This is not a $math bloc$k", "<p>This is not a $math bloc$k</p>", "mathematics|advanced", context: "Example 10\nSection Extensions / Math Inline\n");
         }
 
         // 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):
@@ -201,12 +201,12 @@ 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");
+            TestParser.TestSpec("This is a $math \\$ block$", "<p>This is a <span class=\"math\">\\(math \\$ block\\)</span></p>", "mathematics|advanced", context: "Example 12\nSection Extensions / Math Inline\n");
         }
 
         // At most, two `$` will be matched for the opening and closing:
@@ -217,12 +217,12 @@ 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");
+            TestParser.TestSpec("This is a $$$math block$$$", "<p>This is a <span class=\"math\">\\($math block$\\)</span></p>", "mathematics|advanced", context: "Example 13\nSection Extensions / Math Inline\n");
         }
 
         // Regular text can come both before and after the math inline
@@ -233,15 +233,15 @@ 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");
+            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", context: "Example 14\nSection Extensions / Math Inline\n");
         }
 
-        // A mathematic inline block takes precedence over standard emphasis `*` `_`:
+        // A mathematic block takes precedence over standard emphasis `*` `_`:
         [Test]
         public void ExtensionsMathInline_Example015()
         {
@@ -249,15 +249,15 @@ 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");
+            TestParser.TestSpec("This is *a $math* block$", "<p>This is *a <span class=\"math\">\\(math* block\\)</span></p>", "mathematics|advanced", context: "Example 15\nSection Extensions / Math Inline\n");
         }
 
-        // 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()
         {
@@ -279,7 +279,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()

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/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/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,189 @@
+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 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));
         }
     }
-
-    [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,166 +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("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,37 +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 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>", "");
+        }
     }
 }

src/Markdig.Tests/TestExceptionNotThrown.cs

@@ -1,45 +1,48 @@
-namespace Markdig.Tests;
+using NUnit.Framework;
 
-[TestFixture]
-public class TestExceptionNotThrown
+namespace Markdig.Tests
 {
-    [Test]
-    public void DoesNotThrowIndexOutOfRangeException1()
+    [TestFixture]
+    public class TestExceptionNotThrown
     {
-        Assert.DoesNotThrow(() =>
+        [Test]
+        public void DoesNotThrowIndexOutOfRangeException1()
         {
-            var pipeline = new MarkdownPipelineBuilder().UseAdvancedExtensions().Build();
-            Markdown.ToHtml("+-\n|\n+", pipeline);
-        });
-    }
+            Assert.DoesNotThrow(() =>
+            {
+                var pipeline = new MarkdownPipelineBuilder().UseAdvancedExtensions().Build();
+                Markdown.ToHtml("+-\n|\n+", pipeline);
+            });
+        }
 
-    [Test]
-    public void DoesNotThrowIndexOutOfRangeException2()
-    {
-        Assert.DoesNotThrow(() =>
+        [Test]
+        public void DoesNotThrowIndexOutOfRangeException2()
         {
-            var pipeline = new MarkdownPipelineBuilder().UseAdvancedExtensions().Build();
-            Markdown.ToHtml("+--\n|\n+0", pipeline);
-        });
-    }
+            Assert.DoesNotThrow(() =>
+            {
+                var pipeline = new MarkdownPipelineBuilder().UseAdvancedExtensions().Build();
+                Markdown.ToHtml("+--\n|\n+0", pipeline);
+            });
+        }
 
-    [Test]
-    public void DoesNotThrowIndexOutOfRangeException3()
-    {
-        Assert.DoesNotThrow(() =>
+        [Test]
+        public void DoesNotThrowIndexOutOfRangeException3()
         {
-            var pipeline = new MarkdownPipelineBuilder().UseAdvancedExtensions().Build();
-            Markdown.ToHtml("+-\n|\n+\n0", pipeline);
-        });
-    }
+            Assert.DoesNotThrow(() =>
+            {
+                var pipeline = new MarkdownPipelineBuilder().UseAdvancedExtensions().Build();
+                Markdown.ToHtml("+-\n|\n+\n0", pipeline);
+            });
+        }
 
-    [Test]
-    public void DoesNotThrowIndexOutOfRangeException4()
-    {
-        Assert.DoesNotThrow(() =>
+        [Test]
+        public void DoesNotThrowIndexOutOfRangeException4()
         {
-            var pipeline = new MarkdownPipelineBuilder().UseAdvancedExtensions().Build();
-            Markdown.ToHtml("+-\n|\n+0", pipeline);
-        });
+            Assert.DoesNotThrow(() =>
+            {
+                var pipeline = new MarkdownPipelineBuilder().UseAdvancedExtensions().Build();
+                Markdown.ToHtml("+-\n|\n+0", pipeline);
+            });
+        }
     }
 }

src/Markdig.Tests/TestFastStringWriter.cs

@@ -1,186 +1,189 @@
-using System.Text;
-
 using Markdig.Helpers;
+using NUnit.Framework;
+using System;
+using System.Text;
+using System.Threading.Tasks;
 
-namespace Markdig.Tests;
-
-[TestFixture]
-public class TestFastStringWriter
+namespace Markdig.Tests
 {
-    private const string NewLineReplacement = "~~NEW_LINE~~";
-
-    private FastStringWriter _writer = new();
-
-    [SetUp]
-    public void Setup()
+    [TestFixture]
+    public class TestFastStringWriter
     {
-        _writer = new FastStringWriter
+        private const string NewLineReplacement = "~~NEW_LINE~~";
+
+        private FastStringWriter _writer = new();
+
+        [SetUp]
+        public void Setup()
         {
-            NewLine = NewLineReplacement
-        };
-    }
+            _writer = new FastStringWriter
+            {
+                NewLine = NewLineReplacement
+            };
+        }
 
-    public void AssertToString(string value)
-    {
-        value = value.Replace("\n", NewLineReplacement);
-        Assert.AreEqual(value, _writer.ToString());
-        Assert.AreEqual(value, _writer.ToString());
-    }
+        public void AssertToString(string value)
+        {
+            value = value.Replace("\n", NewLineReplacement);
+            Assert.AreEqual(value, _writer.ToString());
+            Assert.AreEqual(value, _writer.ToString());
+        }
 
-    [Test]
-    public async Task NewLine()
-    {
-        Assert.AreEqual("\n", new FastStringWriter().NewLine);
+        [Test]
+        public async Task NewLine()
+        {
+            Assert.AreEqual("\n", new FastStringWriter().NewLine);
 
-        _writer.NewLine = "\r";
-        Assert.AreEqual("\r", _writer.NewLine);
+            _writer.NewLine = "\r";
+            Assert.AreEqual("\r", _writer.NewLine);
 
-        _writer.NewLine = "foo";
-        Assert.AreEqual("foo", _writer.NewLine);
+            _writer.NewLine = "foo";
+            Assert.AreEqual("foo", _writer.NewLine);
 
-        _writer.WriteLine();
-        await _writer.WriteLineAsync();
-        _writer.WriteLine("bar");
-        Assert.AreEqual("foofoobarfoo", _writer.ToString());
-    }
+            _writer.WriteLine();
+            await _writer.WriteLineAsync();
+            _writer.WriteLine("bar");
+            Assert.AreEqual("foofoobarfoo", _writer.ToString());
+        }
 
-    [Test]
-    public async Task FlushCloseDispose()
-    {
-        _writer.Write('a');
-
-        // Nops
-        _writer.Close();
-        _writer.Dispose();
-        await _writer.DisposeAsync();
-        _writer.Flush();
-        await _writer.FlushAsync();
-
-        _writer.Write('b');
-        AssertToString("ab");
-    }
-
-    [Test]
-    public async Task Write_Char()
-    {
-        _writer.Write('a');
-        AssertToString("a");
-
-        _writer.Write('b');
-        AssertToString("ab");
-
-        _writer.Write('\0');
-        _writer.Write('\r');
-        _writer.Write('\u1234');
-        AssertToString("ab\0\r\u1234");
-
-        _writer.Reset();
-        AssertToString("");
-
-        _writer.Write('a');
-        _writer.WriteLine('b');
-        _writer.Write('c');
-        _writer.Write('d');
-        _writer.WriteLine('e');
-        AssertToString("ab\ncde\n");
-
-        await _writer.WriteAsync('f');
-        await _writer.WriteLineAsync('g');
-        AssertToString("ab\ncde\nfg\n");
-
-        _writer.Reset();
-
-        for (int i = 0; i < 2050; i++)
+        [Test]
+        public async Task FlushCloseDispose()
         {
             _writer.Write('a');
-            AssertToString(new string('a', i + 1));
+
+            // Nops
+            _writer.Close();
+            _writer.Dispose();
+            await _writer.DisposeAsync();
+            _writer.Flush();
+            await _writer.FlushAsync();
+
+            _writer.Write('b');
+            AssertToString("ab");
+        }
+
+        [Test]
+        public async Task Write_Char()
+        {
+            _writer.Write('a');
+            AssertToString("a");
+
+            _writer.Write('b');
+            AssertToString("ab");
+
+            _writer.Write('\0');
+            _writer.Write('\r');
+            _writer.Write('\u1234');
+            AssertToString("ab\0\r\u1234");
+
+            _writer.Reset();
+            AssertToString("");
+
+            _writer.Write('a');
+            _writer.WriteLine('b');
+            _writer.Write('c');
+            _writer.Write('d');
+            _writer.WriteLine('e');
+            AssertToString("ab\ncde\n");
+
+            await _writer.WriteAsync('f');
+            await _writer.WriteLineAsync('g');
+            AssertToString("ab\ncde\nfg\n");
+
+            _writer.Reset();
+
+            for (int i = 0; i < 2050; i++)
+            {
+                _writer.Write('a');
+                AssertToString(new string('a', i + 1));
+            }
+        }
+
+        [Test]
+        public async Task Write_String()
+        {
+            _writer.Write("foo");
+            AssertToString("foo");
+
+            _writer.WriteLine("bar");
+            AssertToString("foobar\n");
+
+            await _writer.WriteAsync("baz");
+            await _writer.WriteLineAsync("foo");
+            AssertToString("foobar\nbazfoo\n");
+
+            _writer.Write(new string('a', 1050));
+            AssertToString("foobar\nbazfoo\n" + new string('a', 1050));
+        }
+
+        [Test]
+        public async Task Write_Span()
+        {
+            _writer.Write("foo".AsSpan());
+            AssertToString("foo");
+
+            _writer.WriteLine("bar".AsSpan());
+            AssertToString("foobar\n");
+
+            await _writer.WriteAsync("baz".AsMemory());
+            await _writer.WriteLineAsync("foo".AsMemory());
+            AssertToString("foobar\nbazfoo\n");
+
+            _writer.Write(new string('a', 1050).AsSpan());
+            AssertToString("foobar\nbazfoo\n" + new string('a', 1050));
+        }
+
+        [Test]
+        public async Task Write_CharArray()
+        {
+            _writer.Write("foo".ToCharArray());
+            AssertToString("foo");
+
+            _writer.WriteLine("bar".ToCharArray());
+            AssertToString("foobar\n");
+
+            await _writer.WriteAsync("baz".ToCharArray());
+            await _writer.WriteLineAsync("foo".ToCharArray());
+            AssertToString("foobar\nbazfoo\n");
+
+            _writer.Write(new string('a', 1050).ToCharArray());
+            AssertToString("foobar\nbazfoo\n" + new string('a', 1050));
+        }
+
+        [Test]
+        public async Task Write_CharArrayWithIndexes()
+        {
+            _writer.Write("foo".ToCharArray(), 1, 1);
+            AssertToString("o");
+
+            _writer.WriteLine("bar".ToCharArray(), 0, 2);
+            AssertToString("oba\n");
+
+            await _writer.WriteAsync("baz".ToCharArray(), 0, 1);
+            await _writer.WriteLineAsync("foo".ToCharArray(), 0, 3);
+            AssertToString("oba\nbfoo\n");
+
+            _writer.Write(new string('a', 1050).ToCharArray(), 10, 1035);
+            AssertToString("oba\nbfoo\n" + new string('a', 1035));
+        }
+
+        [Test]
+        public async Task Write_StringBuilder()
+        {
+            _writer.Write(new StringBuilder("foo"));
+            AssertToString("foo");
+
+            _writer.WriteLine(new StringBuilder("bar"));
+            AssertToString("foobar\n");
+
+            await _writer.WriteAsync(new StringBuilder("baz"));
+            await _writer.WriteLineAsync(new StringBuilder("foo"));
+            AssertToString("foobar\nbazfoo\n");
+
+            var sb = new StringBuilder("foo");
+            sb.Append('a', 1050);
+            _writer.Write(sb);
+            AssertToString("foobar\nbazfoo\nfoo" + new string('a', 1050));
         }
     }
-
-    [Test]
-    public async Task Write_String()
-    {
-        _writer.Write("foo");
-        AssertToString("foo");
-
-        _writer.WriteLine("bar");
-        AssertToString("foobar\n");
-
-        await _writer.WriteAsync("baz");
-        await _writer.WriteLineAsync("foo");
-        AssertToString("foobar\nbazfoo\n");
-
-        _writer.Write(new string('a', 1050));
-        AssertToString("foobar\nbazfoo\n" + new string('a', 1050));
-    }
-
-    [Test]
-    public async Task Write_Span()
-    {
-        _writer.Write("foo".AsSpan());
-        AssertToString("foo");
-
-        _writer.WriteLine("bar".AsSpan());
-        AssertToString("foobar\n");
-
-        await _writer.WriteAsync("baz".AsMemory());
-        await _writer.WriteLineAsync("foo".AsMemory());
-        AssertToString("foobar\nbazfoo\n");
-
-        _writer.Write(new string('a', 1050).AsSpan());
-        AssertToString("foobar\nbazfoo\n" + new string('a', 1050));
-    }
-
-    [Test]
-    public async Task Write_CharArray()
-    {
-        _writer.Write("foo".ToCharArray());
-        AssertToString("foo");
-
-        _writer.WriteLine("bar".ToCharArray());
-        AssertToString("foobar\n");
-
-        await _writer.WriteAsync("baz".ToCharArray());
-        await _writer.WriteLineAsync("foo".ToCharArray());
-        AssertToString("foobar\nbazfoo\n");
-
-        _writer.Write(new string('a', 1050).ToCharArray());
-        AssertToString("foobar\nbazfoo\n" + new string('a', 1050));
-    }
-
-    [Test]
-    public async Task Write_CharArrayWithIndexes()
-    {
-        _writer.Write("foo".ToCharArray(), 1, 1);
-        AssertToString("o");
-
-        _writer.WriteLine("bar".ToCharArray(), 0, 2);
-        AssertToString("oba\n");
-
-        await _writer.WriteAsync("baz".ToCharArray(), 0, 1);
-        await _writer.WriteLineAsync("foo".ToCharArray(), 0, 3);
-        AssertToString("oba\nbfoo\n");
-
-        _writer.Write(new string('a', 1050).ToCharArray(), 10, 1035);
-        AssertToString("oba\nbfoo\n" + new string('a', 1035));
-    }
-
-    [Test]
-    public async Task Write_StringBuilder()
-    {
-        _writer.Write(new StringBuilder("foo"));
-        AssertToString("foo");
-
-        _writer.WriteLine(new StringBuilder("bar"));
-        AssertToString("foobar\n");
-
-        await _writer.WriteAsync(new StringBuilder("baz"));
-        await _writer.WriteLineAsync(new StringBuilder("foo"));
-        AssertToString("foobar\nbazfoo\n");
-
-        var sb = new StringBuilder("foo");
-        sb.Append('a', 1050);
-        _writer.Write(sb);
-        AssertToString("foobar\nbazfoo\nfoo" + new string('a', 1050));
-    }
 }

src/Markdig.Tests/TestFencedCodeBlocks.cs

@@ -1,43 +1,46 @@
+using System.Linq;
 using Markdig.Syntax;
+using NUnit.Framework;
 
-namespace Markdig.Tests;
-
-public class TestFencedCodeBlocks
+namespace Markdig.Tests
 {
-    [Test]
-    [TestCase("c#", "c#", "")]
-    [TestCase("C#", "C#", "")]
-    [TestCase(" c#", "c#", "")]
-    [TestCase(" c# ", "c#", "")]
-    [TestCase(" \tc# ", "c#", "")]
-    [TestCase("\t c# \t", "c#", "")]
-    [TestCase(" c# ", "c#", "")]
-    [TestCase(" c# foo", "c#", "foo")]
-    [TestCase(" c# \t  fOo \t", "c#", "fOo")]
-    [TestCase("in\\%fo arg\\%ument", "in%fo", "arg%ument")]
-    [TestCase("info	 arg´ument", "info\t", "arg\u00B4ument")]
-    public void TestInfoAndArguments(string infoString, string expectedInfo, string expectedArguments)
+    public class TestFencedCodeBlocks
     {
-        Test('`');
-        Test('~');
-
-        void Test(char fencedChar)
+        [Test]
+        [TestCase("c#", "c#", "")]
+        [TestCase("C#", "C#", "")]
+        [TestCase(" c#", "c#", "")]
+        [TestCase(" c# ", "c#", "")]
+        [TestCase(" \tc# ", "c#", "")]
+        [TestCase("\t c# \t", "c#", "")]
+        [TestCase(" c# ", "c#", "")]
+        [TestCase(" c# foo", "c#", "foo")]
+        [TestCase(" c# \t  fOo \t", "c#", "fOo")]
+        [TestCase("in\\%fo arg\\%ument", "in%fo", "arg%ument")]
+        [TestCase("info	 arg´ument", "info\t", "arg\u00B4ument")]
+        public void TestInfoAndArguments(string infoString, string expectedInfo, string expectedArguments)
         {
-            const string Contents = "Foo\nBar\n";
+            Test('`');
+            Test('~');
 
-            var fence = new string(fencedChar, 3);
-            string markdownText = $"{fence}{infoString}\n{Contents}\n{fence}\n";
+            void Test(char fencedChar)
+            {
+                const string Contents = "Foo\nBar\n";
 
-            MarkdownDocument document = Markdown.Parse(markdownText);
+                string fence = new string(fencedChar, 3);
+                string markdownText = $"{fence}{infoString}\n{Contents}\n{fence}\n";
 
-            FencedCodeBlock codeBlock = document.Descendants<FencedCodeBlock>().Single();
+                MarkdownDocument document = Markdown.Parse(markdownText);
 
-            Assert.AreEqual(fencedChar, codeBlock.FencedChar);
-            Assert.AreEqual(3, codeBlock.OpeningFencedCharCount);
-            Assert.AreEqual(3, codeBlock.ClosingFencedCharCount);
-            Assert.AreEqual(expectedInfo, codeBlock.Info);
-            Assert.AreEqual(expectedArguments, codeBlock.Arguments);
-            Assert.AreEqual(Contents, codeBlock.Lines.ToString());
+                FencedCodeBlock codeBlock = document.Descendants<FencedCodeBlock>().Single();
+
+                Assert.AreEqual(fencedChar, codeBlock.FencedChar);
+                Assert.AreEqual(3, codeBlock.OpeningFencedCharCount);
+                Assert.AreEqual(3, codeBlock.ClosingFencedCharCount);
+                Assert.AreEqual(expectedInfo, codeBlock.Info);
+                Assert.AreEqual(expectedArguments, codeBlock.Arguments);
+                Assert.AreEqual(Contents, codeBlock.Lines.ToString());
+            }
         }
     }
 }

src/Markdig.Tests/TestHtmlAttributes.cs

@@ -3,91 +3,94 @@
 // See the license.txt file in the project root for more information.
 
 using Markdig.Renderers.Html;
+using NUnit.Framework;
+using System.Collections.Generic;
 
-namespace Markdig.Tests;
-
-[TestFixture()]
-public class TestHtmlAttributes
+namespace Markdig.Tests
 {
-    [Test]
-    public void TestAddClass()
+    [TestFixture()]
+    public class TestHtmlAttributes
     {
-        var attributes = new HtmlAttributes();
-        attributes.AddClass("test");
-        Assert.NotNull(attributes.Classes);
-        Assert.AreEqual(new List<string>() { "test" }, attributes.Classes);
+        [Test]
+        public void TestAddClass()
+        {
+            var attributes = new HtmlAttributes();
+            attributes.AddClass("test");
+            Assert.NotNull(attributes.Classes);
+            Assert.AreEqual(new List<string>() { "test" }, attributes.Classes);
 
-        attributes.AddClass("test");
-        Assert.AreEqual(1, attributes.Classes.Count);
+            attributes.AddClass("test");
+            Assert.AreEqual(1, attributes.Classes.Count);
 
-        attributes.AddClass("test1");
-        Assert.AreEqual(new List<string>() { "test", "test1" }, attributes.Classes);
-    }
+            attributes.AddClass("test1");
+            Assert.AreEqual(new List<string>() { "test", "test1" }, attributes.Classes);
+        }
 
-    [Test]
-    public void TestAddProperty()
-    {
-        var attributes = new HtmlAttributes();
-        attributes.AddProperty("key1", "1");
-        Assert.NotNull(attributes.Properties);
-        Assert.AreEqual(new List<KeyValuePair<string, string>>() { new KeyValuePair<string, string>("key1", "1") }, attributes.Properties);
+        [Test]
+        public void TestAddProperty()
+        {
+            var attributes = new HtmlAttributes();
+            attributes.AddProperty("key1", "1");
+            Assert.NotNull(attributes.Properties);
+            Assert.AreEqual(new List<KeyValuePair<string, string>>() { new KeyValuePair<string, string>("key1", "1") }, attributes.Properties);
 
-        attributes.AddPropertyIfNotExist("key1", "1");
-        Assert.NotNull(attributes.Properties);
-        Assert.AreEqual(new List<KeyValuePair<string, string>>() { new KeyValuePair<string, string>("key1", "1") }, attributes.Properties);
+            attributes.AddPropertyIfNotExist("key1", "1");
+            Assert.NotNull(attributes.Properties);
+            Assert.AreEqual(new List<KeyValuePair<string, string>>() { new KeyValuePair<string, string>("key1", "1") }, attributes.Properties);
 
-        attributes.AddPropertyIfNotExist("key2", "2");
-        Assert.AreEqual(new List<KeyValuePair<string, string>>() { new KeyValuePair<string, string>("key1", "1"), new KeyValuePair<string, string>("key2", "2") }, attributes.Properties);
-    }
+            attributes.AddPropertyIfNotExist("key2", "2");
+            Assert.AreEqual(new List<KeyValuePair<string, string>>() { new KeyValuePair<string, string>("key1", "1"), new KeyValuePair<string, string>("key2", "2") }, attributes.Properties);
+        }
 
-    [Test]
-    public void TestCopyTo()
-    {
-        var from = new HtmlAttributes();
-        from.AddClass("test");
-        from.AddProperty("key1", "1");
+        [Test]
+        public void TestCopyTo()
+        {
+            var from = new HtmlAttributes();
+            from.AddClass("test");
+            from.AddProperty("key1", "1");
 
-        var to = new HtmlAttributes();
-        from.CopyTo(to);
+            var to = new HtmlAttributes();
+            from.CopyTo(to);
 
-        Assert.True(ReferenceEquals(from.Classes, to.Classes));
-        Assert.True(ReferenceEquals(from.Properties, to.Properties));
+            Assert.True(ReferenceEquals(from.Classes, to.Classes));
+            Assert.True(ReferenceEquals(from.Properties, to.Properties));
 
-        //          From: Classes      From: Properties     To: Classes     To: Properties
-        // test1:        null                null              null             null
-        from = new HtmlAttributes();
-        to = new HtmlAttributes();
-        from.CopyTo(to, false, false);
-        Assert.Null(to.Classes);
-        Assert.Null(to.Properties);
+            //          From: Classes      From: Properties     To: Classes     To: Properties
+            // test1:        null                null              null             null
+            from = new HtmlAttributes();
+            to = new HtmlAttributes();
+            from.CopyTo(to, false, false);
+            Assert.Null(to.Classes);
+            Assert.Null(to.Properties);
 
-        // test2:      ["test"]            ["key1", "1"]       null             null
-        from = new HtmlAttributes();
-        to = new HtmlAttributes();
-        from.AddClass("test");
-        from.AddProperty("key1", "1");
-        from.CopyTo(to, false, false);
-        Assert.AreEqual(new List<string>() { "test" }, to.Classes);
-        Assert.AreEqual(new List<KeyValuePair<string, string>>() { new KeyValuePair<string, string>("key1", "1")}, to.Properties);
+            // test2:      ["test"]            ["key1", "1"]       null             null
+            from = new HtmlAttributes();
+            to = new HtmlAttributes();
+            from.AddClass("test");
+            from.AddProperty("key1", "1");
+            from.CopyTo(to, false, false);
+            Assert.AreEqual(new List<string>() { "test" }, to.Classes);
+            Assert.AreEqual(new List<KeyValuePair<string, string>>() { new KeyValuePair<string, string>("key1", "1")}, to.Properties);
 
-        // test3:        null                null            ["test"]       ["key1", "1"]       
-        from = new HtmlAttributes();
-        to = new HtmlAttributes();
-        to.AddClass("test");
-        to.AddProperty("key1", "1");
-        from.CopyTo(to, false, false);
-        Assert.AreEqual(new List<string>() { "test" }, to.Classes);
-        Assert.AreEqual(new List<KeyValuePair<string, string>>() { new KeyValuePair<string, string>("key1", "1") }, to.Properties);
+            // test3:        null                null            ["test"]       ["key1", "1"]       
+            from = new HtmlAttributes();
+            to = new HtmlAttributes();
+            to.AddClass("test");
+            to.AddProperty("key1", "1");
+            from.CopyTo(to, false, false);
+            Assert.AreEqual(new List<string>() { "test" }, to.Classes);
+            Assert.AreEqual(new List<KeyValuePair<string, string>>() { new KeyValuePair<string, string>("key1", "1") }, to.Properties);
 
-        // test4:      ["test1"]           ["key2", "2"]     ["test"]       ["key1", "1"]       
-        from = new HtmlAttributes();
-        to = new HtmlAttributes();
-        from.AddClass("test1");
-        from.AddProperty("key2", "2");
-        to.AddClass("test");
-        to.AddProperty("key1", "1");
-        from.CopyTo(to, false, false);
-        Assert.AreEqual(new List<string>() { "test", "test1" }, to.Classes);
-        Assert.AreEqual(new List<KeyValuePair<string, string>>() { new KeyValuePair<string, string>("key1", "1"), new KeyValuePair<string, string>("key2", "2") }, to.Properties);
+            // test4:      ["test1"]           ["key2", "2"]     ["test"]       ["key1", "1"]       
+            from = new HtmlAttributes();
+            to = new HtmlAttributes();
+            from.AddClass("test1");
+            from.AddProperty("key2", "2");
+            to.AddClass("test");
+            to.AddProperty("key1", "1");
+            from.CopyTo(to, false, false);
+            Assert.AreEqual(new List<string>() { "test", "test1" }, to.Classes);
+            Assert.AreEqual(new List<KeyValuePair<string, string>>() { new KeyValuePair<string, string>("key1", "1"), new KeyValuePair<string, string>("key2", "2") }, to.Properties);
+        }
     }
 }

src/Markdig.Tests/TestHtmlCodeBlocks.cs

@@ -1,35 +0,0 @@
-using Markdig.Syntax;
-
-namespace Markdig.Tests;
-
-public class TestHtmlCodeBlocks
-{
-    // Start condition: line begins with the string < or </ followed by one of the strings (case-insensitive)
-    // {list of all tags}, followed by a space, a tab, the end of the line, the string >, or the string />.
-    public static string[] KnownSimpleHtmlTags =>
-    [
-        "address", "article", "aside", "base", "basefont", "blockquote", "body", "caption", "center", "col", "colgroup", "dd", "details",
-        "dialog", "dir", "div", "dl", "dt", "fieldset", "figcaption", "figure", "footer", "form", "frame", "frameset",
-        "h1", "h2", "h3", "h4", "h5", "h6", "head", "header", "hr", "html", "iframe", "legend", "li", "link",
-        "main", "menu", "menuitem", "nav", "noframes", "ol", "optgroup", "option", "p", "param",
-        "search", "section", "summary", "table", "tbody", "td", "tfoot", "th", "thead", "title", "tr", "track", "ul",
-    ];
-
-    [Theory]
-    [TestCaseSource(nameof(KnownSimpleHtmlTags))]
-    public void TestKnownTags(string tag)
-    {
-        MarkdownDocument document = Markdown.Parse(
-            $"""
-            Hello
-             <{tag} />
-            World
-            """.ReplaceLineEndings("\n"));
-
-        HtmlBlock[] htmlBlocks = document.Descendants<HtmlBlock>().ToArray();
-
-        Assert.AreEqual(1, htmlBlocks.Length);
-        Assert.AreEqual(7, htmlBlocks[0].Span.Start);
-        Assert.AreEqual(10 + tag.Length, htmlBlocks[0].Span.Length);
-    }
-}

src/Markdig.Tests/TestHtmlHelper.cs

@@ -1,28 +1,30 @@
 // 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 NUnit.Framework;
 using Markdig.Helpers;
 
-namespace Markdig.Tests;
-
-[TestFixture]
-public class TestHtmlHelper
+namespace Markdig.Tests
 {
-    [Test]
-    public void TestParseHtmlTagSimple()
+    [TestFixture]
+    public class TestHtmlHelper
     {
-        var inputTag = "<a>";
-        var text = new StringSlice(inputTag);
-        Assert.True(HtmlHelper.TryParseHtmlTag(ref text, out string outputTag));
-        Assert.AreEqual(inputTag, outputTag);
-    }
+        [Test]
+        public void TestParseHtmlTagSimple()
+        {
+            var inputTag = "<a>";
+            var text = new StringSlice(inputTag);
+            Assert.True(HtmlHelper.TryParseHtmlTag(ref text, out string outputTag));
+            Assert.AreEqual(inputTag, outputTag);
+        }
 
-    [Test]
-    public void TestParseHtmlTagSimpleWithAttribute()
-    {
-        var inputTag = "<a href='http://google.com'>";
-        var text = new StringSlice(inputTag);
-        Assert.True(HtmlHelper.TryParseHtmlTag(ref text, out string outputTag));
-        Assert.AreEqual(inputTag, outputTag);
+        [Test]
+        public void TestParseHtmlTagSimpleWithAttribute()
+        {
+            var inputTag = "<a href='http://google.com'>";
+            var text = new StringSlice(inputTag);
+            Assert.True(HtmlHelper.TryParseHtmlTag(ref text, out string outputTag));
+            Assert.AreEqual(inputTag, outputTag);
+        }
     }
 }

src/Markdig.Tests/TestImageAltText.cs

@@ -1,23 +1,25 @@
+using NUnit.Framework;
 using System.Text.RegularExpressions;
 
-namespace Markdig.Tests;
-
-[TestFixture]
-public class TestImageAltText
+namespace Markdig.Tests
 {
-    [Test]
-    [TestCase("![](image.jpg)", "")]
-    [TestCase("![foo](image.jpg)", "foo")]
-    [TestCase("![][1]\n\n[1]: image.jpg", "")]
-    [TestCase("![bar][1]\n\n[1]: image.jpg", "bar")]
-    [TestCase("![](image.jpg 'title')", "")]
-    [TestCase("![foo](image.jpg 'title')", "foo")]
-    [TestCase("![][1]\n\n[1]: image.jpg 'title'", "")]
-    [TestCase("![bar][1]\n\n[1]: image.jpg 'title'", "bar")]
-    public void TestImageHtmlAltText(string markdown, string expectedAltText)
+    [TestFixture]
+    public class TestImageAltText
     {
-        string html = Markdown.ToHtml(markdown);
-        string actualAltText = Regex.Match(html, "alt=\"(.*?)\"").Groups[1].Value;
-        Assert.AreEqual(expectedAltText, actualAltText);
+        [Test]
+        [TestCase("![](image.jpg)", "")]
+        [TestCase("![foo](image.jpg)", "foo")]
+        [TestCase("![][1]\n\n[1]: image.jpg", "")]
+        [TestCase("![bar][1]\n\n[1]: image.jpg", "bar")]
+        [TestCase("![](image.jpg 'title')", "")]
+        [TestCase("![foo](image.jpg 'title')", "foo")]
+        [TestCase("![][1]\n\n[1]: image.jpg 'title'", "")]
+        [TestCase("![bar][1]\n\n[1]: image.jpg 'title'", "bar")]
+        public void TestImageHtmlAltText(string markdown, string expectedAltText)
+        {
+            string html = Markdown.ToHtml(markdown);
+            string actualAltText = Regex.Match(html, "alt=\"(.*?)\"").Groups[1].Value;
+            Assert.AreEqual(expectedAltText, actualAltText);
+        }
     }
 }

src/Markdig.Tests/TestLazySubstring.cs

@@ -1,65 +1,67 @@
 using Markdig.Helpers;
+using NUnit.Framework;
 
-namespace Markdig.Tests;
-
-public class TestLazySubstring
+namespace Markdig.Tests
 {
-    [Theory]
-    [TestCase("")]
-    [TestCase("a")]
-    [TestCase("foo")]
-    public void LazySubstring_ReturnsCorrectSubstring(string text)
+    public class TestLazySubstring
     {
-        var substring = new LazySubstring(text);
-        Assert.AreEqual(0, substring.Offset);
-        Assert.AreEqual(text.Length, substring.Length);
+        [Theory]
+        [TestCase("")]
+        [TestCase("a")]
+        [TestCase("foo")]
+        public void LazySubstring_ReturnsCorrectSubstring(string text)
+        {
+            var substring = new LazySubstring(text);
+            Assert.AreEqual(0, substring.Offset);
+            Assert.AreEqual(text.Length, substring.Length);
 
-        Assert.AreEqual(text, substring.AsSpan().ToString());
-        Assert.AreEqual(text, substring.AsSpan().ToString());
-        Assert.AreEqual(0, substring.Offset);
-        Assert.AreEqual(text.Length, substring.Length);
+            Assert.AreEqual(text, substring.AsSpan().ToString());
+            Assert.AreEqual(text, substring.AsSpan().ToString());
+            Assert.AreEqual(0, substring.Offset);
+            Assert.AreEqual(text.Length, substring.Length);
 
-        Assert.AreSame(substring.ToString(), substring.ToString());
-        Assert.AreEqual(text, substring.ToString());
-        Assert.AreEqual(0, substring.Offset);
-        Assert.AreEqual(text.Length, substring.Length);
+            Assert.AreSame(substring.ToString(), substring.ToString());
+            Assert.AreEqual(text, substring.ToString());
+            Assert.AreEqual(0, substring.Offset);
+            Assert.AreEqual(text.Length, substring.Length);
 
-        Assert.AreEqual(text, substring.AsSpan().ToString());
-        Assert.AreEqual(text, substring.AsSpan().ToString());
-        Assert.AreEqual(0, substring.Offset);
-        Assert.AreEqual(text.Length, substring.Length);
-    }
+            Assert.AreEqual(text, substring.AsSpan().ToString());
+            Assert.AreEqual(text, substring.AsSpan().ToString());
+            Assert.AreEqual(0, substring.Offset);
+            Assert.AreEqual(text.Length, substring.Length);
+        }
 
-    [Theory]
-    [TestCase("", 0, 0)]
-    [TestCase("a", 0, 0)]
-    [TestCase("a", 1, 0)]
-    [TestCase("a", 0, 1)]
-    [TestCase("foo", 1, 0)]
-    [TestCase("foo", 1, 1)]
-    [TestCase("foo", 1, 2)]
-    [TestCase("foo", 0, 3)]
-    public void LazySubstring_ReturnsCorrectSubstring(string text, int start, int length)
-    {
-        var substring = new LazySubstring(text, start, length);
-        Assert.AreEqual(start, substring.Offset);
-        Assert.AreEqual(length, substring.Length);
+        [Theory]
+        [TestCase("", 0, 0)]
+        [TestCase("a", 0, 0)]
+        [TestCase("a", 1, 0)]
+        [TestCase("a", 0, 1)]
+        [TestCase("foo", 1, 0)]
+        [TestCase("foo", 1, 1)]
+        [TestCase("foo", 1, 2)]
+        [TestCase("foo", 0, 3)]
+        public void LazySubstring_ReturnsCorrectSubstring(string text, int start, int length)
+        {
+            var substring = new LazySubstring(text, start, length);
+            Assert.AreEqual(start, substring.Offset);
+            Assert.AreEqual(length, substring.Length);
 
-        string expectedSubstring = text.Substring(start, length);
+            string expectedSubstring = text.Substring(start, length);
 
-        Assert.AreEqual(expectedSubstring, substring.AsSpan().ToString());
-        Assert.AreEqual(expectedSubstring, substring.AsSpan().ToString());
-        Assert.AreEqual(start, substring.Offset);
-        Assert.AreEqual(length, substring.Length);
+            Assert.AreEqual(expectedSubstring, substring.AsSpan().ToString());
+            Assert.AreEqual(expectedSubstring, substring.AsSpan().ToString());
+            Assert.AreEqual(start, substring.Offset);
+            Assert.AreEqual(length, substring.Length);
 
-        Assert.AreSame(substring.ToString(), substring.ToString());
-        Assert.AreEqual(expectedSubstring, substring.ToString());
-        Assert.AreEqual(0, substring.Offset);
-        Assert.AreEqual(length, substring.Length);
+            Assert.AreSame(substring.ToString(), substring.ToString());
+            Assert.AreEqual(expectedSubstring, substring.ToString());
+            Assert.AreEqual(0, substring.Offset);
+            Assert.AreEqual(length, substring.Length);
 
-        Assert.AreEqual(expectedSubstring, substring.AsSpan().ToString());
-        Assert.AreEqual(expectedSubstring, substring.AsSpan().ToString());
-        Assert.AreEqual(0, substring.Offset);
-        Assert.AreEqual(length, substring.Length);
+            Assert.AreEqual(expectedSubstring, substring.AsSpan().ToString());
+            Assert.AreEqual(expectedSubstring, substring.AsSpan().ToString());
+            Assert.AreEqual(0, substring.Offset);
+            Assert.AreEqual(length, substring.Length);
+        }
     }
 }

src/Markdig.Tests/TestLineReader.cs

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

src/Markdig.Tests/TestLinkHelper.cs

@@ -2,395 +2,374 @@
 // 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.Helpers;
 using Markdig.Syntax;
 
-namespace Markdig.Tests;
-
-[TestFixture]
-public class TestLinkHelper
+namespace Markdig.Tests
 {
-    [Test]
-    public void TestUrlSimple()
+    [TestFixture]
+    public class TestLinkHelper
     {
-        var text = new StringSlice("toto tutu");
-        Assert.True(LinkHelper.TryParseUrl(ref text, out string link, out _));
-        Assert.AreEqual("toto", link);
-        Assert.AreEqual(' ', text.CurrentChar);
-    }
+        [Test]
+        public void TestUrlSimple()
+        {
+            var text = new StringSlice("toto tutu");
+            Assert.True(LinkHelper.TryParseUrl(ref text, out string link, out _));
+            Assert.AreEqual("toto", link);
+            Assert.AreEqual(' ', text.CurrentChar);
+        }
 
-    [Test]
-    public void TestUrlUrl()
-    {
-        var text = new StringSlice("http://google.com)");
-        Assert.True(LinkHelper.TryParseUrl(ref text, out string link, out _));
-        Assert.AreEqual("http://google.com", link);
-        Assert.AreEqual(')', text.CurrentChar);
-    }
+        [Test]
+        public void TestUrlUrl()
+        {
+            var text = new StringSlice("http://google.com)");
+            Assert.True(LinkHelper.TryParseUrl(ref text, out string link, out _));
+            Assert.AreEqual("http://google.com", link);
+            Assert.AreEqual(')', text.CurrentChar);
+        }
 
-    [Test]
-    [TestCase("http://google.com.")]
-    [TestCase("http://google.com. ")]
-    public void TestUrlTrailingFullStop(string uri)
-    {
-        var text = new StringSlice(uri);
-        Assert.True(LinkHelper.TryParseUrl(ref text, out string link, out _, true));
-        Assert.AreEqual("http://google.com", link);
-        Assert.AreEqual('.', text.CurrentChar);
-    }
+        [Test]
+        [TestCase("http://google.com.")]
+        [TestCase("http://google.com. ")]
+        public void TestUrlTrailingFullStop(string uri)
+        {
+            var text = new StringSlice(uri);
+            Assert.True(LinkHelper.TryParseUrl(ref text, out string link, out _, true));
+            Assert.AreEqual("http://google.com", link);
+            Assert.AreEqual('.', text.CurrentChar);
+        }
 
-    [Test]
-    public void TestUrlNestedParenthesis()
-    {
-        var text = new StringSlice("(toto)tutu(tata) nooo");
-        Assert.True(LinkHelper.TryParseUrl(ref text, out string link, out _));
-        Assert.AreEqual("(toto)tutu(tata)", link);
-        Assert.AreEqual(' ', text.CurrentChar);
-    }
+        [Test]
+        public void TestUrlNestedParenthesis()
+        {
+            var text = new StringSlice("(toto)tutu(tata) nooo");
+            Assert.True(LinkHelper.TryParseUrl(ref text, out string link, out _));
+            Assert.AreEqual("(toto)tutu(tata)", link);
+            Assert.AreEqual(' ', text.CurrentChar);
+        }
 
-    [Test]
-    public void TestUrlAlternate()
-    {
-        var text = new StringSlice("<toto_tata_tutu> nooo");
-        Assert.True(LinkHelper.TryParseUrl(ref text, out string link, out _));
-        Assert.AreEqual("toto_tata_tutu", link);
-        Assert.AreEqual(' ', text.CurrentChar);
-    }
+        [Test]
+        public void TestUrlAlternate()
+        {
+            var text = new StringSlice("<toto_tata_tutu> nooo");
+            Assert.True(LinkHelper.TryParseUrl(ref text, out string link, out _));
+            Assert.AreEqual("toto_tata_tutu", link);
+            Assert.AreEqual(' ', text.CurrentChar);
+        }
 
-    [Test]
-    public void TestUrlAlternateInvalid()
-    {
-        var text = new StringSlice("<toto_tata_tutu");
-        Assert.False(LinkHelper.TryParseUrl(ref text, out string link, out _));
-    }
+        [Test]
+        public void TestUrlAlternateInvalid()
+        {
+            var text = new StringSlice("<toto_tata_tutu");
+            Assert.False(LinkHelper.TryParseUrl(ref text, out string link, out _));
+        }
 
-    [Test]
-    public void TestTitleSimple()
-    {
-        var text = new StringSlice(@"'tata\tutu\''");
-        Assert.True(LinkHelper.TryParseTitle(ref text, out string title, out _));
-        Assert.AreEqual(@"tata\tutu'", title);
-    }
+        [Test]
+        public void TestTitleSimple()
+        {
+            var text = new StringSlice(@"'tata\tutu\''");
+            Assert.True(LinkHelper.TryParseTitle(ref text, out string title, out _));
+            Assert.AreEqual(@"tata\tutu'", title);
+        }
 
-    [Test]
-    public void TestTitleSimpleAlternate()
-    {
-        var text = new StringSlice(@"""tata\tutu\"""" ");
-        Assert.True(LinkHelper.TryParseTitle(ref text, out string title, out _));
-        Assert.AreEqual(@"tata\tutu""", title);
-        Assert.AreEqual(' ', text.CurrentChar);
-    }
+        [Test]
+        public void TestTitleSimpleAlternate()
+        {
+            var text = new StringSlice(@"""tata\tutu\"""" ");
+            Assert.True(LinkHelper.TryParseTitle(ref text, out string title, out _));
+            Assert.AreEqual(@"tata\tutu""", title);
+            Assert.AreEqual(' ', text.CurrentChar);
+        }
 
-    [Test]
-    public void TestTitleMultiline()
-    {
-        var text = new StringSlice("'this\ris\r\na\ntitle'");
-        Assert.True(LinkHelper.TryParseTitle(ref text, out string title, out _));
-        Assert.AreEqual("this\ris\r\na\ntitle", title);
-    }
+        [Test]
+        public void TestUrlAndTitle()
+        {
+            //                           0         1         2         3
+            //                           0123456789012345678901234567890123456789
+            var text = new StringSlice(@"(http://google.com 'this is a title')ABC");
+            Assert.True(LinkHelper.TryParseInlineLink(ref text, out string link, out string title, out SourceSpan linkSpan, out SourceSpan titleSpan));
+            Assert.AreEqual("http://google.com", link);
+            Assert.AreEqual("this is a title", title);
+            Assert.AreEqual(new SourceSpan(1, 17), linkSpan);
+            Assert.AreEqual(new SourceSpan(19, 35), titleSpan);
+            Assert.AreEqual('A', text.CurrentChar);
+        }
 
-    [Test]
-    public void TestTitleMultilineWithSpaceAndBackslash()
-    {
-        var text = new StringSlice("'a\n\\ \\\ntitle'");
-        Assert.True(LinkHelper.TryParseTitle(ref text, out string title, out _));
-        Assert.AreEqual("a\n\\ \\\ntitle", title);
-    }
+        [Test]
+        public void TestUrlAndTitleEmpty()
+        {
+            //                           01234
+            var text = new StringSlice(@"(<>)A");
+            Assert.True(LinkHelper.TryParseInlineLink(ref text, out string link, out string title, out SourceSpan linkSpan, out SourceSpan titleSpan));
+            Assert.AreEqual(string.Empty, link);
+            Assert.AreEqual(string.Empty, title);
+            Assert.AreEqual(new SourceSpan(1, 2), linkSpan);
+            Assert.AreEqual(SourceSpan.Empty, titleSpan);
+            Assert.AreEqual('A', text.CurrentChar);
+        }
 
-    [Test]
-    public void TestUrlAndTitle()
-    {
-        //                           0         1         2         3
-        //                           0123456789012345678901234567890123456789
-        var text = new StringSlice(@"(http://google.com 'this is a title')ABC");
-        Assert.True(LinkHelper.TryParseInlineLink(ref text, out string link, out string title, out SourceSpan linkSpan, out SourceSpan titleSpan));
-        Assert.AreEqual("http://google.com", link);
-        Assert.AreEqual("this is a title", title);
-        Assert.AreEqual(new SourceSpan(1, 17), linkSpan);
-        Assert.AreEqual(new SourceSpan(19, 35), titleSpan);
-        Assert.AreEqual('A', text.CurrentChar);
-    }
-
-    [Test]
-    public void TestUrlEmptyAndTitleNull()
-    {
-        //                           01234
-        var text = new StringSlice(@"(<>)A");
-        Assert.True(LinkHelper.TryParseInlineLink(ref text, out string link, out string title, out SourceSpan linkSpan, out SourceSpan titleSpan));
-        Assert.AreEqual(string.Empty, link);
-        Assert.AreEqual(null, title);
-        Assert.AreEqual(new SourceSpan(1, 2), linkSpan);
-        Assert.AreEqual(SourceSpan.Empty, titleSpan);
-        Assert.AreEqual('A', text.CurrentChar);
-    }
-
-    [Test]
-    public void TestUrlEmptyAndTitleNull2()
-    {
-        //                           012345
-        var text = new StringSlice(@"( <> )A");
-        Assert.True(LinkHelper.TryParseInlineLink(ref text, out string link, out string title, out SourceSpan linkSpan, out SourceSpan titleSpan));
-        Assert.AreEqual(string.Empty, link);
-        Assert.AreEqual(null, title);
-        Assert.AreEqual(new SourceSpan(2, 3), linkSpan);
-        Assert.AreEqual(SourceSpan.Empty, titleSpan);
-        Assert.AreEqual('A', text.CurrentChar);
-    }
+        [Test]
+        public void TestUrlAndTitleEmpty2()
+        {
+            //                           012345
+            var text = new StringSlice(@"( <> )A");
+            Assert.True(LinkHelper.TryParseInlineLink(ref text, out string link, out string title, out SourceSpan linkSpan, out SourceSpan titleSpan));
+            Assert.AreEqual(string.Empty, link);
+            Assert.AreEqual(string.Empty, title);
+            Assert.AreEqual(new SourceSpan(2, 3), linkSpan);
+            Assert.AreEqual(SourceSpan.Empty, titleSpan);
+            Assert.AreEqual('A', text.CurrentChar);
+        }
 
 
-    [Test]
-    public void TestUrlEmptyWithTitleWithMultipleSpaces()
-    {
-        //                           0         1         2
-        //                           0123456789012345678901234567
-        var text = new StringSlice(@"(   <>      'toto'       )A");
-        Assert.True(LinkHelper.TryParseInlineLink(ref text, out string link, out string title, out SourceSpan linkSpan, out SourceSpan titleSpan));
-        Assert.AreEqual(string.Empty, link);
-        Assert.AreEqual("toto", title);
-        Assert.AreEqual(new SourceSpan(4, 5), linkSpan);
-        Assert.AreEqual(new SourceSpan(12, 17), titleSpan);
-        Assert.AreEqual('A', text.CurrentChar);
-    }
+        [Test]
+        public void TestUrlEmptyWithTitleWithMultipleSpaces()
+        {
+            //                           0         1         2
+            //                           0123456789012345678901234567
+            var text = new StringSlice(@"(   <>      'toto'       )A");
+            Assert.True(LinkHelper.TryParseInlineLink(ref text, out string link, out string title, out SourceSpan linkSpan, out SourceSpan titleSpan));
+            Assert.AreEqual(string.Empty, link);
+            Assert.AreEqual("toto", title);
+            Assert.AreEqual(new SourceSpan(4, 5), linkSpan);
+            Assert.AreEqual(new SourceSpan(12, 17), titleSpan);
+            Assert.AreEqual('A', text.CurrentChar);
+        }
 
-    [Test]
-    public void TestUrlEmpty()
-    {
-        var text = new StringSlice(@"()A");
-        Assert.True(LinkHelper.TryParseInlineLink(ref text, out string link, out string title, out SourceSpan linkSpan, out SourceSpan titleSpan));
-        Assert.AreEqual(string.Empty, link);
-        Assert.AreEqual(null, title);
-        Assert.AreEqual(SourceSpan.Empty, linkSpan);
-        Assert.AreEqual(SourceSpan.Empty, titleSpan);
-        Assert.AreEqual('A', text.CurrentChar);
-    }
+        [Test]
+        public void TestUrlEmpty()
+        {
+            var text = new StringSlice(@"()A");
+            Assert.True(LinkHelper.TryParseInlineLink(ref text, out string link, out string title, out SourceSpan linkSpan, out SourceSpan titleSpan));
+            Assert.AreEqual(string.Empty, link);
+            Assert.AreEqual(string.Empty, title);
+            Assert.AreEqual(SourceSpan.Empty, linkSpan);
+            Assert.AreEqual(SourceSpan.Empty, titleSpan);
+            Assert.AreEqual('A', text.CurrentChar);
+        }
 
-    [Test]
-    public void TestMultipleLines()
-    {
-        //                          0          1         2          3
-        //                          01 2345678901234567890 1234567890123456789
-        var text = new StringSlice("(\n<http://google.com>\n    'toto' )A");
-        Assert.True(LinkHelper.TryParseInlineLink(ref text, out string link, out string title, out SourceSpan linkSpan, out SourceSpan titleSpan));
-        Assert.AreEqual("http://google.com", link);
-        Assert.AreEqual("toto", title);
-        Assert.AreEqual(new SourceSpan(2, 20), linkSpan);
-        Assert.AreEqual(new SourceSpan(26, 31), titleSpan);
-        Assert.AreEqual('A', text.CurrentChar);
-    }
+        [Test]
+        public void TestMultipleLines()
+        {
+            //                          0          1         2          3
+            //                          01 2345678901234567890 1234567890123456789
+            var text = new StringSlice("(\n<http://google.com>\n    'toto' )A");
+            Assert.True(LinkHelper.TryParseInlineLink(ref text, out string link, out string title, out SourceSpan linkSpan, out SourceSpan titleSpan));
+            Assert.AreEqual("http://google.com", link);
+            Assert.AreEqual("toto", title);
+            Assert.AreEqual(new SourceSpan(2, 20), linkSpan);
+            Assert.AreEqual(new SourceSpan(26, 31), titleSpan);
+            Assert.AreEqual('A', text.CurrentChar);
+        }
 
-    [Test]
-    public void TestLabelSimple()
-    {
-        //                          01234
-        var text = new StringSlice("[foo]");
-        Assert.True(LinkHelper.TryParseLabel(ref text, out string label, out SourceSpan labelSpan));
-        Assert.AreEqual(new SourceSpan(1, 3), labelSpan);
-        Assert.AreEqual("foo", label);
-    }
+        [Test]
+        public void TestLabelSimple()
+        {
+            //                          01234
+            var text = new StringSlice("[foo]");
+            Assert.True(LinkHelper.TryParseLabel(ref text, out string label, out SourceSpan labelSpan));
+            Assert.AreEqual(new SourceSpan(1, 3), labelSpan);
+            Assert.AreEqual("foo", label);
+        }
 
-    [Test]
-    public void TestLabelEscape()
-    {
-        //                           012345678
-        var text = new StringSlice(@"[fo\[\]o]");
-        Assert.True(LinkHelper.TryParseLabel(ref text, out string label, out SourceSpan labelSpan));
-        Assert.AreEqual(new SourceSpan(1, 7), labelSpan);
-        Assert.AreEqual(@"fo[]o", label);
-    }
+        [Test]
+        public void TestLabelEscape()
+        {
+            //                           012345678
+            var text = new StringSlice(@"[fo\[\]o]");
+            Assert.True(LinkHelper.TryParseLabel(ref text, out string label, out SourceSpan labelSpan));
+            Assert.AreEqual(new SourceSpan(1, 7), labelSpan);
+            Assert.AreEqual(@"fo[]o", label);
+        }
 
-    [Test]
-    public void TestLabelEscape2()
-    {
-        //                           0123
-        var text = new StringSlice(@"[\]]");
-        Assert.True(LinkHelper.TryParseLabel(ref text, out string label, out SourceSpan labelSpan));
-        Assert.AreEqual(new SourceSpan(1, 2), labelSpan);
-        Assert.AreEqual(@"]", label);
-    }
+        [Test]
+        public void TestLabelEscape2()
+        {
+            //                           0123
+            var text = new StringSlice(@"[\]]");
+            Assert.True(LinkHelper.TryParseLabel(ref text, out string label, out SourceSpan labelSpan));
+            Assert.AreEqual(new SourceSpan(1, 2), labelSpan);
+            Assert.AreEqual(@"]", label);
+        }
 
-    [Test]
-    public void TestLabelInvalids()
-    {
-        Assert.False(LinkHelper.TryParseLabel(new StringSlice(@"a"), out string label));
-        Assert.False(LinkHelper.TryParseLabel(new StringSlice(@"["), out label));
-        Assert.False(LinkHelper.TryParseLabel(new StringSlice(@"[\x]"), out label));
-        Assert.False(LinkHelper.TryParseLabel(new StringSlice(@"[[]"), out label));
-        Assert.False(LinkHelper.TryParseLabel(new StringSlice(@"[     ]"), out label));
-        Assert.False(LinkHelper.TryParseLabel(new StringSlice(@"[  \t \n  ]"), out label));
-    }
+        [Test]
+        public void TestLabelInvalids()
+        {
+            Assert.False(LinkHelper.TryParseLabel(new StringSlice(@"a"), out string label));
+            Assert.False(LinkHelper.TryParseLabel(new StringSlice(@"["), out label));
+            Assert.False(LinkHelper.TryParseLabel(new StringSlice(@"[\x]"), out label));
+            Assert.False(LinkHelper.TryParseLabel(new StringSlice(@"[[]"), out label));
+            Assert.False(LinkHelper.TryParseLabel(new StringSlice(@"[     ]"), out label));
+            Assert.False(LinkHelper.TryParseLabel(new StringSlice(@"[  \t \n  ]"), out label));
+        }
 
-    [Test]
-    public void TestLabelWhitespaceCollapsedAndTrim()
-    {
-        //                           0         1         2         3
-        //                           0123456789012345678901234567890123456789
-        var text = new StringSlice(@"[     fo    o    z     ]");
-        Assert.True(LinkHelper.TryParseLabel(ref text, out string label, out SourceSpan labelSpan));
-        Assert.AreEqual(new SourceSpan(6, 17), labelSpan);
-        Assert.AreEqual(@"fo o z", label);
-    }
+        [Test]
+        public void TestLabelWhitespaceCollapsedAndTrim()
+        {
+            //                           0         1         2         3
+            //                           0123456789012345678901234567890123456789
+            var text = new StringSlice(@"[     fo    o    z     ]");
+            Assert.True(LinkHelper.TryParseLabel(ref text, out string label, out SourceSpan labelSpan));
+            Assert.AreEqual(new SourceSpan(6, 17), labelSpan);
+            Assert.AreEqual(@"fo o z", label);
+        }
 
-    [Test]
-    public void TestlLinkReferenceDefinitionSimple()
-    {
-        //                           0         1         2         3
-        //                           0123456789012345678901234567890123456789
-        var text = new StringSlice(@"[foo]: /toto 'title'");
-        Assert.True(LinkHelper.TryParseLinkReferenceDefinition(ref text, out string label, out string url, out string title, out SourceSpan labelSpan, out SourceSpan urlSpan, out SourceSpan titleSpan));
-        Assert.AreEqual(@"foo", label);
-        Assert.AreEqual(@"/toto", url);
-        Assert.AreEqual(@"title", title);
-        Assert.AreEqual(new SourceSpan(1, 3), labelSpan);
-        Assert.AreEqual(new SourceSpan(7, 11), urlSpan);
-        Assert.AreEqual(new SourceSpan(13, 19), titleSpan);
+        [Test]
+        public void TestlLinkReferenceDefinitionSimple()
+        {
+            //                           0         1         2         3
+            //                           0123456789012345678901234567890123456789
+            var text = new StringSlice(@"[foo]: /toto 'title'");
+            Assert.True(LinkHelper.TryParseLinkReferenceDefinition(ref text, out string label, out string url, out string title, out SourceSpan labelSpan, out SourceSpan urlSpan, out SourceSpan titleSpan));
+            Assert.AreEqual(@"foo", label);
+            Assert.AreEqual(@"/toto", url);
+            Assert.AreEqual(@"title", title);
+            Assert.AreEqual(new SourceSpan(1, 3), labelSpan);
+            Assert.AreEqual(new SourceSpan(7, 11), urlSpan);
+            Assert.AreEqual(new SourceSpan(13, 19), titleSpan);
 
-    }
+        }
 
-    [Test]
-    public void TestlLinkReferenceDefinitionInvalid()
-    {
-        var text = new StringSlice("[foo]: /url (title) x\n");
-        Assert.False(LinkHelper.TryParseLinkReferenceDefinition(ref text, out _, out _, out _, out _, out _, out _));
-    }
+        [Test]
+        public void TestAutoLinkUrlSimple()
+        {
+            var text = new StringSlice(@"<http://google.com>");
+            Assert.True(LinkHelper.TryParseAutolink(ref text, out string url, out bool isEmail));
+            Assert.False(isEmail);
+            Assert.AreEqual("http://google.com", url);
+        }
 
-    [Test]
-    public void TestAutoLinkUrlSimple()
-    {
-        var text = new StringSlice(@"<http://google.com>");
-        Assert.True(LinkHelper.TryParseAutolink(ref text, out string url, out bool isEmail));
-        Assert.False(isEmail);
-        Assert.AreEqual("http://google.com", url);
-    }
+        [Test]
+        public void TestAutoLinkEmailSimple()
+        {
+            var text = new StringSlice(@"<user@host.com>");
+            Assert.True(LinkHelper.TryParseAutolink(ref text, out string email, out bool isEmail));
+            Assert.True(isEmail);
+            Assert.AreEqual("user@host.com", email);
+        }
 
-    [Test]
-    public void TestAutoLinkEmailSimple()
-    {
-        var text = new StringSlice(@"<user@host.com>");
-        Assert.True(LinkHelper.TryParseAutolink(ref text, out string email, out bool isEmail));
-        Assert.True(isEmail);
-        Assert.AreEqual("user@host.com", email);
-    }
+        [Test]
+        public void TestAutolinkInvalid()
+        {
+            Assert.False(LinkHelper.TryParseAutolink(new StringSlice(@""), out string text, out bool isEmail));
+            Assert.False(LinkHelper.TryParseAutolink(new StringSlice(@"<"), out text, out isEmail));
+            Assert.False(LinkHelper.TryParseAutolink(new StringSlice(@"<ab"), out text, out isEmail));
+            Assert.False(LinkHelper.TryParseAutolink(new StringSlice(@"<user@>"), out text, out isEmail));
+        }
 
-    [Test]
-    public void TestAutolinkInvalid()
-    {
-        Assert.False(LinkHelper.TryParseAutolink(new StringSlice(@""), out string text, out bool isEmail));
-        Assert.False(LinkHelper.TryParseAutolink(new StringSlice(@"<"), out text, out isEmail));
-        Assert.False(LinkHelper.TryParseAutolink(new StringSlice(@"<ab"), out text, out isEmail));
-        Assert.False(LinkHelper.TryParseAutolink(new StringSlice(@"<user@>"), out text, out isEmail));
-    }
+        [TestCase("Header identifiers in HTML", "header-identifiers-in-html")]
+        [TestCase("* Dogs*?--in *my* house?", "dogs-in-my-house")] // Not Pandoc equivalent: dogs--in...
+        [TestCase("[HTML], [S5], or [RTF]?", "html-s5-or-rtf")]
+        [TestCase("3. Applications", "applications")]
+        [TestCase("33", "")]
+        public void TestUrilizeNonAscii_Pandoc(string input, string expectedResult)
+        {
+            Assert.AreEqual(expectedResult, LinkHelper.Urilize(input, false));
+        }
 
-    [TestCase("Header identifiers in HTML", "header-identifiers-in-html")]
-    [TestCase("* Dogs*?--in *my* house?", "dogs-in-my-house")] // Not Pandoc equivalent: dogs--in...
-    [TestCase("[HTML], [S5], or [RTF]?", "html-s5-or-rtf")]
-    [TestCase("3. Applications", "applications")]
-    [TestCase("33", "")]
-    public void TestUrilizeNonAscii_Pandoc(string input, string expectedResult)
-    {
-        Assert.AreEqual(expectedResult, LinkHelper.Urilize(input, false));
-    }
+        [TestCase("Header identifiers in HTML", "header-identifiers-in-html")]
+        [TestCase("* Dogs*?--in *my* house?", "-dogs--in-my-house")]
+        [TestCase("[HTML], [S5], or [RTF]?", "html-s5-or-rtf")]
+        [TestCase("3. Applications", "3-applications")]
+        [TestCase("33", "33")]
+        public void TestUrilizeGfm(string input, string expectedResult)
+        {
+            Assert.AreEqual(expectedResult, LinkHelper.UrilizeAsGfm(input));
+        }
 
-    [TestCase("Header identifiers in HTML", "header-identifiers-in-html")]
-    [TestCase("* Dogs*?--in *my* house?", "-dogs--in-my-house")]
-    [TestCase("[HTML], [S5], or [RTF]?", "html-s5-or-rtf")]
-    [TestCase("3. Applications", "3-applications")]
-    [TestCase("33", "33")]
-    public void TestUrilizeGfm(string input, string expectedResult)
-    {
-        Assert.AreEqual(expectedResult, LinkHelper.UrilizeAsGfm(input));
-    }
+        [TestCase("abc", "abc")]
+        [TestCase("a-c", "a-c")]
+        [TestCase("a c", "a-c")]
+        [TestCase("a_c", "a_c")]
+        [TestCase("a.c", "a.c")]
+        [TestCase("a,c", "ac")]
+        [TestCase("a--", "a")] // Not Pandoc-equivalent: a--
+        [TestCase("a__", "a")] // Not Pandoc-equivalent: a__
+        [TestCase("a..", "a")] // Not Pandoc-equivalent: a..
+        [TestCase("a??", "a")]
+        [TestCase("a  ", "a")]
+        [TestCase("a--d", "a-d")]
+        [TestCase("a__d", "a_d")]
+        [TestCase("a??d", "ad")]
+        [TestCase("a  d", "a-d")]
+        [TestCase("a..d", "a.d")]
+        [TestCase("-bc", "bc")]
+        [TestCase("_bc", "bc")]
+        [TestCase(" bc", "bc")]
+        [TestCase("?bc", "bc")]
+        [TestCase(".bc", "bc")]
+        [TestCase("a-.-", "a")] // Not Pandoc equivalent: a-.-
+        public void TestUrilizeOnlyAscii_Simple(string input, string expectedResult)
+        {
+            Assert.AreEqual(expectedResult, LinkHelper.Urilize(input, true));
+        }
 
-    [TestCase("abc", "abc")]
-    [TestCase("a-c", "a-c")]
-    [TestCase("a c", "a-c")]
-    [TestCase("a_c", "a_c")]
-    [TestCase("a.c", "a.c")]
-    [TestCase("a,c", "ac")]
-    [TestCase("a--", "a")] // Not Pandoc-equivalent: a--
-    [TestCase("a__", "a")] // Not Pandoc-equivalent: a__
-    [TestCase("a..", "a")] // Not Pandoc-equivalent: a..
-    [TestCase("a??", "a")]
-    [TestCase("a  ", "a")]
-    [TestCase("a--d", "a-d")]
-    [TestCase("a__d", "a_d")]
-    [TestCase("a??d", "ad")]
-    [TestCase("a  d", "a-d")]
-    [TestCase("a..d", "a.d")]
-    [TestCase("-bc", "bc")]
-    [TestCase("_bc", "bc")]
-    [TestCase(" bc", "bc")]
-    [TestCase("?bc", "bc")]
-    [TestCase(".bc", "bc")]
-    [TestCase("a-.-", "a")] // Not Pandoc equivalent: a-.-
-    public void TestUrilizeOnlyAscii_Simple(string input, string expectedResult)
-    {
-        Assert.AreEqual(expectedResult, LinkHelper.Urilize(input, true));
-    }
+        [TestCase("bær", "br")]
+        [TestCase("bør", "br")]
+        [TestCase("bΘr", "br")]
+        [TestCase("四五", "")]
+        public void TestUrilizeOnlyAscii_NonAscii(string input, string expectedResult)
+        {
+            Assert.AreEqual(expectedResult, LinkHelper.Urilize(input, true));
+        }
 
-    [TestCase("bær", "br")]
-    [TestCase("bør", "br")]
-    [TestCase("bΘr", "br")]
-    [TestCase("四五", "")]
-    public void TestUrilizeOnlyAscii_NonAscii(string input, string expectedResult)
-    {
-        Assert.AreEqual(expectedResult, LinkHelper.Urilize(input, true));
-    }
+        [TestCase("bár", "bar")]
+        [TestCase("àrrivé", "arrive")]
+        public void TestUrilizeOnlyAscii_Normalization(string input, string expectedResult)
+        {
+            Assert.AreEqual(expectedResult, LinkHelper.Urilize(input, true));
+        }
 
-    [TestCase("bár", "bar")]
-    [TestCase("àrrivé", "arrive")]
-    public void TestUrilizeOnlyAscii_Normalization(string input, string expectedResult)
-    {
-        Assert.AreEqual(expectedResult, LinkHelper.Urilize(input, true));
-    }
+        [TestCase("123", "")]
+        [TestCase("1,-b", "b")]
+        [TestCase("b1,-", "b1")] // Not Pandoc equivalent: b1-
+        [TestCase("ab3", "ab3")]
+        [TestCase("ab3de", "ab3de")]
+        public void TestUrilizeOnlyAscii_Numeric(string input, string expectedResult)
+        {
+            Assert.AreEqual(expectedResult, LinkHelper.Urilize(input, true));
+        }
 
-    [TestCase("123", "")]
-    [TestCase("1,-b", "b")]
-    [TestCase("b1,-", "b1")] // Not Pandoc equivalent: b1-
-    [TestCase("ab3", "ab3")]
-    [TestCase("ab3de", "ab3de")]
-    public void TestUrilizeOnlyAscii_Numeric(string input, string expectedResult)
-    {
-        Assert.AreEqual(expectedResult, LinkHelper.Urilize(input, true));
-    }
+        [TestCase("一二三四五", "一二三四五")]
+        [TestCase("一,-b", "一-b")]
+        public void TestUrilizeNonAscii_NonAsciiNumeric(string input, string expectedResult)
+        {
+            Assert.AreEqual(expectedResult, LinkHelper.Urilize(input, false));
+        }
 
-    [TestCase("一二三四五", "一二三四五")]
-    [TestCase("一,-b", "一-b")]
-    public void TestUrilizeNonAscii_NonAsciiNumeric(string input, string expectedResult)
-    {
-        Assert.AreEqual(expectedResult, LinkHelper.Urilize(input, false));
-    }
+        [TestCase("bær", "bær")]
+        [TestCase("æ5el", "æ5el")]
+        [TestCase("-æ5el", "æ5el")]
+        [TestCase("-frø-", "frø")]
+        [TestCase("-fr-ø", "fr-ø")]
+        public void TestUrilizeNonAscii_Simple(string input, string expectedResult)
+        {
+            Assert.AreEqual(expectedResult, LinkHelper.Urilize(input, false));
+        }
 
-    [TestCase("bær", "bær")]
-    [TestCase("æ5el", "æ5el")]
-    [TestCase("-æ5el", "æ5el")]
-    [TestCase("-frø-", "frø")]
-    [TestCase("-fr-ø", "fr-ø")]
-    public void TestUrilizeNonAscii_Simple(string input, string expectedResult)
-    {
-        Assert.AreEqual(expectedResult, LinkHelper.Urilize(input, false));
-    }
+        // Just to be sure, test for characters expressly forbidden in URI fragments:
+        [TestCase("b#r", "br")]
+        [TestCase("b%r", "br")] // Invalid except as an escape character
+        [TestCase("b^r", "br")]
+        [TestCase("b[r", "br")]
+        [TestCase("b]r", "br")]
+        [TestCase("b{r", "br")]
+        [TestCase("b}r", "br")]
+        [TestCase("b<r", "br")]
+        [TestCase("b>r", "br")]
+        [TestCase(@"b\r", "br")]
+        [TestCase(@"b""r", "br")]
+        [TestCase(@"Requirement 😀", "requirement")]
+        public void TestUrilizeNonAscii_NonValidCharactersForFragments(string input, string expectedResult)
+        {
+            Assert.AreEqual(expectedResult, LinkHelper.Urilize(input, false));
+        }
 
-    // Just to be sure, test for characters expressly forbidden in URI fragments:
-    [TestCase("b#r", "br")]
-    [TestCase("b%r", "br")] // Invalid except as an escape character
-    [TestCase("b^r", "br")]
-    [TestCase("b[r", "br")]
-    [TestCase("b]r", "br")]
-    [TestCase("b{r", "br")]
-    [TestCase("b}r", "br")]
-    [TestCase("b<r", "br")]
-    [TestCase("b>r", "br")]
-    [TestCase(@"b\r", "br")]
-    [TestCase(@"b""r", "br")]
-    [TestCase(@"Requirement 😀", "requirement")]
-    public void TestUrilizeNonAscii_NonValidCharactersForFragments(string input, string expectedResult)
-    {
-        Assert.AreEqual(expectedResult, LinkHelper.Urilize(input, false));
-    }
-
-    [Test]
-    public void TestUnicodeInDomainNameOfLinkReferenceDefinition()
-    {
-        TestParser.TestSpec("[Foo]\n\n[Foo]: http://ünicode.com", "<p><a href=\"http://xn--nicode-2ya.com\">Foo</a></p>");
+        [Test]
+        public void TestUnicodeInDomainNameOfLinkReferenceDefinition()
+        {
+            TestParser.TestSpec("[Foo]\n\n[Foo]: http://ünicode.com", "<p><a href=\"http://xn--nicode-2ya.com\">Foo</a></p>");
+        }
     }
 }

src/Markdig.Tests/TestLinkRewriter.cs

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

src/Markdig.Tests/TestMarkdigCoreApi.cs

@@ -1,214 +1,217 @@
 using Markdig.Renderers;
 using Markdig.Syntax;
 using Markdig.Syntax.Inlines;
+using NUnit.Framework;
+using System.IO;
 
-namespace Markdig.Tests;
-
-public class TestMarkdigCoreApi
+namespace Markdig.Tests
 {
-    [Test]
-    public void TestToHtml()
+    public class TestMarkdigCoreApi
     {
-        for (int i = 0; i < 5; i++)
+        [Test]
+        public void TestToHtml()
         {
-            string html = Markdown.ToHtml("This is a text with some *emphasis*");
-            Assert.AreEqual("<p>This is a text with some <em>emphasis</em></p>\n", html);
+            for (int i = 0; i < 5; i++)
+            {
+                string html = Markdown.ToHtml("This is a text with some *emphasis*");
+                Assert.AreEqual("<p>This is a text with some <em>emphasis</em></p>\n", html);
 
-            html = Markdown.ToHtml("This is a text with a https://link.tld/");
-            Assert.AreNotEqual("<p>This is a text with a <a href=\"https://link.tld/\">https://link.tld/</a></p>\n", html);
-        }
-    }
-
-    [Test]
-    public void TestToHtmlWithPipeline()
-    {
-        var pipeline = new MarkdownPipelineBuilder()
-            .Build();
-
-        for (int i = 0; i < 5; i++)
-        {
-            string html = Markdown.ToHtml("This is a text with some *emphasis*", pipeline);
-            Assert.AreEqual("<p>This is a text with some <em>emphasis</em></p>\n", html);
-
-            html = Markdown.ToHtml("This is a text with a https://link.tld/", pipeline);
-            Assert.AreNotEqual("<p>This is a text with a <a href=\"https://link.tld/\">https://link.tld/</a></p>\n", html);
+                html = Markdown.ToHtml("This is a text with a https://link.tld/");
+                Assert.AreNotEqual("<p>This is a text with a <a href=\"https://link.tld/\">https://link.tld/</a></p>\n", html);
+            }
         }
 
-        pipeline = new MarkdownPipelineBuilder()
-            .UseAdvancedExtensions()
-            .Build();
-
-        for (int i = 0; i < 5; i++)
+        [Test]
+        public void TestToHtmlWithPipeline()
         {
-            string html = Markdown.ToHtml("This is a text with a https://link.tld/", pipeline);
-            Assert.AreEqual("<p>This is a text with a <a href=\"https://link.tld/\">https://link.tld/</a></p>\n", html);
-        }
-    }
+            var pipeline = new MarkdownPipelineBuilder()
+                .Build();
 
-    [Test]
-    public void TestToHtmlWithWriter()
-    {
-        var writer = new StringWriter();
+            for (int i = 0; i < 5; i++)
+            {
+                string html = Markdown.ToHtml("This is a text with some *emphasis*", pipeline);
+                Assert.AreEqual("<p>This is a text with some <em>emphasis</em></p>\n", html);
 
-        for (int i = 0; i < 5; i++)
-        {
-            _ = Markdown.ToHtml("This is a text with some *emphasis*", writer);
-            string html = writer.ToString();
-            Assert.AreEqual("<p>This is a text with some <em>emphasis</em></p>\n", html);
-            writer.GetStringBuilder().Length = 0;
+                html = Markdown.ToHtml("This is a text with a https://link.tld/", pipeline);
+                Assert.AreNotEqual("<p>This is a text with a <a href=\"https://link.tld/\">https://link.tld/</a></p>\n", html);
+            }
+
+            pipeline = new MarkdownPipelineBuilder()
+                .UseAdvancedExtensions()
+                .Build();
+
+            for (int i = 0; i < 5; i++)
+            {
+                string html = Markdown.ToHtml("This is a text with a https://link.tld/", pipeline);
+                Assert.AreEqual("<p>This is a text with a <a href=\"https://link.tld/\">https://link.tld/</a></p>\n", html);
+            }
         }
 
-        writer = new StringWriter();
-        var pipeline = new MarkdownPipelineBuilder()
-            .UseAdvancedExtensions()
-            .Build();
-
-        for (int i = 0; i < 5; i++)
-        {
-            _ = Markdown.ToHtml("This is a text with a https://link.tld/", writer, pipeline);
-            string html = writer.ToString();
-            Assert.AreEqual("<p>This is a text with a <a href=\"https://link.tld/\">https://link.tld/</a></p>\n", html);
-            writer.GetStringBuilder().Length = 0;
-        }
-    }
-
-    [Test]
-    public void TestDocumentToHtmlWithWriter()
-    {
-        var writer = new StringWriter();
-
-        for (int i = 0; i < 5; i++)
-        {
-            MarkdownDocument document = Markdown.Parse("This is a text with some *emphasis*");
-            document.ToHtml(writer);
-            string html = writer.ToString();
-            Assert.AreEqual("<p>This is a text with some <em>emphasis</em></p>\n", html);
-            writer.GetStringBuilder().Length = 0;
-        }
-
-        writer = new StringWriter();
-        var pipeline = new MarkdownPipelineBuilder()
-            .UseAdvancedExtensions()
-            .Build();
-
-        for (int i = 0; i < 5; i++)
-        {
-            MarkdownDocument document = Markdown.Parse("This is a text with a https://link.tld/", pipeline);
-            document.ToHtml(writer, pipeline);
-            string html = writer.ToString();
-            Assert.AreEqual("<p>This is a text with a <a href=\"https://link.tld/\">https://link.tld/</a></p>\n", html);
-            writer.GetStringBuilder().Length = 0;
-        }
-    }
-
-    [Test]
-    public void TestConvert()
-    {
-        var writer = new StringWriter();
-        var renderer = new HtmlRenderer(writer);
-
-        for (int i = 0; i < 5; i++)
-        {
-            _ = Markdown.Convert("This is a text with some *emphasis*", renderer);
-            string html = writer.ToString();
-            Assert.AreEqual("<p>This is a text with some <em>emphasis</em></p>\n", html);
-            writer.GetStringBuilder().Length = 0;
-        }
-
-        writer = new StringWriter();
-        renderer = new HtmlRenderer(writer);
-        var pipeline = new MarkdownPipelineBuilder()
-            .UseAdvancedExtensions()
-            .Build();
-
-        for (int i = 0; i < 5; i++)
-        {
-            _ = Markdown.Convert("This is a text with a https://link.tld/", renderer, pipeline);
-            string html = writer.ToString();
-            Assert.AreEqual("<p>This is a text with a <a href=\"https://link.tld/\">https://link.tld/</a></p>\n", html);
-            writer.GetStringBuilder().Length = 0;
-        }
-    }
-
-    [Test]
-    public void TestParse()
-    {
-        const string markdown = "This is a text with some *emphasis*";
-
-        var pipeline = new MarkdownPipelineBuilder()
-            .UsePreciseSourceLocation()
-            .Build();
-
-        for (int i = 0; i < 5; i++)
-        {
-            MarkdownDocument document = Markdown.Parse(markdown, pipeline);
-
-            Assert.AreEqual(1, document.LineCount);
-            Assert.AreEqual(markdown.Length, document.Span.Length);
-            Assert.AreEqual(1, document.LineStartIndexes.Count);
-            Assert.AreEqual(0, document.LineStartIndexes[0]);
-
-            Assert.AreEqual(1, document.Count);
-            ParagraphBlock paragraph = document[0] as ParagraphBlock;
-            Assert.NotNull(paragraph);
-            Assert.AreEqual(markdown.Length, paragraph.Span.Length);
-            LiteralInline literal = paragraph.Inline.FirstChild as LiteralInline;
-            Assert.NotNull(literal);
-            Assert.AreEqual("This is a text with some ", literal.ToString());
-            EmphasisInline emphasis = literal.NextSibling as EmphasisInline;
-            Assert.NotNull(emphasis);
-            Assert.AreEqual("*emphasis*".Length, emphasis.Span.Length);
-            LiteralInline emphasisLiteral = emphasis.FirstChild as LiteralInline;
-            Assert.NotNull(emphasisLiteral);
-            Assert.AreEqual("emphasis", emphasisLiteral.ToString());
-            Assert.Null(emphasisLiteral.NextSibling);
-            Assert.Null(emphasis.NextSibling);
-        }
-    }
-
-    [Test]
-    public void TestNormalize()
-    {
-        for (int i = 0; i < 5; i++)
-        {
-            string normalized = Markdown.Normalize("Heading\n=======");
-            Assert.AreEqual("# Heading", normalized);
-        }
-    }
-
-    [Test]
-    public void TestNormalizeWithWriter()
-    {
-        for (int i = 0; i < 5; i++)
+        [Test]
+        public void TestToHtmlWithWriter()
         {
             var writer = new StringWriter();
 
-            _ = Markdown.Normalize("Heading\n=======", writer);
-            string normalized = writer.ToString();
-            Assert.AreEqual("# Heading", normalized);
-        }
-    }
+            for (int i = 0; i < 5; i++)
+            {
+                _ = Markdown.ToHtml("This is a text with some *emphasis*", writer);
+                string html = writer.ToString();
+                Assert.AreEqual("<p>This is a text with some <em>emphasis</em></p>\n", html);
+                writer.GetStringBuilder().Length = 0;
+            }
 
-    [Test]
-    public void TestToPlainText()
-    {
-        for (int i = 0; i < 5; i++)
-        {
-            string plainText = Markdown.ToPlainText("*Hello*, [world](http://example.com)!");
-            Assert.AreEqual("Hello, world!\n", plainText);
-        }
-    }
+            writer = new StringWriter();
+            var pipeline = new MarkdownPipelineBuilder()
+                .UseAdvancedExtensions()
+                .Build();
 
-    [Test]
-    public void TestToPlainTextWithWriter()
-    {
-        for (int i = 0; i < 5; i++)
+            for (int i = 0; i < 5; i++)
+            {
+                _ = Markdown.ToHtml("This is a text with a https://link.tld/", writer, pipeline);
+                string html = writer.ToString();
+                Assert.AreEqual("<p>This is a text with a <a href=\"https://link.tld/\">https://link.tld/</a></p>\n", html);
+                writer.GetStringBuilder().Length = 0;
+            }
+        }
+
+        [Test]
+        public void TestDocumentToHtmlWithWriter()
         {
             var writer = new StringWriter();
 
-            _ = Markdown.ToPlainText("*Hello*, [world](http://example.com)!", writer);
-            string plainText = writer.ToString();
-            Assert.AreEqual("Hello, world!\n", plainText);
+            for (int i = 0; i < 5; i++)
+            {
+                MarkdownDocument document = Markdown.Parse("This is a text with some *emphasis*");
+                document.ToHtml(writer);
+                string html = writer.ToString();
+                Assert.AreEqual("<p>This is a text with some <em>emphasis</em></p>\n", html);
+                writer.GetStringBuilder().Length = 0;
+            }
+
+            writer = new StringWriter();
+            var pipeline = new MarkdownPipelineBuilder()
+                .UseAdvancedExtensions()
+                .Build();
+
+            for (int i = 0; i < 5; i++)
+            {
+                MarkdownDocument document = Markdown.Parse("This is a text with a https://link.tld/", pipeline);
+                document.ToHtml(writer, pipeline);
+                string html = writer.ToString();
+                Assert.AreEqual("<p>This is a text with a <a href=\"https://link.tld/\">https://link.tld/</a></p>\n", html);
+                writer.GetStringBuilder().Length = 0;
+            }
+        }
+
+        [Test]
+        public void TestConvert()
+        {
+            var writer = new StringWriter();
+            var renderer = new HtmlRenderer(writer);
+
+            for (int i = 0; i < 5; i++)
+            {
+                _ = Markdown.Convert("This is a text with some *emphasis*", renderer);
+                string html = writer.ToString();
+                Assert.AreEqual("<p>This is a text with some <em>emphasis</em></p>\n", html);
+                writer.GetStringBuilder().Length = 0;
+            }
+
+            writer = new StringWriter();
+            renderer = new HtmlRenderer(writer);
+            var pipeline = new MarkdownPipelineBuilder()
+                .UseAdvancedExtensions()
+                .Build();
+
+            for (int i = 0; i < 5; i++)
+            {
+                _ = Markdown.Convert("This is a text with a https://link.tld/", renderer, pipeline);
+                string html = writer.ToString();
+                Assert.AreEqual("<p>This is a text with a <a href=\"https://link.tld/\">https://link.tld/</a></p>\n", html);
+                writer.GetStringBuilder().Length = 0;
+            }
+        }
+
+        [Test]
+        public void TestParse()
+        {
+            const string markdown = "This is a text with some *emphasis*";
+
+            var pipeline = new MarkdownPipelineBuilder()
+                .UsePreciseSourceLocation()
+                .Build();
+
+            for (int i = 0; i < 5; i++)
+            {
+                MarkdownDocument document = Markdown.Parse(markdown, pipeline);
+
+                Assert.AreEqual(1, document.LineCount);
+                Assert.AreEqual(markdown.Length, document.Span.Length);
+                Assert.AreEqual(1, document.LineStartIndexes.Count);
+                Assert.AreEqual(0, document.LineStartIndexes[0]);
+
+                Assert.AreEqual(1, document.Count);
+                ParagraphBlock paragraph = document[0] as ParagraphBlock;
+                Assert.NotNull(paragraph);
+                Assert.AreEqual(markdown.Length, paragraph.Span.Length);
+                LiteralInline literal = paragraph.Inline.FirstChild as LiteralInline;
+                Assert.NotNull(literal);
+                Assert.AreEqual("This is a text with some ", literal.ToString());
+                EmphasisInline emphasis = literal.NextSibling as EmphasisInline;
+                Assert.NotNull(emphasis);
+                Assert.AreEqual("*emphasis*".Length, emphasis.Span.Length);
+                LiteralInline emphasisLiteral = emphasis.FirstChild as LiteralInline;
+                Assert.NotNull(emphasisLiteral);
+                Assert.AreEqual("emphasis", emphasisLiteral.ToString());
+                Assert.Null(emphasisLiteral.NextSibling);
+                Assert.Null(emphasis.NextSibling);
+            }
+        }
+
+        [Test]
+        public void TestNormalize()
+        {
+            for (int i = 0; i < 5; i++)
+            {
+                string normalized = Markdown.Normalize("Heading\n=======");
+                Assert.AreEqual("# Heading", normalized);
+            }
+        }
+
+        [Test]
+        public void TestNormalizeWithWriter()
+        {
+            for (int i = 0; i < 5; i++)
+            {
+                var writer = new StringWriter();
+
+                _ = Markdown.Normalize("Heading\n=======", writer);
+                string normalized = writer.ToString();
+                Assert.AreEqual("# Heading", normalized);
+            }
+        }
+
+        [Test]
+        public void TestToPlainText()
+        {
+            for (int i = 0; i < 5; i++)
+            {
+                string plainText = Markdown.ToPlainText("*Hello*, [world](http://example.com)!");
+                Assert.AreEqual("Hello, world!\n", plainText);
+            }
+        }
+
+        [Test]
+        public void TestToPlainTextWithWriter()
+        {
+            for (int i = 0; i < 5; i++)
+            {
+                var writer = new StringWriter();
+
+                _ = Markdown.ToPlainText("*Hello*, [world](http://example.com)!", writer);
+                string plainText = writer.ToString();
+                Assert.AreEqual("Hello, world!\n", plainText);
+            }
         }
     }
 }

src/Markdig.Tests/TestMediaLinks.cs

@@ -1,113 +1,104 @@
+using Markdig.Extensions.MediaLinks;
+using NUnit.Framework;
+using System;
 using System.Text.RegularExpressions;
 
-using Markdig.Extensions.MediaLinks;
-
-namespace Markdig.Tests;
-
-[TestFixture]
-public class TestMediaLinks
+namespace Markdig.Tests
 {
-    private MarkdownPipeline GetPipeline(MediaOptions options = null)
+    [TestFixture]
+    public class TestMediaLinks
     {
-        return new MarkdownPipelineBuilder()
-             .UseMediaLinks(options)
-             .Build();
-    }
-
-    private MarkdownPipeline GetPipelineWithBootstrap(MediaOptions options = null)
-    {
-        return new MarkdownPipelineBuilder()
-            .UseBootstrap()
-            .UseMediaLinks(options)
-            .Build();
-    }
-
-    [Test]
-    [TestCase("![static mp4](https://sample.com/video.mp4)", "<p><video width=\"500\" height=\"281\" controls=\"\"><source type=\"video/mp4\" src=\"https://sample.com/video.mp4\"></source></video></p>\n")]
-    [TestCase("![static mp4](//sample.com/video.mp4)", "<p><video width=\"500\" height=\"281\" controls=\"\"><source type=\"video/mp4\" src=\"//sample.com/video.mp4\"></source></video></p>\n")]
-    [TestCase(@"![youtube short](https://www.youtube.com/shorts/6BUptHVuvyI?feature=share)", "<p><iframe src=\"https://www.youtube.com/embed/6BUptHVuvyI\" class=\"youtubeshort\" width=\"500\" height=\"281\" frameborder=\"0\" allowfullscreen=\"\"></iframe></p>\n")]
-    [TestCase(@"![youtube.com](https://www.youtube.com/watch?v=mswPy5bt3TQ)", "<p><iframe src=\"https://www.youtube.com/embed/mswPy5bt3TQ\" class=\"youtube\" width=\"500\" height=\"281\" frameborder=\"0\" allowfullscreen=\"\"></iframe></p>\n")]
-    [TestCase("![yandex.ru](https://music.yandex.ru/album/411845/track/4402274)", "<p><iframe src=\"https://music.yandex.ru/iframe/#track/4402274/411845/\" class=\"yandex\" width=\"500\" height=\"281\" frameborder=\"0\"></iframe></p>\n")]
-    [TestCase("![vimeo](https://vimeo.com/8607834)", "<p><iframe src=\"https://player.vimeo.com/video/8607834\" class=\"vimeo\" width=\"500\" height=\"281\" frameborder=\"0\" allowfullscreen=\"\"></iframe></p>\n")]
-    [TestCase("![ok.ru](https://ok.ru/video/26870090463)", "<p><iframe src=\"https://ok.ru/videoembed/26870090463\" class=\"odnoklassniki\" width=\"500\" height=\"281\" frameborder=\"0\" allowfullscreen=\"\"></iframe></p>\n")]
-    [TestCase("![ok.ru](//ok.ru/video/26870090463)", "<p><iframe src=\"https://ok.ru/videoembed/26870090463\" class=\"odnoklassniki\" width=\"500\" height=\"281\" frameborder=\"0\" allowfullscreen=\"\"></iframe></p>\n")]
-    public void TestBuiltInHosts(string markdown, string expected)
-    {
-        string html = Markdown.ToHtml(markdown, GetPipeline());
-        Assert.AreEqual(expected, html);
-    }
-
-    [TestCase("![static video relative path](./video.mp4)",
-        "<p><video width=\"500\" height=\"281\" controls=\"\"><source type=\"video/mp4\" src=\"./video.mp4\"></source></video></p>\n")]
-    [TestCase("![static audio relative path](./audio.mp3)",
-        "<p><audio width=\"500\" controls=\"\"><source type=\"audio/mpeg\" src=\"./audio.mp3\"></source></audio></p>\n")]
-    public void TestBuiltInHostsWithRelativePaths(string markdown, string expected)
-    {
-        string html = Markdown.ToHtml(markdown, GetPipeline());
-        Assert.AreEqual(expected, html);
-    }
-    
-    private class TestHostProvider : IHostProvider
-    {
-        public string Class { get; } = "regex";
-        public bool AllowFullScreen { get; }
-
-        public bool TryHandle(Uri mediaUri, bool isSchemaRelative, out string iframeUrl)
+        private MarkdownPipeline GetPipeline(MediaOptions options = null)
         {
-            iframeUrl = null;
-            var uri = isSchemaRelative ? "//" + mediaUri.GetComponents(UriComponents.AbsoluteUri & ~UriComponents.Scheme, UriFormat.UriEscaped) : mediaUri.ToString();
-            if (!matcher.IsMatch(uri))
-                return false;
-            iframeUrl = matcher.Replace(uri, replacement);
-            return true;
+            return new MarkdownPipelineBuilder()
+                 .UseMediaLinks(options)
+                 .Build();
         }
 
-        private Regex matcher;
-        private string replacement;
-
-        public TestHostProvider(string provider, string replace)
+        private MarkdownPipeline GetPipelineWithBootstrap(MediaOptions options = null)
         {
-            matcher = new Regex(provider);
-            replacement = replace;
+            return new MarkdownPipelineBuilder()
+                .UseBootstrap()
+                .UseMediaLinks(options)
+                .Build();
         }
-    }
 
-    [Test]
-    [TestCase("![p1](https://sample.com/video.mp4)", "<p><iframe src=\"https://example.com/video.mp4\" class=\"regex\" width=\"500\" height=\"281\" frameborder=\"0\"></iframe></p>\n", @"^https?://sample.com/(.+)$", @"https://example.com/$1")]
-    [TestCase("![p1](//sample.com/video.mp4)", "<p><iframe src=\"https://example.com/video.mp4\" class=\"regex\" width=\"500\" height=\"281\" frameborder=\"0\"></iframe></p>\n", @"^//sample.com/(.+)$", @"https://example.com/$1")]
-    [TestCase("![p1](https://sample.com/video.mp4)", "<p><iframe src=\"https://example.com/video.mp4?token=aaabbb\" class=\"regex\" width=\"500\" height=\"281\" frameborder=\"0\"></iframe></p>\n", @"^https?://sample.com/(.+)$", @"https://example.com/$1?token=aaabbb")]
-    public void TestCustomHostProvider(string markdown, string expected, string provider, string replace)
-    {
-        string html = Markdown.ToHtml(markdown, GetPipeline(new MediaOptions
+        [Test]
+        [TestCase("![static mp4](https://sample.com/video.mp4)", "<p><video width=\"500\" height=\"281\" controls=\"\"><source type=\"video/mp4\" src=\"https://sample.com/video.mp4\"></source></video></p>\n")]
+        [TestCase("![static mp4](//sample.com/video.mp4)", "<p><video width=\"500\" height=\"281\" controls=\"\"><source type=\"video/mp4\" src=\"//sample.com/video.mp4\"></source></video></p>\n")]
+        [TestCase(@"![youtube.com](https://www.youtube.com/watch?v=mswPy5bt3TQ)", "<p><iframe src=\"https://www.youtube.com/embed/mswPy5bt3TQ\" class=\"youtube\" width=\"500\" height=\"281\" frameborder=\"0\" allowfullscreen=\"\"></iframe></p>\n")]
+        [TestCase("![yandex.ru](https://music.yandex.ru/album/411845/track/4402274)", "<p><iframe src=\"https://music.yandex.ru/iframe/#track/4402274/411845/\" class=\"yandex\" width=\"500\" height=\"281\" frameborder=\"0\"></iframe></p>\n")]
+        [TestCase("![vimeo](https://vimeo.com/8607834)", "<p><iframe src=\"https://player.vimeo.com/video/8607834\" class=\"vimeo\" width=\"500\" height=\"281\" frameborder=\"0\" allowfullscreen=\"\"></iframe></p>\n")]
+        [TestCase("![ok.ru](https://ok.ru/video/26870090463)", "<p><iframe src=\"https://ok.ru/videoembed/26870090463\" class=\"odnoklassniki\" width=\"500\" height=\"281\" frameborder=\"0\" allowfullscreen=\"\"></iframe></p>\n")]
+        [TestCase("![ok.ru](//ok.ru/video/26870090463)", "<p><iframe src=\"https://ok.ru/videoembed/26870090463\" class=\"odnoklassniki\" width=\"500\" height=\"281\" frameborder=\"0\" allowfullscreen=\"\"></iframe></p>\n")]
+        public void TestBuiltInHosts(string markdown, string expected)
         {
-            Hosts =
+            string html = Markdown.ToHtml(markdown, GetPipeline());
+            Assert.AreEqual(html, expected);
+        }
+
+        private class TestHostProvider : IHostProvider
+        {
+            public string Class { get; } = "regex";
+            public bool AllowFullScreen { get; }
+
+            public bool TryHandle(Uri mediaUri, bool isSchemaRelative, out string iframeUrl)
             {
-                new TestHostProvider(provider, replace),
+                iframeUrl = null;
+                var uri = isSchemaRelative ? "//" + mediaUri.GetComponents(UriComponents.AbsoluteUri & ~UriComponents.Scheme, UriFormat.UriEscaped) : mediaUri.ToString();
+                if (!matcher.IsMatch(uri))
+                    return false;
+                iframeUrl = matcher.Replace(uri, replacement);
+                return true;
             }
-        }));
-        Assert.AreEqual(html, expected);
-    }
 
-    [Test]
-    [TestCase("![static mp4](//sample.com/video.mp4)", "<p><video width=\"500\" height=\"281\" controls=\"\"><source type=\"video/mp4\" src=\"//sample.com/video.mp4\"></source></video></p>\n", "")]
-    [TestCase(@"![youtube.com](https://www.youtube.com/watch?v=mswPy5bt3TQ)", "<p><iframe src=\"https://www.youtube.com/embed/mswPy5bt3TQ\" class=\"youtube\" width=\"500\" height=\"281\" frameborder=\"0\" allowfullscreen=\"\"></iframe></p>\n", "")]
-    [TestCase("![static mp4](//sample.com/video.mp4)", "<p><video class=\"k\" width=\"500\" height=\"281\" controls=\"\"><source type=\"video/mp4\" src=\"//sample.com/video.mp4\"></source></video></p>\n", "k")]
-    [TestCase(@"![youtube.com](https://www.youtube.com/watch?v=mswPy5bt3TQ)", "<p><iframe src=\"https://www.youtube.com/embed/mswPy5bt3TQ\" class=\"k youtube\" width=\"500\" height=\"281\" frameborder=\"0\" allowfullscreen=\"\"></iframe></p>\n", "k")]
-    public void TestCustomClass(string markdown, string expected, string klass)
-    {
-        string html = Markdown.ToHtml(markdown, GetPipeline(new MediaOptions
+            private Regex matcher;
+            private string replacement;
+
+            public TestHostProvider(string provider, string replace)
+            {
+                matcher = new Regex(provider);
+                replacement = replace;
+            }
+        }
+
+        [Test]
+        [TestCase("![p1](https://sample.com/video.mp4)", "<p><iframe src=\"https://example.com/video.mp4\" class=\"regex\" width=\"500\" height=\"281\" frameborder=\"0\"></iframe></p>\n", @"^https?://sample.com/(.+)$", @"https://example.com/$1")]
+        [TestCase("![p1](//sample.com/video.mp4)", "<p><iframe src=\"https://example.com/video.mp4\" class=\"regex\" width=\"500\" height=\"281\" frameborder=\"0\"></iframe></p>\n", @"^//sample.com/(.+)$", @"https://example.com/$1")]
+        [TestCase("![p1](https://sample.com/video.mp4)", "<p><iframe src=\"https://example.com/video.mp4?token=aaabbb\" class=\"regex\" width=\"500\" height=\"281\" frameborder=\"0\"></iframe></p>\n", @"^https?://sample.com/(.+)$", @"https://example.com/$1?token=aaabbb")]
+        public void TestCustomHostProvider(string markdown, string expected, string provider, string replace)
         {
-            Class = klass,
-        }));
-        Assert.AreEqual(html, expected);
-    }
+            string html = Markdown.ToHtml(markdown, GetPipeline(new MediaOptions
+            {
+                Hosts =
+                {
+                    new TestHostProvider(provider, replace),
+                }
+            }));
+            Assert.AreEqual(html, expected);
+        }
 
-    [Test]
-    [TestCase("![static mp4](//sample.com/video.mp4)", "<p><video class=\"img-fluid\" width=\"500\" height=\"281\" controls=\"\"><source type=\"video/mp4\" src=\"//sample.com/video.mp4\"></source></video></p>\n")]
-    [TestCase(@"![youtube.com](https://www.youtube.com/watch?v=mswPy5bt3TQ)", "<p><iframe src=\"https://www.youtube.com/embed/mswPy5bt3TQ\" class=\"img-fluid youtube\" width=\"500\" height=\"281\" frameborder=\"0\" allowfullscreen=\"\"></iframe></p>\n")]
-    public void TestWithBootstrap(string markdown, string expected)
-    {
-        string html = Markdown.ToHtml(markdown, GetPipelineWithBootstrap());
-        Assert.AreEqual(html, expected);
+        [Test]
+        [TestCase("![static mp4](//sample.com/video.mp4)", "<p><video width=\"500\" height=\"281\" controls=\"\"><source type=\"video/mp4\" src=\"//sample.com/video.mp4\"></source></video></p>\n", "")]
+        [TestCase(@"![youtube.com](https://www.youtube.com/watch?v=mswPy5bt3TQ)", "<p><iframe src=\"https://www.youtube.com/embed/mswPy5bt3TQ\" class=\"youtube\" width=\"500\" height=\"281\" frameborder=\"0\" allowfullscreen=\"\"></iframe></p>\n", "")]
+        [TestCase("![static mp4](//sample.com/video.mp4)", "<p><video class=\"k\" width=\"500\" height=\"281\" controls=\"\"><source type=\"video/mp4\" src=\"//sample.com/video.mp4\"></source></video></p>\n", "k")]
+        [TestCase(@"![youtube.com](https://www.youtube.com/watch?v=mswPy5bt3TQ)", "<p><iframe src=\"https://www.youtube.com/embed/mswPy5bt3TQ\" class=\"k youtube\" width=\"500\" height=\"281\" frameborder=\"0\" allowfullscreen=\"\"></iframe></p>\n", "k")]
+        public void TestCustomClass(string markdown, string expected, string klass)
+        {
+            string html = Markdown.ToHtml(markdown, GetPipeline(new MediaOptions
+            {
+                Class = klass,
+            }));
+            Assert.AreEqual(html, expected);
+        }
+
+        [Test]
+        [TestCase("![static mp4](//sample.com/video.mp4)", "<p><video class=\"img-fluid\" width=\"500\" height=\"281\" controls=\"\"><source type=\"video/mp4\" src=\"//sample.com/video.mp4\"></source></video></p>\n")]
+        [TestCase(@"![youtube.com](https://www.youtube.com/watch?v=mswPy5bt3TQ)", "<p><iframe src=\"https://www.youtube.com/embed/mswPy5bt3TQ\" class=\"img-fluid youtube\" width=\"500\" height=\"281\" frameborder=\"0\" allowfullscreen=\"\"></iframe></p>\n")]
+        public void TestWithBootstrap(string markdown, string expected)
+        {
+            string html = Markdown.ToHtml(markdown, GetPipelineWithBootstrap());
+            Assert.AreEqual(html, expected);
+        }
     }
 }

src/Markdig.Tests/TestNewLine.cs

@@ -1,28 +1,31 @@
+using System.Linq;
 using Markdig.Syntax;
 using Markdig.Syntax.Inlines;
+using NUnit.Framework;
 
-namespace Markdig.Tests;
-
-[TestFixture]
-public class TestNewLine
+namespace Markdig.Tests
 {
-    [TestCase("a  \nb", "<p>a<br />\nb</p>\n")]
-    [TestCase("a\\\nb", "<p>a<br />\nb</p>\n")]
-    [TestCase("a `b\nc`", "<p>a <code>b c</code></p>\n")]
-    [TestCase("# Text A\nText B\n\n## Text C", "<h1>Text A</h1>\n<p>Text B</p>\n<h2>Text C</h2>\n")]
-    public void Test(string value, string expectedHtml)
+    [TestFixture]
+    public class TestNewLine
     {
-        Assert.AreEqual(expectedHtml, Markdown.ToHtml(value));
-        Assert.AreEqual(expectedHtml, Markdown.ToHtml(value.Replace("\n", "\r\n")));
-    }
+        [TestCase("a  \nb", "<p>a<br />\nb</p>\n")]
+        [TestCase("a\\\nb", "<p>a<br />\nb</p>\n")]
+        [TestCase("a `b\nc`", "<p>a <code>b c</code></p>\n")]
+        [TestCase("# Text A\nText B\n\n## Text C", "<h1>Text A</h1>\n<p>Text B</p>\n<h2>Text C</h2>\n")]
+        public void Test(string value, string expectedHtml)
+        {
+            Assert.AreEqual(expectedHtml, Markdown.ToHtml(value));
+            Assert.AreEqual(expectedHtml, Markdown.ToHtml(value.Replace("\n", "\r\n")));
+        }
 
-    [Test()]
-    public void TestEscapeLineBreak()
-    {
-        var input = "test\\\r\ntest1\r\n";
-        var doc = Markdown.Parse(input);
-        var inlines = doc.Descendants<LineBreakInline>().ToList();
-        Assert.AreEqual(1, inlines.Count, "Invalid number of LineBreakInline");
-        Assert.True(inlines[0].IsBackslash);
+        [Test()]
+        public void TestEscapeLineBreak()
+        {
+            var input = "test\\\r\ntest1\r\n";
+            var doc = Markdown.Parse(input);
+            var inlines = doc.Descendants<LineBreakInline>().ToList();
+            Assert.AreEqual(1, inlines.Count, "Invalid number of LineBreakInline");
+            Assert.True(inlines[0].IsBackslash);
+        }
     }
 }

src/Markdig.Tests/TestNormalize.cs

@@ -2,187 +2,180 @@
 // This file is licensed under the BSD-Clause 2 license.
 // See the license.txt file in the project root for more information.
 
-using Markdig.Helpers;
-using Markdig.Renderers.Normalize;
+using System;
+using NUnit.Framework;
 using Markdig.Syntax;
 using Markdig.Syntax.Inlines;
+using System.IO;
+using Markdig.Renderers.Normalize;
+using Markdig.Helpers;
 
-namespace Markdig.Tests;
-
-[TestFixture]
-public class TestNormalize
+namespace Markdig.Tests
 {
-    [Test]
-    public void SyntaxCodeBlock()
+    [TestFixture]
+    public class TestNormalize
     {
-        AssertSyntax("````csharp\npublic void HelloWorld()\n{\n}\n````", new FencedCodeBlock(null)
+        [Test]
+        public void SyntaxCodeBlock()
         {
-            FencedChar = '`',
-            OpeningFencedCharCount = 4,
-            ClosingFencedCharCount = 4,
-            Info = "csharp",
-            Lines = new StringLineGroup(4)
+            AssertSyntax("````csharp\npublic void HelloWorld()\n{\n}\n````", new FencedCodeBlock(null)
             {
-                new StringSlice("public void HelloWorld()"),
-                new StringSlice("{"),
-                new StringSlice("}"),
-            }
-        });
+                FencedChar = '`',
+                OpeningFencedCharCount = 4,
+                ClosingFencedCharCount = 4,
+                Info = "csharp",
+                Lines = new StringLineGroup(4)
+                {
+                    new StringSlice("public void HelloWorld()"),
+                    new StringSlice("{"),
+                    new StringSlice("}"),
+                }
+            });
 
-        AssertSyntax("    public void HelloWorld()\n    {\n    }", new CodeBlock(null)
-        {
-            Lines = new StringLineGroup(4)
+            AssertSyntax("    public void HelloWorld()\n    {\n    }", new CodeBlock(null)
             {
-                new StringSlice("public void HelloWorld()"),
-                new StringSlice("{"),
-                new StringSlice("}"),
-            }
-        });
-    }
+                Lines = new StringLineGroup(4)
+                {
+                    new StringSlice("public void HelloWorld()"),
+                    new StringSlice("{"),
+                    new StringSlice("}"),
+                }
+            });
+        }
 
-    [Test]
-    public void SyntaxHeadline()
-    {
-        AssertSyntax("## Headline", new HeadingBlock(null)
+        [Test]
+        public void SyntaxHeadline()
         {
-            HeaderChar = '#',
-            Level = 2,
-            Inline = new ContainerInline().AppendChild(new LiteralInline("Headline")),
-        });
-    }
+            AssertSyntax("## Headline", new HeadingBlock(null)
+            {
+                HeaderChar = '#',
+                Level = 2,
+                Inline = new ContainerInline().AppendChild(new LiteralInline("Headline")),
+            });
+        }
 
-    [Test]
-    public void SyntaxHeadlineLevel7()
-    {
-        AssertSyntax("####### Headline", new HeadingBlock(null) {
-            HeaderChar = '#',
-            Level = 7,
-            Inline = new ContainerInline().AppendChild(new LiteralInline("Headline")),
-        });
-    }
-
-    [Test]
-    public void SyntaxParagraph()
-    {
-        AssertSyntax("This is a normal paragraph", new ParagraphBlock()
+        [Test]
+        public void SyntaxParagraph()
         {
-            Inline = new ContainerInline()
-                .AppendChild(new LiteralInline("This is a normal paragraph")),
-        });
+            AssertSyntax("This is a normal paragraph", new ParagraphBlock()
+            {
+                Inline = new ContainerInline()
+                    .AppendChild(new LiteralInline("This is a normal paragraph")),
+            });
 
-        AssertSyntax("This is a\nnormal\nparagraph", new ParagraphBlock()
+            AssertSyntax("This is a\nnormal\nparagraph", new ParagraphBlock()
+            {
+                Inline = new ContainerInline()
+                    .AppendChild(new LiteralInline("This is a"))
+                    .AppendChild(new LineBreakInline())
+                    .AppendChild(new LiteralInline("normal"))
+                    .AppendChild(new LineBreakInline())
+                    .AppendChild(new LiteralInline("paragraph")),
+            });
+        }
+
+        [Test]
+        public void CodeBlock()
         {
-            Inline = new ContainerInline()
-                .AppendChild(new LiteralInline("This is a"))
-                .AppendChild(new LineBreakInline())
-                .AppendChild(new LiteralInline("normal"))
-                .AppendChild(new LineBreakInline())
-                .AppendChild(new LiteralInline("paragraph")),
-        });
-    }
+            AssertNormalizeNoTrim("    public void HelloWorld();\n    {\n    }");
+            AssertNormalizeNoTrim("    public void HelloWorld();\n    {\n    }\n\ntext after two newlines");
+            AssertNormalizeNoTrim("````\npublic void HelloWorld();\n{\n}\n````\n\ntext after two newlines");
+            AssertNormalizeNoTrim("````csharp\npublic void HelloWorld();\n{\n}\n````");
+            AssertNormalizeNoTrim("````csharp hideNewKeyword=true\npublic void HelloWorld();\n{\n}\n````");
+        }
 
-    [Test]
-    public void CodeBlock()
-    {
-        AssertNormalizeNoTrim("    public void HelloWorld();\n    {\n    }");
-        AssertNormalizeNoTrim("    public void HelloWorld();\n    {\n    }\n\ntext after two newlines");
-        AssertNormalizeNoTrim("````\npublic void HelloWorld();\n{\n}\n````\n\ntext after two newlines");
-        AssertNormalizeNoTrim("````csharp\npublic void HelloWorld();\n{\n}\n````");
-        AssertNormalizeNoTrim("````csharp hideNewKeyword=true\npublic void HelloWorld();\n{\n}\n````");
-    }
+        [Test]
+        public void Heading()
+        {
+            AssertNormalizeNoTrim("# Heading");
+            AssertNormalizeNoTrim("## Heading");
+            AssertNormalizeNoTrim("### Heading");
+            AssertNormalizeNoTrim("#### Heading");
+            AssertNormalizeNoTrim("##### Heading");
+            AssertNormalizeNoTrim("###### Heading");
+            AssertNormalizeNoTrim("###### Heading\n\ntext after two newlines");
+            AssertNormalizeNoTrim("# Heading\nAnd Text1\n\nAndText2", options: new NormalizeOptions() { EmptyLineAfterHeading = false });
 
-    [Test]
-    public void Heading()
-    {
-        AssertNormalizeNoTrim("# Heading");
-        AssertNormalizeNoTrim("## Heading");
-        AssertNormalizeNoTrim("### Heading");
-        AssertNormalizeNoTrim("#### Heading");
-        AssertNormalizeNoTrim("##### Heading");
-        AssertNormalizeNoTrim("###### Heading");
-        AssertNormalizeNoTrim("###### Heading\n\ntext after two newlines");
-        AssertNormalizeNoTrim("# Heading\nAnd Text1\n\nAndText2", options: new NormalizeOptions() { EmptyLineAfterHeading = false });
+            AssertNormalizeNoTrim("Heading\n=======\n\ntext after two newlines", "# Heading\n\ntext after two newlines");
+        }
 
-        AssertNormalizeNoTrim("Heading\n=======\n\ntext after two newlines", "# Heading\n\ntext after two newlines");
-    }
+        [Test]
+        public void Backslash()
+        {
+            AssertNormalizeNoTrim("This is a hardline  \nAnd this is another hardline\\\nThis is standard newline");
+            AssertNormalizeNoTrim("This is a line\nWith another line\nAnd a last line");
+        }
 
-    [Test]
-    public void Backslash()
-    {
-        AssertNormalizeNoTrim("This is a hardline  \nAnd this is another hardline\\\nThis is standard newline");
-        AssertNormalizeNoTrim("This is a line\nWith another line\nAnd a last line");
-    }
-
-    [Test]
-    public void HtmlBlock()
-    {
-        /*AssertNormalizeNoTrim(@"<div id=""foo"" class=""bar
-baz"">
+        [Test]
+        public void HtmlBlock()
+        {
+            /*AssertNormalizeNoTrim(@"<div id=""foo"" class=""bar
+  baz"">
 </ div >");*/ // TODO: Bug: Throws Exception during emit
-    }
+        }
 
-    [Test]
-    public void Paragraph()
-    {
-        AssertNormalizeNoTrim("This is a plain paragraph");
-        AssertNormalizeNoTrim(@"This
+        [Test]
+        public void Paragraph()
+        {
+            AssertNormalizeNoTrim("This is a plain paragraph");
+            AssertNormalizeNoTrim(@"This
 is
 a
 plain
 paragraph");
-    }
+        }
 
-    [Test]
-    public void ParagraphMulti()
-    {
-        AssertNormalizeNoTrim(@"line1
+        [Test]
+        public void ParagraphMulti()
+        {
+            AssertNormalizeNoTrim(@"line1
 
 line2
 
 line3");
-    }
+        }
 
-    [Test]
-    public void ListUnordered()
-    {
-        AssertNormalizeNoTrim(@"- a
+        [Test]
+        public void ListUnordered()
+        {
+            AssertNormalizeNoTrim(@"- a
 - b
 - c");
-    }
+        }
 
-    [Test]
-    public void ListUnorderedLoose()
-    {
-        AssertNormalizeNoTrim(@"- a
+        [Test]
+        public void ListUnorderedLoose()
+        {
+            AssertNormalizeNoTrim(@"- a
 
 - b
 
 - c");
-    }
+        }
 
-    [Test]
-    public void ListOrderedLooseAndCodeBlock()
-    {
-        AssertNormalizeNoTrim(@"1. ```
+        [Test]
+        public void ListOrderedLooseAndCodeBlock()
+        {
+            AssertNormalizeNoTrim(@"1. ```
    foo
    ```
    
    bar");
-    }
+        }
 
-    [Test, Ignore("Not sure this is the correct normalize for this one. Need to check the specs")]
-    public void ListUnorderedLooseTop()
-    {
-        AssertNormalizeNoTrim(@"* foo
+        [Test, Ignore("Not sure this is the correct normalize for this one. Need to check the specs")]
+        public void ListUnorderedLooseTop()
+        {
+            AssertNormalizeNoTrim(@"* foo
   * bar
   
   baz", options: new NormalizeOptions() { ListItemCharacter = '*' });
-    }
+        }
 
-    [Test]
-    public void ListUnorderedLooseMultiParagraph()
-    {
-        AssertNormalizeNoTrim(
+        [Test]
+        public void ListUnorderedLooseMultiParagraph()
+        {
+            AssertNormalizeNoTrim(
 @"- a
   
   And another paragraph a
@@ -192,22 +185,22 @@ line3");
   And another paragraph b
 
 - c");
-    }
+        }
 
 
-    [Test]
-    public void ListOrdered()
-    {
-        AssertNormalizeNoTrim(@"1. a
+        [Test]
+        public void ListOrdered()
+        {
+            AssertNormalizeNoTrim(@"1. a
 2. b
 3. c");
-    }
+        }
 
 
-    [Test]
-    public void ListOrderedAndIntended()
-    {
-        AssertNormalizeNoTrim(@"1. a
+        [Test]
+        public void ListOrderedAndIntended()
+        {
+            AssertNormalizeNoTrim(@"1. a
 2. b
    - foo
    - bar
@@ -225,169 +218,169 @@ line3");
     - Bar
 11. c
 12. c");
-    }
+        }
 
-    [Test]
-    public void HeaderAndParagraph()
-    {
-        AssertNormalizeNoTrim(@"# heading
+        [Test]
+        public void HeaderAndParagraph()
+        {
+            AssertNormalizeNoTrim(@"# heading
 
 paragraph
 
 paragraph2 without newlines");
-    }
+        }
 
 
-    [Test]
-    public void QuoteBlock()
-    {
-        AssertNormalizeNoTrim(@"> test1
+        [Test]
+        public void QuoteBlock()
+        {
+            AssertNormalizeNoTrim(@"> test1
 > 
 > test2");
 
-        AssertNormalizeNoTrim(@"> test1
+            AssertNormalizeNoTrim(@"> test1
 This is a continuation
 > test2",
-            @"> test1
+                @"> test1
 > This is a continuation
 > test2"
 );
 
-        AssertNormalizeNoTrim(@"> test1
+            AssertNormalizeNoTrim(@"> test1
 > -foobar
 
 asdf
 
 > test2
 > -foobar sen.");
-    }
+        }
 
-    [Test]
-    public void ThematicBreak()
-    {
-        AssertNormalizeNoTrim("***\n");
+        [Test]
+        public void ThematicBreak()
+        {
+            AssertNormalizeNoTrim("***\n");
 
-        AssertNormalizeNoTrim("* * *\n", "***\n");
-    }
+            AssertNormalizeNoTrim("* * *\n", "***\n");
+        }
 
-    [Test]
-    public void AutolinkInline()
-    {
-        AssertNormalizeNoTrim("This has a <auto.link.com>");
-    }
+        [Test]
+        public void AutolinkInline()
+        {
+            AssertNormalizeNoTrim("This has a <auto.link.com>");
+        }
 
-    [Test]
-    public void CodeInline()
-    {
-        AssertNormalizeNoTrim("This has a ` ` in it");
-        AssertNormalizeNoTrim("This has a `HelloWorld()` in it");
-        AssertNormalizeNoTrim(@"This has a ``Hello`World()`` in it");
-        AssertNormalizeNoTrim(@"This has a ``` Hello`World() ``` in it", @"This has a ``Hello`World()`` in it");
-        AssertNormalizeNoTrim(@"This has a ``Hello`World()` `` in it");
-        AssertNormalizeNoTrim(@"This has a ```` ``Hello```World()` ```` in it");
-        AssertNormalizeNoTrim(@"This has a `` `Hello`World()`` in it");
-        AssertNormalizeNoTrim(@"This has a ``` ``Hello`World()` ``` in it");
-    }
+        [Test]
+        public void CodeInline()
+        {
+            AssertNormalizeNoTrim("This has a ` ` in it");
+            AssertNormalizeNoTrim("This has a `HelloWorld()` in it");
+            AssertNormalizeNoTrim(@"This has a ``Hello`World()`` in it");
+            AssertNormalizeNoTrim(@"This has a ``` Hello`World() ``` in it", @"This has a ``Hello`World()`` in it");
+            AssertNormalizeNoTrim(@"This has a ``Hello`World()` `` in it");
+            AssertNormalizeNoTrim(@"This has a ```` ``Hello```World()` ```` in it");
+            AssertNormalizeNoTrim(@"This has a `` `Hello`World()`` in it");
+            AssertNormalizeNoTrim(@"This has a ``` ``Hello`World()` ``` in it");
+        }
 
-    [Test]
-    public void EmphasisInline()
-    {
-        AssertNormalizeNoTrim("This is a plain **paragraph**");
-        AssertNormalizeNoTrim("This is a plain *paragraph*");
-        AssertNormalizeNoTrim("This is a plain _paragraph_");
-        AssertNormalizeNoTrim("This is a plain __paragraph__");
-        AssertNormalizeNoTrim("This is a pl*ai*n **paragraph**");
-    }
+        [Test]
+        public void EmphasisInline()
+        {
+            AssertNormalizeNoTrim("This is a plain **paragraph**");
+            AssertNormalizeNoTrim("This is a plain *paragraph*");
+            AssertNormalizeNoTrim("This is a plain _paragraph_");
+            AssertNormalizeNoTrim("This is a plain __paragraph__");
+            AssertNormalizeNoTrim("This is a pl*ai*n **paragraph**");
+        }
 
-    [Test]
-    public void LineBreakInline()
-    {
-        AssertNormalizeNoTrim("normal\nline break");
-        AssertNormalizeNoTrim("hard  \nline break");
-        AssertNormalizeNoTrim("This is a hardline  \nAnd this is another hardline\\\nThis is standard newline");
-        AssertNormalizeNoTrim("This is a line\nWith another line\nAnd a last line");
-    }
+        [Test]
+        public void LineBreakInline()
+        {
+            AssertNormalizeNoTrim("normal\nline break");
+            AssertNormalizeNoTrim("hard  \nline break");
+            AssertNormalizeNoTrim("This is a hardline  \nAnd this is another hardline\\\nThis is standard newline");
+            AssertNormalizeNoTrim("This is a line\nWith another line\nAnd a last line");
+        }
 
-    [Test]
-    public void LinkInline()
-    {
-        AssertNormalizeNoTrim("This is a [link](http://company.com)");
-        AssertNormalizeNoTrim("This is an ![image](http://company.com)");
+        [Test]
+        public void LinkInline()
+        {
+            AssertNormalizeNoTrim("This is a [link](http://company.com)");
+            AssertNormalizeNoTrim("This is an ![image](http://company.com)");
 
-        AssertNormalizeNoTrim(@"This is a [link](http://company.com ""Crazy Company"")");
-        AssertNormalizeNoTrim(@"This is a [link](http://company.com ""Crazy \"" Company"")");
-    }
+            AssertNormalizeNoTrim(@"This is a [link](http://company.com ""Crazy Company"")");
+            AssertNormalizeNoTrim(@"This is a [link](http://company.com ""Crazy \"" Company"")");
+        }
 
-    [Test]
-    public void LinkReferenceDefinition()
-    {
-        // Full link
-        AssertNormalizeNoTrim("This is a [link][MyLink]\n\n[MyLink]: http://company.com");
+        [Test]
+        public void LinkReferenceDefinition()
+        {
+            // Full link
+            AssertNormalizeNoTrim("This is a [link][MyLink]\n\n[MyLink]: http://company.com");
 
-        AssertNormalizeNoTrim("[MyLink]: http://company.com\nThis is a [link][MyLink]",
-            "This is a [link][MyLink]\n\n[MyLink]: http://company.com");
+            AssertNormalizeNoTrim("[MyLink]: http://company.com\nThis is a [link][MyLink]",
+                "This is a [link][MyLink]\n\n[MyLink]: http://company.com");
 
-        AssertNormalizeNoTrim("This is a [link][MyLink] a normal link [link](http://google.com) and another def link [link2][MyLink2]\n\n[MyLink]: http://company.com\n[MyLink2]: http://company2.com");
+            AssertNormalizeNoTrim("This is a [link][MyLink] a normal link [link](http://google.com) and another def link [link2][MyLink2]\n\n[MyLink]: http://company.com\n[MyLink2]: http://company2.com");
 
-        // Collapsed link
-        AssertNormalizeNoTrim("This is a [link][]\n\n[link]: http://company.com");
+            // Collapsed link
+            AssertNormalizeNoTrim("This is a [link][]\n\n[link]: http://company.com");
 
-        // Shortcut link
-        AssertNormalizeNoTrim("This is a [link]\n\n[link]: http://company.com");
-    }
+            // Shortcut link
+            AssertNormalizeNoTrim("This is a [link]\n\n[link]: http://company.com");
+        }
 
-    [Test]
-    public void EscapeInline()
-    {
-        AssertNormalizeNoTrim("This is an escape \\* with another \\[");
-    }
+        [Test]
+        public void EscapeInline()
+        {
+            AssertNormalizeNoTrim("This is an escape \\* with another \\[");
+        }
 
-    [Test]
-    public void HtmlEntityInline()
-    {
-        AssertNormalizeNoTrim("This is a &auml; blank");
-    }
+        [Test]
+        public void HtmlEntityInline()
+        {
+            AssertNormalizeNoTrim("This is a &auml; blank");
+        }
 
-    [Test]
-    public void HtmlInline()
-    {
-        AssertNormalizeNoTrim("foo <hr/> bar");
-        AssertNormalizeNoTrim(@"foo <hr foo=""bar""/> bar");
-    }
+        [Test]
+        public void HtmlInline()
+        {
+            AssertNormalizeNoTrim("foo <hr/> bar");
+            AssertNormalizeNoTrim(@"foo <hr foo=""bar""/> bar");
+        }
 
 
-    [Test]
-    public void SpaceBetweenNodes()
-    {
-        AssertNormalizeNoTrim("# Hello World\nFoobar is a better bar.",
-                              "# Hello World\n\nFoobar is a better bar.");
-    }
+        [Test]
+        public void SpaceBetweenNodes()
+        {
+            AssertNormalizeNoTrim("# Hello World\nFoobar is a better bar.",
+                                  "# Hello World\n\nFoobar is a better bar.");
+        }
 
-    [Test]
-    public void SpaceBetweenNodesEvenForHeadlines()
-    {
-        AssertNormalizeNoTrim("# Hello World\n## Chapter 1\nFoobar is a better bar.",
-                              "# Hello World\n\n## Chapter 1\n\nFoobar is a better bar.");
-    }
+        [Test]
+        public void SpaceBetweenNodesEvenForHeadlines()
+        {
+            AssertNormalizeNoTrim("# Hello World\n## Chapter 1\nFoobar is a better bar.",
+                                  "# Hello World\n\n## Chapter 1\n\nFoobar is a better bar.");
+        }
 
-    [Test]
-    public void SpaceRemoveAtStartAndEnd()
-    {
-        AssertNormalizeNoTrim("\n\n# Hello World\n## Chapter 1\nFoobar is a better bar.\n\n",
-                              "# Hello World\n\n## Chapter 1\n\nFoobar is a better bar.");
-    }
+        [Test]
+        public void SpaceRemoveAtStartAndEnd()
+        {
+            AssertNormalizeNoTrim("\n\n# Hello World\n## Chapter 1\nFoobar is a better bar.\n\n",
+                                  "# Hello World\n\n## Chapter 1\n\nFoobar is a better bar.");
+        }
 
-    [Test]
-    public void SpaceShortenBetweenNodes()
-    {
-        AssertNormalizeNoTrim("# Hello World\n\n\n\nFoobar is a better bar.",
-                              "# Hello World\n\nFoobar is a better bar.");
-    }
+        [Test]
+        public void SpaceShortenBetweenNodes()
+        {
+            AssertNormalizeNoTrim("# Hello World\n\n\n\nFoobar is a better bar.",
+                                  "# Hello World\n\nFoobar is a better bar.");
+        }
 
-    [Test]
-    public void BiggerSample()
-    {
-        var input = @"# Heading 1
+        [Test]
+        public void BiggerSample()
+        {
+            var input = @"# Heading 1
 
 This is a paragraph
 
@@ -407,99 +400,100 @@ This is a code block
     line 2 of indented
 
 This is a last line";
-        AssertNormalizeNoTrim(input);
-    }
-
-    [Test]
-    public void TaskLists()
-    {
-        AssertNormalizeNoTrim("- [X] This is done");
-        AssertNormalizeNoTrim("- [x] This is done",
-                              "- [X] This is done");
-        AssertNormalizeNoTrim("- [ ] This is not done");
-
-        // ignore
-        AssertNormalizeNoTrim("[x] This is not a task list");
-        AssertNormalizeNoTrim("[ ] This is not a task list");
-    }
-
-    [Test]
-    public void JiraLinks()
-    {
-        AssertNormalizeNoTrim("FOO-1234");
-        AssertNormalizeNoTrim("AB-1");
-
-        AssertNormalizeNoTrim("**Hello World AB-1**");
-    }
-
-    [Test]
-    public void AutoLinks()
-    {
-        AssertNormalizeNoTrim("Hello from http://example.com/foo", "Hello from [http://example.com/foo](http://example.com/foo)", new NormalizeOptions() { ExpandAutoLinks = true, });
-        AssertNormalizeNoTrim("Hello from www.example.com/foo", "Hello from [www.example.com/foo](http://www.example.com/foo)", new NormalizeOptions() { ExpandAutoLinks = true, });
-        AssertNormalizeNoTrim("Hello from ftp://example.com", "Hello from [ftp://example.com](ftp://example.com)", new NormalizeOptions() { ExpandAutoLinks = true, });
-        AssertNormalizeNoTrim("Hello from mailto:hello@example.com", "Hello from [hello@example.com](mailto:hello@example.com)", new NormalizeOptions() { ExpandAutoLinks = true, });
-
-        AssertNormalizeNoTrim("Hello from http://example.com/foo", "Hello from http://example.com/foo", new NormalizeOptions() { ExpandAutoLinks = false, });
-        AssertNormalizeNoTrim("Hello from www.example.com/foo", "Hello from http://www.example.com/foo", new NormalizeOptions() { ExpandAutoLinks = false, });
-        AssertNormalizeNoTrim("Hello from mailto:hello@example.com", "Hello from mailto:hello@example.com", new NormalizeOptions() { ExpandAutoLinks = false, });
-    }
-
-    private static void AssertSyntax(string expected, MarkdownObject syntax)
-    {
-        var writer = new StringWriter();
-        var normalizer = new NormalizeRenderer(writer);
-        var document = new MarkdownDocument();
-        if (syntax is Block)
-        {
-            document.Add(syntax as Block);
+            AssertNormalizeNoTrim(input);
         }
-        else
+
+        [Test]
+        public void TaskLists()
         {
-            throw new InvalidOperationException();
+            AssertNormalizeNoTrim("- [X] This is done");
+            AssertNormalizeNoTrim("- [x] This is done",
+                                  "- [X] This is done");
+            AssertNormalizeNoTrim("- [ ] This is not done");
+
+            // ignore
+            AssertNormalizeNoTrim("[x] This is not a task list");
+            AssertNormalizeNoTrim("[ ] This is not a task list");
         }
-        normalizer.Render(document);
 
-        var actual = writer.ToString();
-
-        Assert.AreEqual(expected, actual);
-    }
-
-    public static void TestSpec(string inputText, string expectedOutputText, string extensions = null, string context = null)
-    {
-        foreach (var pipeline in TestParser.GetPipeline(extensions))
+        [Test]
+        public void JiraLinks()
         {
-            AssertNormalize(inputText, expectedOutputText, trim: false, pipeline: pipeline.Value, context: context);
+            AssertNormalizeNoTrim("FOO-1234");
+            AssertNormalizeNoTrim("AB-1");
+
+            AssertNormalizeNoTrim("**Hello World AB-1**");
         }
-    }
 
-    public static void AssertNormalizeNoTrim(string input, string expected = null, NormalizeOptions options = null)
-        => AssertNormalize(input, expected, false, options);
-
-    public static void AssertNormalize(string input, string expected = null, bool trim = true, NormalizeOptions options = null, MarkdownPipeline pipeline = null, string context = null)
-    {
-        expected = expected ?? input;
-        input = NormText(input, trim);
-        expected = NormText(expected, trim);
-
-        pipeline = pipeline ?? new MarkdownPipelineBuilder()
-            .UseAutoLinks()
-            .UseJiraLinks(new Extensions.JiraLinks.JiraLinkOptions("https://jira.example.com"))
-            .UseTaskLists()
-            .Build();
-
-        var result = Markdown.Normalize(input, options, pipeline: pipeline);
-        result = NormText(result, trim);
-
-        TestParser.PrintAssertExpected(input, result, expected, context);
-    }
-
-    private static string NormText(string text, bool trim)
-    {
-        if (trim)
+        [Test]
+        public void AutoLinks()
         {
-            text = text.Trim();
+            AssertNormalizeNoTrim("Hello from http://example.com/foo", "Hello from [http://example.com/foo](http://example.com/foo)", new NormalizeOptions() { ExpandAutoLinks = true, });
+            AssertNormalizeNoTrim("Hello from www.example.com/foo", "Hello from [www.example.com/foo](http://www.example.com/foo)", new NormalizeOptions() { ExpandAutoLinks = true, });
+            AssertNormalizeNoTrim("Hello from ftp://example.com", "Hello from [ftp://example.com](ftp://example.com)", new NormalizeOptions() { ExpandAutoLinks = true, });
+            AssertNormalizeNoTrim("Hello from mailto:hello@example.com", "Hello from [hello@example.com](mailto:hello@example.com)", new NormalizeOptions() { ExpandAutoLinks = true, });
+
+            AssertNormalizeNoTrim("Hello from http://example.com/foo", "Hello from http://example.com/foo", new NormalizeOptions() { ExpandAutoLinks = false, });
+            AssertNormalizeNoTrim("Hello from www.example.com/foo", "Hello from http://www.example.com/foo", new NormalizeOptions() { ExpandAutoLinks = false, });
+            AssertNormalizeNoTrim("Hello from mailto:hello@example.com", "Hello from mailto:hello@example.com", new NormalizeOptions() { ExpandAutoLinks = false, });
+        }
+
+        private static void AssertSyntax(string expected, MarkdownObject syntax)
+        {
+            var writer = new StringWriter();
+            var normalizer = new NormalizeRenderer(writer);
+            var document = new MarkdownDocument();
+            if (syntax is Block)
+            {
+                document.Add(syntax as Block);
+            }
+            else
+            {
+                throw new InvalidOperationException();
+            }
+            normalizer.Render(document);
+
+            var actual = writer.ToString();
+
+            Assert.AreEqual(expected, actual);
+        }
+
+        public static void TestSpec(string inputText, string expectedOutputText, string extensions = null, string context = null)
+        {
+            foreach (var pipeline in TestParser.GetPipeline(extensions))
+            {
+                AssertNormalize(inputText, expectedOutputText, trim: false, pipeline: pipeline.Value, context: context);
+            }
+        }
+
+        public static void AssertNormalizeNoTrim(string input, string expected = null, NormalizeOptions options = null)
+            => AssertNormalize(input, expected, false, options);
+
+        public static void AssertNormalize(string input, string expected = null, bool trim = true, NormalizeOptions options = null, MarkdownPipeline pipeline = null, string context = null)
+        {
+            expected = expected ?? input;
+            input = NormText(input, trim);
+            expected = NormText(expected, trim);
+
+            pipeline = pipeline ?? new MarkdownPipelineBuilder()
+                .UseAutoLinks()
+                .UseJiraLinks(new Extensions.JiraLinks.JiraLinkOptions("https://jira.example.com"))
+                .UseTaskLists()
+                .Build();
+
+            var result = Markdown.Normalize(input, options, pipeline: pipeline);
+            result = NormText(result, trim);
+
+            TestParser.PrintAssertExpected(input, result, expected, context);
+        }
+
+        private static string NormText(string text, bool trim)
+        {
+            if (trim)
+            {
+                text = text.Trim();
+            }
+            return text.Replace("\r\n", "\n").Replace('\r', '\n');
         }
-        return text.Replace("\r\n", "\n").Replace('\r', '\n');
     }
 }

src/Markdig.Tests/TestOrderedList.cs

@@ -1,41 +1,43 @@
-// Copyright (c) Alexandre Mutel. All rights reserved.
+// Copyright (c) Alexandre Mutel. All rights reserved.
 // This file is licensed under the BSD-Clause 2 license. 
 // See the license.txt file in the project root for more information.
 
 using Markdig.Helpers;
+using NUnit.Framework;
 
-namespace Markdig.Tests;
-
-[TestFixture]
-public class TestOrderedList
+namespace Markdig.Tests
 {
-    [Test]
-    public void TestReplace()
+    [TestFixture]
+    public class TestOrderedList
     {
-        var list = new OrderedList<ITest>
+        [Test]
+        public void TestReplace()
         {
-            new A(),
-            new B(),
-            new C(),
-        };
+            var list = new OrderedList<ITest>
+            {
+                new A(),
+                new B(),
+                new C(),
+            };
 
-        // Replacing B with D. Order should now be A, D, B.
-        var result = list.Replace<B>(new D());
-        Assert.That(result, Is.True);
-        Assert.That(list.Count, Is.EqualTo(3));
-        Assert.That(list[0], Is.InstanceOf<A>());
-        Assert.That(list[1], Is.InstanceOf<D>());
-        Assert.That(list[2], Is.InstanceOf<C>());
+            // Replacing B with D. Order should now be A, D, B.
+            var result = list.Replace<B>(new D());
+            Assert.That(result, Is.True);
+            Assert.That(list.Count, Is.EqualTo(3));
+            Assert.That(list[0], Is.InstanceOf<A>());
+            Assert.That(list[1], Is.InstanceOf<D>());
+            Assert.That(list[2], Is.InstanceOf<C>());
 
-        // Replacing B again should fail, as it's no longer in the list.
-        Assert.That(list.Replace<B>(new D()), Is.False);
+            // Replacing B again should fail, as it's no longer in the list.
+            Assert.That(list.Replace<B>(new D()), Is.False);
+        }
+
+        #region Test fixtures
+        private interface ITest { }
+        private class A : ITest { }
+        private class B : ITest { }
+        private class C : ITest { }
+        private class D : ITest { }
+        #endregion
     }
-
-    #region Test fixtures
-    private interface ITest { }
-    private class A : ITest { }
-    private class B : ITest { }
-    private class C : ITest { }
-    private class D : ITest { }
-    #endregion
 }

src/Markdig.Tests/TestParser.cs

@@ -1,196 +1,191 @@
 // Copyright (c) Alexandre Mutel. All rights reserved.
 // This file is licensed under the BSD-Clause 2 license.
 // See the license.txt file in the project root for more information.
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
 using System.Text;
 using System.Text.RegularExpressions;
-
 using Markdig.Extensions.JiraLinks;
-using Markdig.Renderers.Roundtrip;
 using Markdig.Syntax;
+using NUnit.Framework;
 
-namespace Markdig.Tests;
-
-public class TestParser
+namespace Markdig.Tests
 {
-    [Test]
-    public void EnsureSpecsAreUpToDate()
+    public class TestParser
     {
-        // In CI, SpecFileGen is guaranteed to run
-        if (IsContinuousIntegration)
-            return;
-
-        var specsFilePaths = Directory.GetDirectories(TestsDirectory)
-            .Where(dir => dir.EndsWith("Specs"))
-            .SelectMany(dir => Directory.GetFiles(dir)
-                .Where(file => file.EndsWith(".md", StringComparison.OrdinalIgnoreCase))
-                .Where(file => file.IndexOf("readme", StringComparison.OrdinalIgnoreCase) == -1))
-            .ToArray();
-
-        var specsMarkdown = new string[specsFilePaths.Length];
-        var specsSyntaxTrees = new MarkdownDocument[specsFilePaths.Length];
-
-        var pipeline = new MarkdownPipelineBuilder()
-            .UseAdvancedExtensions()
-            .Build();
-
-        for (int i = 0; i < specsFilePaths.Length; i++)
+        [Test]
+        public void EnsureSpecsAreUpToDate()
         {
-            string markdown = specsMarkdown[i] = File.ReadAllText(specsFilePaths[i]);
-            specsSyntaxTrees[i] = Markdown.Parse(markdown, pipeline);
-        }
+            // In CI, SpecFileGen is guaranteed to run
+            if (IsContinuousIntegration)
+                return;
 
-        foreach (var specFilePath in specsFilePaths)
-        {
-            string testFilePath = Path.ChangeExtension(specFilePath, ".generated.cs");
+            var specsFilePaths = Directory.GetDirectories(TestsDirectory)
+                .Where(dir => dir.EndsWith("Specs"))
+                .SelectMany(dir => Directory.GetFiles(dir)
+                    .Where(file => file.EndsWith(".md", StringComparison.OrdinalIgnoreCase))
+                    .Where(file => file.IndexOf("readme", StringComparison.OrdinalIgnoreCase) == -1))
+                .ToArray();
 
-            Assert.True(File.Exists(testFilePath),
-                "A new specification file has been added. Add the spec to the list in SpecFileGen and regenerate the tests.");
+            var specsMarkdown = new string[specsFilePaths.Length];
+            var specsSyntaxTrees = new MarkdownDocument[specsFilePaths.Length];
 
-            DateTime specTime = File.GetLastWriteTimeUtc(specFilePath);
-            DateTime testTime = File.GetLastWriteTimeUtc(testFilePath);
+            var pipeline = new MarkdownPipelineBuilder()
+                .UseAdvancedExtensions()
+                .Build();
 
-            // If file creation times aren't preserved by git, add some leeway
-            // If specs have come from git, assume that they were regenerated since CI would fail otherwise
-            testTime = testTime.AddMinutes(3);
-
-            // This might not catch a changed spec every time, but should at least sometimes. Otherwise CI will catch it
-
-            // This could also trigger, if a user has modified the spec file but reverted the change - can't think of a good workaround
-            Assert.Less(specTime, testTime,
-                $"{Path.GetFileName(specFilePath)} has been modified. Run SpecFileGen to regenerate the tests. " +
-                "If you have modified a specification file, but reverted all changes, ignore this error or revert the 'changed' timestamp metadata on the file.");
-        }
-
-        TestDescendantsOrder.TestSchemas(specsSyntaxTrees);
-    }
-
-    [Test]
-    public void ParseEmptyDocumentWithTrackTriviaEnabled()
-    {
-        var document = Markdown.Parse("", trackTrivia: true);
-        using var sw = new StringWriter();
-        new RoundtripRenderer(sw).Render(document);
-        Assert.AreEqual("", sw.ToString());
-    }
-
-    public static void TestSpec(string inputText, string expectedOutputText, string extensions = null, bool plainText = false, string context = null)
-    {
-        context ??= string.Empty;
-        if (!string.IsNullOrEmpty(context))
-        {
-            context += "\n";
-        }
-        foreach (var pipeline in GetPipeline(extensions))
-        {
-            TestSpec(inputText, expectedOutputText, pipeline.Value, plainText, context: context + $"Pipeline configured with extensions: {pipeline.Key}");
-        }
-    }
-
-    public static void TestSpec(string inputText, string expectedOutputText, MarkdownPipeline pipeline, bool plainText = false, string context = null)
-    {
-        // Uncomment this line to get more debug information for process inlines.
-        //pipeline.DebugLog = Console.Out;
-        var result = plainText ? Markdown.ToPlainText(inputText, pipeline) : Markdown.ToHtml(inputText, pipeline);
-
-        result = Compact(result);
-        expectedOutputText = Compact(expectedOutputText);
-
-        PrintAssertExpected(inputText, result, expectedOutputText, context);
-    }
-
-    public static void PrintAssertExpected(string source, string result, string expected, string context = null)
-    {
-        if (expected != result)
-        {
-            if (context != null)
+            for (int i = 0; i < specsFilePaths.Length; i++)
             {
-                Console.WriteLine(context);
+                string markdown = specsMarkdown[i] = File.ReadAllText(specsFilePaths[i]);
+                specsSyntaxTrees[i] = Markdown.Parse(markdown, pipeline);
             }
-            Console.WriteLine("```````````````````Source");
-            Console.WriteLine(DisplaySpaceAndTabs(source));
-            Console.WriteLine("```````````````````Result");
-            Console.WriteLine(DisplaySpaceAndTabs(result));
-            Console.WriteLine("```````````````````Expected");
-            Console.WriteLine(DisplaySpaceAndTabs(expected));
-            Console.WriteLine("```````````````````");
-            Console.WriteLine();
-            TextAssert.AreEqual(expected, result);
-        }
-    }
 
-    public static IEnumerable<KeyValuePair<string, MarkdownPipeline>> GetPipeline(string extensionsGroupText)
-    {
-        // For the standard case, we make sure that both the CommmonMark core and Extra/Advanced are CommonMark compliant!
-        if (string.IsNullOrEmpty(extensionsGroupText))
-        {
-            yield return new KeyValuePair<string, MarkdownPipeline>("default", new MarkdownPipelineBuilder().Build());
-
-            //yield return new KeyValuePair<string, MarkdownPipeline>("default-trivia", new MarkdownPipelineBuilder().EnableTrackTrivia().Build());
-
-            yield return new KeyValuePair<string, MarkdownPipeline>("advanced", new MarkdownPipelineBuilder()  // Use similar to advanced extension without auto-identifier
-             .UseAbbreviations()
-            //.UseAutoIdentifiers()
-            .UseCitations()
-            .UseCustomContainers()
-            .UseDefinitionLists()
-            .UseEmphasisExtras()
-            .UseFigures()
-            .UseFooters()
-            .UseFootnotes()
-            .UseGridTables()
-            .UseMathematics()
-            .UseMediaLinks()
-            .UsePipeTables()
-            .UseListExtras()
-            .UseGenericAttributes().Build());
-
-            yield break;
-        }
-
-        var extensionGroups = extensionsGroupText.Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
-        foreach (var extensionsText in extensionGroups)
-        {
-            var builder = new MarkdownPipelineBuilder();
-            builder.DebugLog = Console.Out;
-            if (extensionsText == "jiralinks")
+            foreach (var specFilePath in specsFilePaths)
             {
-                builder.UseJiraLinks(new JiraLinkOptions("http://your.company.abc"));
+                string testFilePath = Path.ChangeExtension(specFilePath, ".generated.cs");
+
+                Assert.True(File.Exists(testFilePath),
+                    "A new specification file has been added. Add the spec to the list in SpecFileGen and regenerate the tests.");
+
+                DateTime specTime = File.GetLastWriteTimeUtc(specFilePath);
+                DateTime testTime = File.GetLastWriteTimeUtc(testFilePath);
+
+                // If file creation times aren't preserved by git, add some leeway
+                // If specs have come from git, assume that they were regenerated since CI would fail otherwise
+                testTime = testTime.AddMinutes(3);
+
+                // This might not catch a changed spec every time, but should at least sometimes. Otherwise CI will catch it
+
+                // This could also trigger, if a user has modified the spec file but reverted the change - can't think of a good workaround
+                Assert.Less(specTime, testTime,
+                    $"{Path.GetFileName(specFilePath)} has been modified. Run SpecFileGen to regenerate the tests. " +
+                    "If you have modified a specification file, but reverted all changes, ignore this error or revert the 'changed' timestamp metadata on the file.");
             }
-            else
-            {
-                builder = extensionsText == "self" ? builder.UseSelfPipeline() : builder.Configure(extensionsText);
-            }
-            yield return new KeyValuePair<string, MarkdownPipeline>(extensionsText, builder.Build());
+
+            TestDescendantsOrder.TestSchemas(specsSyntaxTrees);
         }
-    }
 
-    public static string DisplaySpaceAndTabs(string text)
-    {
-        // Output special characters to check correctly the results
-        return text.Replace('\t', '→').Replace(' ', '·');
-    }
-
-    private static string Compact(string html)
-    {
-        // Normalize the output to make it compatible with CommonMark specs
-        html = html.Replace("\r\n", "\n").Replace(@"\r", @"\n").Trim();
-        html = Regex.Replace(html, @"\s+</li>", "</li>");
-        html = Regex.Replace(html, @"<li>\s+", "<li>");
-        html = html.Normalize(NormalizationForm.FormKD);
-        return html;
-    }
-
-    public static readonly bool IsContinuousIntegration = Environment.GetEnvironmentVariable("CI") != null;
-
-    public static readonly string TestsDirectory = Path.GetFullPath(Path.Combine(Path.GetDirectoryName(typeof(TestParser).Assembly.Location), "../../.."));
-
-    static TestParser()
-    {
-        const string RunningInsideVisualStudioPath = "\\src\\.vs\\markdig\\";
-        int index = TestsDirectory.IndexOf(RunningInsideVisualStudioPath);
-        if (index != -1)
+        public static void TestSpec(string inputText, string expectedOutputText, string extensions = null, bool plainText = false, string context = null)
         {
-            TestsDirectory = TestsDirectory.Substring(0, index) + "\\src\\Markdig.Tests";
+            context ??= string.Empty;
+            if (!string.IsNullOrEmpty(context))
+            {
+                context += "\n";
+            }
+            foreach (var pipeline in GetPipeline(extensions))
+            {
+                TestSpec(inputText, expectedOutputText, pipeline.Value, plainText, context: context + $"Pipeline configured with extensions: {pipeline.Key}");
+            }
+        }
+
+        public static void TestSpec(string inputText, string expectedOutputText, MarkdownPipeline pipeline, bool plainText = false, string context = null)
+        {
+            // Uncomment this line to get more debug information for process inlines.
+            //pipeline.DebugLog = Console.Out;
+            var result = plainText ? Markdown.ToPlainText(inputText, pipeline) : Markdown.ToHtml(inputText, pipeline);
+
+            result = Compact(result);
+            expectedOutputText = Compact(expectedOutputText);
+
+            PrintAssertExpected(inputText, result, expectedOutputText, context);
+        }
+
+        public static void PrintAssertExpected(string source, string result, string expected, string context = null)
+        {
+            if (expected != result)
+            {
+                if (context != null)
+                {
+                    Console.WriteLine(context);
+                }
+                Console.WriteLine("```````````````````Source");
+                Console.WriteLine(DisplaySpaceAndTabs(source));
+                Console.WriteLine("```````````````````Result");
+                Console.WriteLine(DisplaySpaceAndTabs(result));
+                Console.WriteLine("```````````````````Expected");
+                Console.WriteLine(DisplaySpaceAndTabs(expected));
+                Console.WriteLine("```````````````````");
+                Console.WriteLine();
+                TextAssert.AreEqual(expected, result);
+            }
+        }
+
+        public static IEnumerable<KeyValuePair<string, MarkdownPipeline>> GetPipeline(string extensionsGroupText)
+        {
+            // For the standard case, we make sure that both the CommmonMark core and Extra/Advanced are CommonMark compliant!
+            if (string.IsNullOrEmpty(extensionsGroupText))
+            {
+                yield return new KeyValuePair<string, MarkdownPipeline>("default", new MarkdownPipelineBuilder().Build());
+
+                //yield return new KeyValuePair<string, MarkdownPipeline>("default-trivia", new MarkdownPipelineBuilder().EnableTrackTrivia().Build());
+
+                yield return new KeyValuePair<string, MarkdownPipeline>("advanced", new MarkdownPipelineBuilder()  // Use similar to advanced extension without auto-identifier
+                 .UseAbbreviations()
+                //.UseAutoIdentifiers()
+                .UseCitations()
+                .UseCustomContainers()
+                .UseDefinitionLists()
+                .UseEmphasisExtras()
+                .UseFigures()
+                .UseFooters()
+                .UseFootnotes()
+                .UseGridTables()
+                .UseMathematics()
+                .UseMediaLinks()
+                .UsePipeTables()
+                .UseListExtras()
+                .UseGenericAttributes().Build());
+
+                yield break;
+            }
+
+            var extensionGroups = extensionsGroupText.Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
+            foreach (var extensionsText in extensionGroups)
+            {
+                var builder = new MarkdownPipelineBuilder();
+                builder.DebugLog = Console.Out;
+                if (extensionsText == "jiralinks")
+                {
+                    builder.UseJiraLinks(new JiraLinkOptions("http://your.company.abc"));
+                }
+                else
+                {
+                    builder = extensionsText == "self" ? builder.UseSelfPipeline() : builder.Configure(extensionsText);
+                }
+                yield return new KeyValuePair<string, MarkdownPipeline>(extensionsText, builder.Build());
+            }
+        }
+
+        public static string DisplaySpaceAndTabs(string text)
+        {
+            // Output special characters to check correctly the results
+            return text.Replace('\t', '→').Replace(' ', '·');
+        }
+
+        private static string Compact(string html)
+        {
+            // Normalize the output to make it compatible with CommonMark specs
+            html = html.Replace("\r\n", "\n").Replace(@"\r", @"\n").Trim();
+            html = Regex.Replace(html, @"\s+</li>", "</li>");
+            html = Regex.Replace(html, @"<li>\s+", "<li>");
+            html = html.Normalize(NormalizationForm.FormKD);
+            return html;
+        }
+
+        public static readonly bool IsContinuousIntegration = Environment.GetEnvironmentVariable("CI") != null;
+
+        public static readonly string TestsDirectory = Path.GetFullPath(Path.Combine(Path.GetDirectoryName(typeof(TestParser).Assembly.Location), "../../.."));
+
+        static TestParser()
+        {
+            const string RunningInsideVisualStudioPath = "\\src\\.vs\\markdig\\";
+            int index = TestsDirectory.IndexOf(RunningInsideVisualStudioPath);
+            if (index != -1)
+            {
+                TestsDirectory = TestsDirectory.Substring(0, index) + "\\src\\Markdig.Tests";
+            }
         }
     }
 }

src/Markdig.Tests/TestPipeTable.cs

@@ -1,60 +1,26 @@
 using Markdig.Extensions.Tables;
 using Markdig.Syntax;
+using NUnit.Framework;
+using System.Linq;
 
-namespace Markdig.Tests;
-
-[TestFixture]
-public sealed class TestPipeTable
+namespace Markdig.Tests
 {
-    [TestCase("| S | T |\r\n|---|---| \r\n| G | H |")]
-    [TestCase("| S | T |\r\n|---|---|\t\r\n| G | H |")]
-    [TestCase("| S | T |\r\n|---|---|\f\r\n| G | H |")]
-    [TestCase("| S | \r\n|---|\r\n| G |\r\n\r\n| D | D |\r\n| ---| ---| \r\n| V | V |", 2)]
-    [TestCase("a\r| S | T |\r|---|---|")]
-    [TestCase("a\n| S | T |\r|---|---|")]
-    public void TestTableBug(string markdown, int tableCount = 1)
+    [TestFixture]
+    public sealed class TestPipeTable
     {
-        MarkdownDocument document =
-            Markdown.Parse(markdown, new MarkdownPipelineBuilder().UseAdvancedExtensions().Build());
-
-        Table[] tables = document.Descendants().OfType<Table>().ToArray();
-
-        Assert.AreEqual(tableCount, tables.Length);
-    }
-
-    [TestCase("A | B\r\n---|---", new[] {50.0f, 50.0f})]
-    [TestCase("A | B\r\n-|---", new[] {25.0f, 75.0f})]
-    [TestCase("A | B\r\n-|---\r\nA | B\r\n---|---", new[] {25.0f, 75.0f})]
-    [TestCase("A | B\r\n---|---|---", new[] {33.33f, 33.33f, 33.33f})]
-    [TestCase("A | B\r\n---|---|---|", new[] {33.33f, 33.33f, 33.33f})]
-    public void TestColumnWidthByHeaderLines(string markdown, float[] expectedWidth)
-    {
-        var pipeline = new MarkdownPipelineBuilder()
-            .UsePipeTables(new PipeTableOptions() {InferColumnWidthsFromSeparator = true})
-            .Build();
-        var document = Markdown.Parse(markdown, pipeline);
-        var table = document.Descendants().OfType<Table>().FirstOrDefault();
-        Assert.IsNotNull(table);
-        var actualWidths = table.ColumnDefinitions.Select(x => x.Width).ToList();
-        Assert.AreEqual(actualWidths.Count, expectedWidth.Length);
-        for (int i = 0; i < expectedWidth.Length; i++)
+        [TestCase("| S | T |\r\n|---|---| \r\n| G | H |")]
+        [TestCase("| S | T |\r\n|---|---|\t\r\n| G | H |")]
+        [TestCase("| S | T |\r\n|---|---|\v\r\n| G | H |")]
+        [TestCase("| S | T |\r\n|---|---|\f\r\n| G | H |")]
+        [TestCase("| S | T |\r\n|---|---|\f\v\t \r\n| G | H |")]
+        [TestCase("| S | \r\n|---|\r\n| G |\r\n\r\n| D | D |\r\n| ---| ---| \r\n| V | V |", 2)]
+        public void TestTableBug(string markdown, int tableCount = 1)
         {
-            Assert.AreEqual(actualWidths[i], expectedWidth[i], 0.01);
-        }
-    }
+            MarkdownDocument document = Markdown.Parse(markdown, new MarkdownPipelineBuilder().UseAdvancedExtensions().Build());
 
-    [Test]
-    public void TestColumnWidthIsNotSetWithoutConfigurationFlag()
-    {
-        var pipeline = new MarkdownPipelineBuilder()
-            .UsePipeTables(new PipeTableOptions() {InferColumnWidthsFromSeparator = false})
-            .Build();
-        var document = Markdown.Parse("| A | B | C |\r\n|---|---|---|", pipeline);
-        var table = document.Descendants().OfType<Table>().FirstOrDefault();
-        Assert.IsNotNull(table);
-        foreach (var column in table.ColumnDefinitions)
-        {
-            Assert.AreEqual(0, column.Width);
+            Table[] tables = document.Descendants().OfType<Table>().ToArray();
+
+            Assert.AreEqual(tableCount, tables.Length);
         }
     }
 }

src/Markdig.Tests/TestPlainText.cs

@@ -1,50 +1,45 @@
-namespace Markdig.Tests;
+using NUnit.Framework;
 
-[TestFixture]
-public class TestPlainText
+namespace Markdig.Tests
 {
-    [Test]
-    [TestCase(/* markdownText: */ "foo bar", /* expected: */ "foo bar\n")]
-    [TestCase(/* markdownText: */ "foo\nbar", /* expected: */ "foo\nbar\n")]
-    [TestCase(/* markdownText: */ "*foo\nbar*", /* expected: */ "foo\nbar\n")]
-    [TestCase(/* markdownText: */ "[foo\nbar](http://example.com)", /* expected: */ "foo\nbar\n")]
-    [TestCase(/* markdownText: */ "<http://foo.bar.baz>", /* expected: */ "http://foo.bar.baz\n")]
-    [TestCase(/* markdownText: */ "# foo bar", /* expected: */ "foo bar\n")]
-    [TestCase(/* markdownText: */ "# foo\nbar", /* expected: */ "foo\nbar\n")]
-    [TestCase(/* markdownText: */ "> foo", /* expected: */ "foo\n")]
-    [TestCase(/* markdownText: */ "> foo\nbar\n> baz", /* expected: */ "foo\nbar\nbaz\n")]
-    [TestCase(/* markdownText: */ "`foo`", /* expected: */ "foo\n")]
-    [TestCase(/* markdownText: */ "`foo\nbar`", /* expected: */ "foo bar\n")] // new line within codespan is treated as whitespace (Example317)
-    [TestCase(/* markdownText: */ "```\nfoo bar\n```", /* expected: */ "foo bar\n")]
-    [TestCase(/* markdownText: */ "- foo\n- bar\n- baz", /* expected: */ "foo\nbar\nbaz\n")]
-    [TestCase(/* markdownText: */ "- foo<baz", /* expected: */ "foo<baz\n")]
-    [TestCase(/* markdownText: */ "- foo&lt;baz", /* expected: */ "foo<baz\n")]
-    [TestCase(/* markdownText: */ "## foo `bar::baz >`", /* expected: */ "foo bar::baz >\n")]
-    public void TestPlainEnsureNewLine(string markdownText, string expected)
+    [TestFixture]
+    public class TestPlainText
     {
-        var actual = Markdown.ToPlainText(markdownText);
-        Assert.AreEqual(expected, actual);
-    }
+        [Test]
+        [TestCase(/* markdownText: */ "foo bar", /* expected: */ "foo bar\n")]
+        [TestCase(/* markdownText: */ "foo\nbar", /* expected: */ "foo\nbar\n")]
+        [TestCase(/* markdownText: */ "*foo\nbar*", /* expected: */ "foo\nbar\n")]
+        [TestCase(/* markdownText: */ "[foo\nbar](http://example.com)", /* expected: */ "foo\nbar\n")]
+        [TestCase(/* markdownText: */ "<http://foo.bar.baz>", /* expected: */ "http://foo.bar.baz\n")]
+        [TestCase(/* markdownText: */ "# foo bar", /* expected: */ "foo bar\n")]
+        [TestCase(/* markdownText: */ "# foo\nbar", /* expected: */ "foo\nbar\n")]
+        [TestCase(/* markdownText: */ "> foo", /* expected: */ "foo\n")]
+        [TestCase(/* markdownText: */ "> foo\nbar\n> baz", /* expected: */ "foo\nbar\nbaz\n")]
+        [TestCase(/* markdownText: */ "`foo`", /* expected: */ "foo\n")]
+        [TestCase(/* markdownText: */ "`foo\nbar`", /* expected: */ "foo bar\n")] // new line within codespan is treated as whitespace (Example317)
+        [TestCase(/* markdownText: */ "```\nfoo bar\n```", /* expected: */ "foo bar\n")]
+        [TestCase(/* markdownText: */ "- foo\n- bar\n- baz", /* expected: */ "foo\nbar\nbaz\n")]
+        [TestCase(/* markdownText: */ "- foo<baz", /* expected: */ "foo<baz\n")]
+        [TestCase(/* markdownText: */ "- foo&lt;baz", /* expected: */ "foo<baz\n")]
+        [TestCase(/* markdownText: */ "## foo `bar::baz >`", /* expected: */ "foo bar::baz >\n")]
+        public void TestPlainEnsureNewLine(string markdownText, string expected)
+        {
+            var actual = Markdown.ToPlainText(markdownText);
+            Assert.AreEqual(expected, actual);
+        }
 
-    [Test]
-    [TestCase(/* markdownText: */ "```\nConsole.WriteLine(\"Hello, World!\");\n```", /* expected: */ "Console.WriteLine(\"Hello, World!\");\n")]
-    public void TestPlainCodeBlock(string markdownText, string expected)
-    {
-        var actual = Markdown.ToPlainText(markdownText);
-        Assert.AreEqual(expected, actual);
-    }
+        [Test]
+        [TestCase(/* markdownText: */ ":::\nfoo\n:::", /* expected: */ "foo\n", /*extensions*/ "customcontainers|advanced")]
+        [TestCase(/* markdownText: */ ":::bar\nfoo\n:::", /* expected: */ "foo\n", /*extensions*/ "customcontainers+attributes|advanced")]
+        [TestCase(/* markdownText: */ "| Header1 | Header2 | Header3 |\n|--|--|--|\nt**es**t|value2|value3", /* expected: */ "Header1 Header2 Header3 test value2 value3","pipetables")]
+        public void TestPlainWithExtensions(string markdownText, string expected, string extensions)
+        {
+            TestParser.TestSpec(markdownText, expected, extensions, plainText: true);
+        }
 
-    [Test]
-    [TestCase(/* markdownText: */ ":::\nfoo\n:::", /* expected: */ "foo\n", /*extensions*/ "customcontainers|advanced")]
-    [TestCase(/* markdownText: */ ":::bar\nfoo\n:::", /* expected: */ "foo\n", /*extensions*/ "customcontainers+attributes|advanced")]
-    [TestCase(/* markdownText: */ "| Header1 | Header2 | Header3 |\n|--|--|--|\nt**es**t|value2|value3", /* expected: */ "Header1 Header2 Header3 test value2 value3","pipetables")]
-    public void TestPlainWithExtensions(string markdownText, string expected, string extensions)
-    {
-        TestParser.TestSpec(markdownText, expected, extensions, plainText: true);
-    }
-
-    public static void TestSpec(string markdownText, string expected, string extensions, string context = null)
-    {
-        TestParser.TestSpec(markdownText, expected, extensions, plainText: true, context: context);
+        public static void TestSpec(string markdownText, string expected, string extensions, string context = null)
+        {
+            TestParser.TestSpec(markdownText, expected, extensions, plainText: true, context: context);
+        }
     }
 }

src/Markdig.Tests/TestPlayParser.cs

@@ -1,109 +1,97 @@
 // 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.Linq;
 using Markdig.Syntax;
 using Markdig.Syntax.Inlines;
+using NUnit.Framework;
 
-namespace Markdig.Tests;
-
-[TestFixture]
-public class TestPlayParser
+namespace Markdig.Tests
 {
-
-    [Test]
-    public void TestInvalidSetext()
+    [TestFixture]
+    public class TestPlayParser
     {
-        TestParser.TestSpec("test\n===n", "<p>test\n===n</p>", "advanced");
-    }
+        [Test]
+        public void TestBugWithEmphasisAndTable()
+        {
+            TestParser.TestSpec("**basics | 8:00**", "<p><strong>basics | 8:00</strong></p>", "advanced");
+        }
 
-    [Test]
-    public void TestBugWithEmphasisAndTable()
-    {
-        TestParser.TestSpec("**basics | 8:00**", "<p><strong>basics | 8:00</strong></p>", "advanced");
-    }
+        [Test]
+        public void TestLinksWithCarriageReturn()
+        {
+            var text = "[Link 1][link-1], [link 2][link-2].\r\n\r\n[link-1]: https://example.com\r\n[link-2]: https://example.com";
+            var result = Markdown.ToHtml(text).TrimEnd();
+            Assert.AreEqual("<p><a href=\"https://example.com\">Link 1</a>, <a href=\"https://example.com\">link 2</a>.</p>", result);
+        }
 
-    [Test]
-    public void TestLinksWithCarriageReturn()
-    {
-        var text = "[Link 1][link-1], [link 2][link-2].\r\n\r\n[link-1]: https://example.com\r\n[link-2]: https://example.com";
-        var result = Markdown.ToHtml(text).TrimEnd();
-        Assert.AreEqual("<p><a href=\"https://example.com\">Link 1</a>, <a href=\"https://example.com\">link 2</a>.</p>", result);
-    }
+        [Test]
+        public void TestLinksWithTitleAndCarriageReturn()
+        {
+            var text = "[Link 1][link-1], [link 2][link-2].\r\n\r\n[link-1]: https://example.com \"title 1\" \r\n[link-2]: https://example.com \"title 2\"";
+            var result = Markdown.ToHtml(text).TrimEnd();
+            Assert.AreEqual("<p><a href=\"https://example.com\" title=\"title 1\">Link 1</a>, <a href=\"https://example.com\" title=\"title 2\">link 2</a>.</p>", result);
+        }
 
-    [Test]
-    public void TestLinksWithTitleAndCarriageReturn()
-    {
-        var text = "[Link 1][link-1], [link 2][link-2].\r\n\r\n[link-1]: https://example.com \"title 1\" \r\n[link-2]: https://example.com \"title 2\"";
-        var result = Markdown.ToHtml(text).TrimEnd();
-        Assert.AreEqual("<p><a href=\"https://example.com\" title=\"title 1\">Link 1</a>, <a href=\"https://example.com\" title=\"title 2\">link 2</a>.</p>", result);
-    }
+        [Test]
+        public void TestLink()
+        {
+            var doc = Markdown.Parse("There is a ![link](/yoyo)");
+            var link = doc.Descendants<ParagraphBlock>().SelectMany(x => x.Inline.Descendants<LinkInline>()).FirstOrDefault(l => l.IsImage);
+            Assert.AreEqual("/yoyo", link?.Url);
+        }
 
-    [Test]
-    public void TestLink()
-    {
-        var doc = Markdown.Parse("There is a ![link](/yoyo)");
-        var link = doc.Descendants<ParagraphBlock>().SelectMany(x => x.Inline.Descendants<LinkInline>()).FirstOrDefault(l => l.IsImage);
-        Assert.AreEqual("/yoyo", link?.Url);
-    }
-
-    [Test]
-    public void TestLinkWithMultipleBackslashesInTitle()
-    {
-        var doc = Markdown.Parse(@"[link](/uri '\\\\127.0.0.1')");
-        var link = doc.Descendants<LinkInline>().FirstOrDefault();
-        Assert.AreEqual(@"\\127.0.0.1", link?.Title);
-    }
-
-    [Test]
-    public void TestListBug2()
-    {
-        TestParser.TestSpec("10.\t*test* – test\n\n11.\t__test__ test\n\n", @"<ol start=""10"">
+        [Test]
+        public void TestListBug2()
+        {
+            TestParser.TestSpec("10.\t*test* – test\n\n11.\t__test__ test\n\n", @"<ol start=""10"">
 <li><p><em>test</em> – test</p>
 </li>
 <li><p><strong>test</strong> test</p>
 </li>
 </ol>
 ");
-    }
+        }
 
-    [Test]
-    public void TestSimple()
-    {
-        var text = @" *[HTML]: Hypertext Markup Language
+        [Test]
+        public void TestSimple()
+        {
+            var text = @" *[HTML]: Hypertext Markup Language
 
 Later in a text we are using HTML and it becomes an abbr tag HTML
 ";
-        //            var reader = new StringReader(@"> > toto tata
-        //> titi toto
-        //");
+            //            var reader = new StringReader(@"> > toto tata
+            //> titi toto
+            //");
 
-        //var result = Markdown.ToHtml(text, new MarkdownPipeline().UseFootnotes().UseEmphasisExtras());
-        var result = Markdown.ToHtml(text, new MarkdownPipelineBuilder().UseAbbreviations().Build());
-        //File.WriteAllText("test.html", result, Encoding.UTF8);
-        //Console.WriteLine(result);
-    }
+            //var result = Markdown.ToHtml(text, new MarkdownPipeline().UseFootnotes().UseEmphasisExtras());
+            var result = Markdown.ToHtml(text, new MarkdownPipelineBuilder().UseAbbreviations().Build());
+            //File.WriteAllText("test.html", result, Encoding.UTF8);
+            //Console.WriteLine(result);
+        }
 
-    [Test]
-    public void TestEmptyLiteral()
-    {
-        var text = @"> *some text*
+        [Test]
+        public void TestEmptyLiteral()
+        {
+            var text = @"> *some text*
 > some other text";
-        var doc = Markdown.Parse(text);
+            var doc = Markdown.Parse(text);
 
-        Assert.True(doc.Descendants<LiteralInline>().All(x => !x.Content.IsEmpty),
-            "There should not have any empty literals");
-    }
+            Assert.True(doc.Descendants<LiteralInline>().All(x => !x.Content.IsEmpty),
+                "There should not have any empty literals");
+        }
 
-    [Test]
-    public void TestSelfPipeline1()
-    {
-        var text = @" <!--markdig:pipetables-->
+        [Test]
+        public void TestSelfPipeline1()
+        {
+            var text = @" <!--markdig:pipetables-->
 
 a | b
 - | -
 0 | 1
 ";
-        TestParser.TestSpec(text, @"<!--markdig:pipetables-->
+            TestParser.TestSpec(text, @"<!--markdig:pipetables-->
 <table>
 <thead>
 <tr>
@@ -119,17 +107,17 @@ a | b
 </tbody>
 </table>
 ", "self");
-    }
+        }
 
-    [Test]
-    public void TestListBug()
-    {
-        // TODO: Add this test back to the CommonMark specs
-        var text = @"- item1
+        [Test]
+        public void TestListBug()
+        {
+            // TODO: Add this test back to the CommonMark specs
+            var text = @"- item1
   - item2
     - item3
       - item4";
-        TestParser.TestSpec(text, @"<ul>
+            TestParser.TestSpec(text, @"<ul>
 <li>item1
 <ul>
 <li>item2
@@ -142,13 +130,13 @@ a | b
 </ul></li>
 </ul>
 ");
-    }
+        }
 
 
-    [Test]
-    public void TestHtmlBug()
-    {
-        TestParser.TestSpec(@" # header1
+        [Test]
+        public void TestHtmlBug()
+        {
+            TestParser.TestSpec(@" # header1
 
 <pre class='copy'>
 blabla
@@ -160,43 +148,43 @@ blabla
 blabla
 </pre>
 <h1>header2</h1>");
-    }
+        }
 
-    [Test]
-    public void TestHtmlh4Bug()
-    {
-        TestParser.TestSpec(@"<h4>foobar</h4>", @"<h4>foobar</h4>");
-    }
+        [Test]
+        public void TestHtmlh4Bug()
+        {
+            TestParser.TestSpec(@"<h4>foobar</h4>", @"<h4>foobar</h4>");
+        }
 
-    [Test]
-    public void TestStandardUriEscape()
-    {
-        TestParser.TestSpec(@"![你好](你好.png)", "<p><img src=\"你好.png\" alt=\"你好\" /></p>", "nonascii-noescape");
-    }
+        [Test]
+        public void TestStandardUriEscape()
+        {
+            TestParser.TestSpec(@"![你好](你好.png)", "<p><img src=\"你好.png\" alt=\"你好\" /></p>", "nonascii-noescape");
+        }
 
 
-    [Test]
-    public void TestBugAdvanced()
-    {
-        TestParser.TestSpec(@"`https://{domain}/callbacks`
+        [Test]
+        public void TestBugAdvanced()
+        {
+            TestParser.TestSpec(@"`https://{domain}/callbacks`
 #### HEADING
 Paragraph
 ", "<p><code>https://{domain}/callbacks</code></p>\n<h4 id=\"heading\">HEADING</h4>\n<p>Paragraph</p>", "advanced");
-    }
+        }
 
 
-    [Test]
-    public void TestBugEmphAttribute()
-    {
-        // https://github.com/lunet-io/markdig/issues/108
-        TestParser.TestSpec(@"*test*{name=value}", "<p><em name=\"value\">test</em></p>", "advanced");
-    }
+        [Test]
+        public void TestBugEmphAttribute()
+        {
+            // https://github.com/lunet-io/markdig/issues/108
+            TestParser.TestSpec(@"*test*{name=value}", "<p><em name=\"value\">test</em></p>", "advanced");
+        }
 
-    [Test]
-    public void TestBugPipeTables()
-    {
-        // https://github.com/lunet-io/markdig/issues/73
-        TestParser.TestSpec(@"| abc | def |
+        [Test]
+        public void TestBugPipeTables()
+        {
+            // https://github.com/lunet-io/markdig/issues/73
+            TestParser.TestSpec(@"| abc | def |
 | --- | --- |
 | 1 | ~3 |
 ", @"<table>
@@ -213,12 +201,12 @@ Paragraph
 </tr>
 </tbody>
 </table>", "advanced");
-    }
+        }
 
-    [Test]
-    public void TestGridTableWithCustomAttributes() {
+        [Test]
+        public void TestGridTableWithCustomAttributes() {
 
-        var input = @"
+            var input = @"
 {.table}
 +---+---+
 | a | b |
@@ -227,7 +215,7 @@ Paragraph
 +---+---+
 ";
 
-        var expected = @"<table class=""table"">
+            var expected = @"<table class=""table"">
 <col style=""width:50%"" />
 <col style=""width:50%"" />
 <thead>
@@ -244,75 +232,76 @@ Paragraph
 </tbody>
 </table>
 ";
-        TestParser.TestSpec(input, expected, "advanced");
+            TestParser.TestSpec(input, expected, "advanced");
+        }
+
+        [Test]
+        public void TestSamePipelineAllExtensions()
+        {
+            var pipeline = new MarkdownPipelineBuilder().UseAdvancedExtensions().Build();
+
+            // Reuse the same pipeline
+            var result1 = Markdown.ToHtml("This is a \"\"citation\"\"", pipeline);
+            var result2 = Markdown.ToHtml("This is a \"\"citation\"\"", pipeline);
+
+            Assert.AreEqual("<p>This is a <cite>citation</cite></p>", result1.Trim());
+            Assert.AreEqual(result1, result2);
+        }
+
+        // Test for emoji and smileys
+        //        var text = @" This is a test with a :) and a :angry: smiley";
+
+
+        // Test for definition lists:
+        //
+        //        var text = @"
+        //Term 1
+        //:   This is a definition item
+        //    With a paragraph
+        //    > This is a block quote
+
+        //    - This is a list
+        //    - item2
+
+        //    ```java
+        //    Test
+
+
+        //    ```
+
+        //    And a lazy line
+        //:   This ia another definition item
+
+        //Term2
+        //Term3 *with some inline*
+        //:   This is another definition for term2
+        //";
+
+
+        // Test for grid table
+
+
+        //        var text = @"
+        //+-----------------------------------+--------------------------------------+
+        //| - this is a list                  | > We have a blockquote
+        //| - this is a second item           |
+        //|                                   |
+        //| ```                               |
+        //| Yes                               |
+        //| ```                               |
+        //+===================================+======================================+
+        //| This is a second line             |
+        //+-----------------------------------+--------------------------------------+
+
+        //:::spoiler  {#yessss}
+        //This is a spoiler
+        //:::
+
+        ///| we have mult | paragraph    |
+        ///| we have a new colspan with a long line
+        ///| and lots of text
+        //";
+
+
     }
-
-    [Test]
-    public void TestSamePipelineAllExtensions()
-    {
-        var pipeline = new MarkdownPipelineBuilder().UseAdvancedExtensions().Build();
-
-        // Reuse the same pipeline
-        var result1 = Markdown.ToHtml("This is a \"\"citation\"\"", pipeline);
-        var result2 = Markdown.ToHtml("This is a \"\"citation\"\"", pipeline);
-
-        Assert.AreEqual("<p>This is a <cite>citation</cite></p>", result1.Trim());
-        Assert.AreEqual(result1, result2);
-    }
-
-    // Test for emoji and smileys
-    //        var text = @" This is a test with a :) and a :angry: smiley";
-
-
-    // Test for definition lists:
-    //
-    //        var text = @"
-    //Term 1
-    //:   This is a definition item
-    //    With a paragraph
-    //    > This is a block quote
-
-    //    - This is a list
-    //    - item2
-
-    //    ```java
-    //    Test
-
-
-    //    ```
-
-    //    And a lazy line
-    //:   This ia another definition item
-
-    //Term2
-    //Term3 *with some inline*
-    //:   This is another definition for term2
-    //";
-
-
-    // Test for grid table
-
-
-    //        var text = @"
-    //+-----------------------------------+--------------------------------------+
-    //| - this is a list                  | > We have a blockquote
-    //| - this is a second item           |
-    //|                                   |
-    //| ```                               |
-    //| Yes                               |
-    //| ```                               |
-    //+===================================+======================================+
-    //| This is a second line             |
-    //+-----------------------------------+--------------------------------------+
-
-    //:::spoiler  {#yessss}
-    //This is a spoiler
-    //:::
-
-    ///| we have mult | paragraph    |
-    ///| we have a new colspan with a long line
-    ///| and lots of text
-    //";
-
-
 }

src/Markdig.Tests/TestPragmaLines.cs

@@ -1,18 +1,19 @@
-// Copyright (c) Alexandre Mutel. All rights reserved.
+// Copyright (c) Alexandre Mutel. All rights reserved.
 // This file is licensed under the BSD-Clause 2 license. 
 // See the license.txt file in the project root for more information.
 
 using Markdig.Syntax;
+using NUnit.Framework;
 
-namespace Markdig.Tests;
-
-[TestFixture]
-public class TestPragmaLines
+namespace Markdig.Tests
 {
-    [Test]
-    public void TestFindClosest()
+    [TestFixture]
+    public class TestPragmaLines
     {
-        var doc = Markdown.Parse(
+        [Test]
+        public void TestFindClosest()
+        {
+            var doc = Markdown.Parse(
 "test1\n" +                      // 0
 "\n" +                           // 1
 "test2\n" +                      // 2
@@ -36,27 +37,27 @@ public class TestPragmaLines
 "- item3\n" +                    // 20
 "\n" +                           // 21
 "This is a last paragraph\n"     // 22
-            , new MarkdownPipelineBuilder().UsePragmaLines().Build());
+                , new MarkdownPipelineBuilder().UsePragmaLines().Build());
 
-        foreach (var exact in new int[] {0, 2, 4, 6, 8, 10, 18, 19, 20, 22})
-        {
-            Assert.AreEqual(exact, doc.FindClosestLine(exact));
+            foreach (var exact in new int[] {0, 2, 4, 6, 8, 10, 18, 19, 20, 22})
+            {
+                Assert.AreEqual(exact, doc.FindClosestLine(exact));
+            }
+
+            Assert.AreEqual(22, doc.FindClosestLine(23));
+
+            Assert.AreEqual(10, doc.FindClosestLine(11));
+            Assert.AreEqual(10, doc.FindClosestLine(12));
+            Assert.AreEqual(10, doc.FindClosestLine(13));
+            Assert.AreEqual(18, doc.FindClosestLine(14)); // > 50% of the paragraph, we switch to next
+            Assert.AreEqual(18, doc.FindClosestLine(15));
+            Assert.AreEqual(18, doc.FindClosestLine(16));
         }
 
-        Assert.AreEqual(22, doc.FindClosestLine(23));
-
-        Assert.AreEqual(10, doc.FindClosestLine(11));
-        Assert.AreEqual(10, doc.FindClosestLine(12));
-        Assert.AreEqual(10, doc.FindClosestLine(13));
-        Assert.AreEqual(18, doc.FindClosestLine(14)); // > 50% of the paragraph, we switch to next
-        Assert.AreEqual(18, doc.FindClosestLine(15));
-        Assert.AreEqual(18, doc.FindClosestLine(16));
-    }
-
-    [Test]
-    public void TestFindClosest1()
-    {
-        var text = 
+        [Test]
+        public void TestFindClosest1()
+        {
+            var text = 
 "- item1\n" +                    // 0
 "  - item11\n" +                 // 1
 "  - item12\n" +                 // 2
@@ -65,14 +66,15 @@ public class TestPragmaLines
 "    - item131\n" +              // 5
 "      - item1311\n";            // 6
 
-        var pipeline = new MarkdownPipelineBuilder().UsePragmaLines().Build();
-        var doc = Markdown.Parse(text, pipeline);
+            var pipeline = new MarkdownPipelineBuilder().UsePragmaLines().Build();
+            var doc = Markdown.Parse(text, pipeline);
 
-        for (int exact = 0; exact < 7; exact++)
-        {
-            Assert.AreEqual(exact, doc.FindClosestLine(exact));
+            for (int exact = 0; exact < 7; exact++)
+            {
+                Assert.AreEqual(exact, doc.FindClosestLine(exact));
+            }
+
+            Assert.AreEqual(6, doc.FindClosestLine(50));
         }
-
-        Assert.AreEqual(6, doc.FindClosestLine(50));
     }
 }

src/Markdig.Tests/TestReferralLinks.cs

@@ -1,54 +1,57 @@
-namespace Markdig.Tests;
+using NUnit.Framework;
 
-[TestFixture]
-public class TestReferralLinks
+namespace Markdig.Tests
 {
-    [Test]
-    public void TestLinksWithNoFollowRel()
+    [TestFixture]
+    public class TestReferralLinks
     {
-        var markdown = "[world](http://example.com)";
-        var expected = "nofollow";
+        [Test]
+        public void TestLinksWithNoFollowRel()
+        {
+            var markdown = "[world](http://example.com)";
+            var expected = "nofollow";
 
 #pragma warning disable 0618
-        var pipeline = new MarkdownPipelineBuilder()
-            .UseNoFollowLinks()
+            var pipeline = new MarkdownPipelineBuilder()
+                .UseNoFollowLinks()
 #pragma warning restore 0618
-            .Build();
-        var html = Markdown.ToHtml(markdown, pipeline);
+                .Build();
+            var html = Markdown.ToHtml(markdown, pipeline);
 
-        Assert.That(html, Contains.Substring($"rel=\"{expected}\""));
-    }
+            Assert.That(html, Contains.Substring($"rel=\"{expected}\""));
+        }
 
-    [Test]
-    [TestCase(new[] { "nofollow" }, "nofollow")]
-    [TestCase(new[] { "noopener" }, "noopener")]
-    [TestCase(new[] { "nofollow", "noopener"}, "nofollow noopener")]
-    public void TestLinksWithCustomRel(string[] rels, string expected)
-    {
-        var markdown = "[world](http://example.com)";
+        [Test]
+        [TestCase(new[] { "nofollow" }, "nofollow")]
+        [TestCase(new[] { "noopener" }, "noopener")]
+        [TestCase(new[] { "nofollow", "noopener"}, "nofollow noopener")]
+        public void TestLinksWithCustomRel(string[] rels, string expected)
+        {
+            var markdown = "[world](http://example.com)";
 
-        var pipeline = new MarkdownPipelineBuilder()
-            .UseReferralLinks(rels)
-            .Build();
-        var html = Markdown.ToHtml(markdown, pipeline);
+            var pipeline = new MarkdownPipelineBuilder()
+                .UseReferralLinks(rels)
+                .Build();
+            var html = Markdown.ToHtml(markdown, pipeline);
 
-        Assert.That(html, Contains.Substring($"rel=\"{expected}\""));
-    }
+            Assert.That(html, Contains.Substring($"rel=\"{expected}\""));
+        }
 
-    [Test]
-    [TestCase(new[] { "noopener" }, "noopener")]
-    [TestCase(new[] { "nofollow" }, "nofollow")]
-    [TestCase(new[] { "nofollow", "noopener" }, "nofollow noopener")]
-    public void TestAutoLinksWithCustomRel(string[] rels, string expected)
-    {
-        var markdown = "http://example.com";
+        [Test]
+        [TestCase(new[] { "noopener" }, "noopener")]
+        [TestCase(new[] { "nofollow" }, "nofollow")]
+        [TestCase(new[] { "nofollow", "noopener" }, "nofollow noopener")]
+        public void TestAutoLinksWithCustomRel(string[] rels, string expected)
+        {
+            var markdown = "http://example.com";
 
-        var pipeline = new MarkdownPipelineBuilder()
-            .UseAutoLinks()
-            .UseReferralLinks(rels)
-            .Build();
-        var html = Markdown.ToHtml(markdown, pipeline);
+            var pipeline = new MarkdownPipelineBuilder()
+                .UseAutoLinks()
+                .UseReferralLinks(rels)
+                .Build();
+            var html = Markdown.ToHtml(markdown, pipeline);
 
-        Assert.That(html, Contains.Substring($"rel=\"{expected}\""));
+            Assert.That(html, Contains.Substring($"rel=\"{expected}\""));
+        }
     }
 }

src/Markdig.Tests/TestRelativeUrlReplacement.cs

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

src/Markdig.Tests/TestRoundtrip.cs

@@ -1,29 +1,32 @@
 using Markdig.Renderers.Roundtrip;
 using Markdig.Syntax;
+using NUnit.Framework;
+using System.IO;
 
-namespace Markdig.Tests;
-
-internal static class TestRoundtrip
+namespace Markdig.Tests
 {
-    internal static void TestSpec(string markdownText, string expected, string extensions, string context = null)
+    internal static class TestRoundtrip
     {
-        RoundTrip(markdownText, context);
-    }
+        internal static void TestSpec(string markdownText, string expected, string extensions, string context = null)
+        {
+            RoundTrip(markdownText, context);
+        }
 
-    internal static void RoundTrip(string markdown, string context = null)
-    {
-        var pipelineBuilder = new MarkdownPipelineBuilder();
-        pipelineBuilder.EnableTrackTrivia();
-        pipelineBuilder.UseYamlFrontMatter();
-        MarkdownPipeline pipeline = pipelineBuilder.Build();
-        MarkdownDocument markdownDocument = Markdown.Parse(markdown, pipeline);
-        var sw = new StringWriter();
-        var nr = new RoundtripRenderer(sw);
-        pipeline.Setup(nr);
+        internal static void RoundTrip(string markdown, string context = null)
+        {
+            var pipelineBuilder = new MarkdownPipelineBuilder();
+            pipelineBuilder.EnableTrackTrivia();
+            pipelineBuilder.UseYamlFrontMatter();
+            MarkdownPipeline pipeline = pipelineBuilder.Build();
+            MarkdownDocument markdownDocument = Markdown.Parse(markdown, pipeline);
+            var sw = new StringWriter();
+            var nr = new RoundtripRenderer(sw);
+            pipeline.Setup(nr);
 
-        nr.Write(markdownDocument);
+            nr.Write(markdownDocument);
 
-        var result = sw.ToString();
-        TestParser.PrintAssertExpected("", result, markdown, context);
+            var result = sw.ToString();
+            TestParser.PrintAssertExpected("", result, markdown, context);
+        }
     }
 }

src/Markdig.Tests/TestSmartyPants.cs

@@ -1,34 +1,36 @@
 using Markdig.Extensions.SmartyPants;
+using NUnit.Framework;
 
-namespace Markdig.Tests;
-
-public class TestSmartyPants
+namespace Markdig.Tests
 {
-    [Test]
-    public void MappingCanBeReconfigured()
+    public class TestSmartyPants
     {
-        var options = new SmartyPantOptions();
-        options.Mapping[SmartyPantType.LeftAngleQuote] = "foo";
-        options.Mapping[SmartyPantType.RightAngleQuote] = "bar";
+        [Test]
+        public void MappingCanBeReconfigured()
+        {
+            SmartyPantOptions options = new SmartyPantOptions();
+            options.Mapping[SmartyPantType.LeftAngleQuote] = "foo";
+            options.Mapping[SmartyPantType.RightAngleQuote] = "bar";
 
-        var pipeline = new MarkdownPipelineBuilder()
-            .UseSmartyPants(options)
-            .Build();
+            var pipeline = new MarkdownPipelineBuilder()
+                .UseSmartyPants(options)
+                .Build();
 
-        TestParser.TestSpec("<<test>>", "<p>footestbar</p>", pipeline);
-    }
+            TestParser.TestSpec("<<test>>", "<p>footestbar</p>", pipeline);
+        }
 
-    [Test]
-    public void MappingCanBeReconfigured_HandlesRemovedMappings()
-    {
-        var options = new SmartyPantOptions();
-        options.Mapping.Remove(SmartyPantType.LeftAngleQuote);
-        options.Mapping.Remove(SmartyPantType.RightAngleQuote);
+        [Test]
+        public void MappingCanBeReconfigured_HandlesRemovedMappings()
+        {
+            SmartyPantOptions options = new SmartyPantOptions();
+            options.Mapping.Remove(SmartyPantType.LeftAngleQuote);
+            options.Mapping.Remove(SmartyPantType.RightAngleQuote);
 
-        var pipeline = new MarkdownPipelineBuilder()
-            .UseSmartyPants(options)
-            .Build();
+            var pipeline = new MarkdownPipelineBuilder()
+                .UseSmartyPants(options)
+                .Build();
 
-        TestParser.TestSpec("<<test>>", "<p>&laquo;test&raquo;</p>", pipeline);
+            TestParser.TestSpec("<<test>>", "<p>&laquo;test&raquo;</p>", pipeline);
+        }
     }
 }

src/Markdig.Tests/TestStringSliceList.cs

@@ -1,242 +1,185 @@
-using System.Collections;
+using NUnit.Framework;
 using System.Text;
-
 using Markdig.Helpers;
+using System;
 
-namespace Markdig.Tests;
-
-[TestFixture]
-public class TestStringSliceList
+namespace Markdig.Tests
 {
-    // TODO: Add tests for StringSlice
-    // TODO: Add more tests for StringLineGroup
-
-    [Test]
-    public void TestStringLineGroupSimple()
+    [TestFixture]
+    public class TestStringSliceList
     {
-        var text = new StringLineGroup(4)
+        // TODO: Add tests for StringSlice
+        // TODO: Add more tests for StringLineGroup
+
+        [Test]
+        public void TestStringLineGroupSimple()
         {
-            new StringSlice("ABC", NewLine.LineFeed),
-            new StringSlice("E", NewLine.LineFeed),
-            new StringSlice("F")
-        };
+            var text = new StringLineGroup(4)
+            {
+                new StringSlice("ABC", NewLine.LineFeed),
+                new StringSlice("E", NewLine.LineFeed),
+                new StringSlice("F")
+            };
 
-        var iterator = text.ToCharIterator();
-        Assert.AreEqual("ABC\nE\nF".Length, iterator.End - iterator.Start + 1);
+            var iterator = text.ToCharIterator();
+            Assert.AreEqual("ABC\nE\nF".Length, iterator.End - iterator.Start + 1);
 
-        var chars = ToString(text.ToCharIterator());
-        TextAssert.AreEqual("ABC\nE\nF", chars.ToString());
+            var chars = ToString(text.ToCharIterator());
+            TextAssert.AreEqual("ABC\nE\nF", chars.ToString());
 
-        TextAssert.AreEqual("ABC\nE\nF", text.ToString());
-    }
+            TextAssert.AreEqual("ABC\nE\nF", text.ToString());
+        }
 
-    [Test]
-    public void TestStringLineGroupWithSlices()
-    {
-        var text = new StringLineGroup(4)
+        [Test]
+        public void TestStringLineGroupWithSlices()
         {
-            new StringSlice("XABC", NewLine.LineFeed) { Start = 1},
-            new StringSlice("YYE", NewLine.LineFeed) { Start = 2},
-            new StringSlice("ZZZF") { Start = 3 }
-        };
+            var text = new StringLineGroup(4)
+            {
+                new StringSlice("XABC", NewLine.LineFeed) { Start = 1},
+                new StringSlice("YYE", NewLine.LineFeed) { Start = 2},
+                new StringSlice("ZZZF") { Start = 3 }
+            };
 
-        var chars = ToString(text.ToCharIterator());
-        TextAssert.AreEqual("ABC\nE\nF", chars.ToString());
-    }
+            var chars = ToString(text.ToCharIterator());
+            TextAssert.AreEqual("ABC\nE\nF", chars.ToString());
+        }
 
 
-    private static string ToString(StringLineGroup.Iterator text)
-    {
-        var chars = new StringBuilder();
-        while (text.CurrentChar != '\0')
+        private static string ToString(StringLineGroup.Iterator text)
         {
-            chars.Append(text.CurrentChar);
+            var chars = new StringBuilder();
+            while (text.CurrentChar != '\0')
+            {
+                chars.Append(text.CurrentChar);
+                text.NextChar();
+            }
+            return chars.ToString();
+        }
+
+        [Test]
+        public void TestStringLineGroupSaveAndRestore()
+        {
+            var text = new StringLineGroup(4)
+            {
+                new StringSlice("ABCD", NewLine.LineFeed),
+                new StringSlice("EF"),
+            }.ToCharIterator();
+
+            Assert.AreEqual('A', text.CurrentChar);
+            Assert.AreEqual(0, text.SliceIndex);
+
+            text.NextChar(); // B
+
+            text.NextChar(); // C
+            text.NextChar(); // D
+            text.NextChar(); // \n
             text.NextChar();
+            Assert.AreEqual('E', text.CurrentChar);
+            Assert.AreEqual(1, text.SliceIndex);
         }
-        return chars.ToString();
-    }
 
-    [Test]
-    public void TestStringLineGroupSaveAndRestore()
-    {
-        var text = new StringLineGroup(4)
+        [Test]
+        public void TestSkipWhitespaces()
         {
-            new StringSlice("ABCD", NewLine.LineFeed),
-            new StringSlice("EF"),
-        }.ToCharIterator();
+            var text = new StringLineGroup("             ABC").ToCharIterator();
+            Assert.False(text.TrimStart());
+            Assert.AreEqual('A', text.CurrentChar);
 
-        Assert.AreEqual('A', text.CurrentChar);
-        Assert.AreEqual(0, text.SliceIndex);
+            text = new StringLineGroup("        ").ToCharIterator();
+            Assert.True(text.TrimStart());
+            Assert.AreEqual('\0', text.CurrentChar);
 
-        text.NextChar(); // B
+            var slice = new StringSlice("             ABC");
+            Assert.False(slice.TrimStart());
 
-        text.NextChar(); // C
-        text.NextChar(); // D
-        text.NextChar(); // \n
-        text.NextChar();
-        Assert.AreEqual('E', text.CurrentChar);
-        Assert.AreEqual(1, text.SliceIndex);
-    }
+            slice = new StringSlice("        ");
+            Assert.True(slice.TrimStart());
+        }
 
-    [Test]
-    public void TestSkipWhitespaces()
-    {
-        var text = new StringLineGroup("             ABC").ToCharIterator();
-        Assert.False(text.TrimStart());
-        Assert.AreEqual('A', text.CurrentChar);
-
-        text = new StringLineGroup("        ").ToCharIterator();
-        Assert.True(text.TrimStart());
-        Assert.AreEqual('\0', text.CurrentChar);
-
-        var slice = new StringSlice("             ABC");
-        Assert.False(slice.TrimStart());
-
-        slice = new StringSlice("        ");
-        Assert.True(slice.TrimStart());
-    }
-
-    [Test]
-    public void TestStringLineGroupWithModifiedStart()
-    {
-        var line1 = new StringSlice("  ABC", NewLine.LineFeed);
-        line1.NextChar();
-        line1.NextChar();
-
-        var line2 = new StringSlice("  DEF ");
-        line2.Trim();
-
-        var text = new StringLineGroup(4) {line1, line2};
-
-        var result = ToString(text.ToCharIterator());
-        TextAssert.AreEqual("ABC\nDEF", result);
-    }
-
-    [Test]
-    public void TestStringLineGroupWithTrim()
-    {
-        var line1 = new StringSlice("  ABC  ", NewLine.LineFeed);
-        line1.NextChar();
-        line1.NextChar();
-
-        var line2 = new StringSlice("  DEF ");
-
-        var text = new StringLineGroup(4) { line1, line2}.ToCharIterator();
-        text.TrimStart();
-
-        var result = ToString(text);
-        TextAssert.AreEqual("ABC  \n  DEF ", result);
-    }
-
-    [Test]
-    public void TestStringLineGroupIteratorPeekChar()
-    {
-        var iterator = new StringLineGroup(4)
+        [Test]
+        public void TestStringLineGroupWithModifiedStart()
         {
-            new StringSlice("ABC", NewLine.LineFeed),
-            new StringSlice("E", NewLine.LineFeed),
-            new StringSlice("F")
-        }.ToCharIterator();
+            var line1 = new StringSlice("  ABC", NewLine.LineFeed);
+            line1.NextChar();
+            line1.NextChar();
 
-        Assert.AreEqual('A', iterator.CurrentChar);
-        Assert.AreEqual('A', iterator.PeekChar(0));
-        Assert.AreEqual('B', iterator.PeekChar());
-        Assert.AreEqual('B', iterator.PeekChar(1));
-        Assert.AreEqual('C', iterator.PeekChar(2));
-        Assert.AreEqual('\n', iterator.PeekChar(3));
-        Assert.AreEqual('E', iterator.PeekChar(4));
-        Assert.AreEqual('\n', iterator.PeekChar(5));
-        Assert.AreEqual('F', iterator.PeekChar(6));
-        Assert.AreEqual('\0', iterator.PeekChar(7)); // There is no \n appended to the last line
-        Assert.AreEqual('\0', iterator.PeekChar(8));
-        Assert.AreEqual('\0', iterator.PeekChar(100));
+            var line2 = new StringSlice("  DEF ");
+            line2.Trim();
 
-        Assert.Throws<ArgumentOutOfRangeException>(() => iterator.PeekChar(-1));
-    }
+            var text = new StringLineGroup(4) {line1, line2};
 
-    [Test]
-    public void TestIteratorSkipChar()
-    {
-        var lineGroup = new StringLineGroup(4)
+            var result = ToString(text.ToCharIterator());
+            TextAssert.AreEqual("ABC\nDEF", result);
+        }
+
+        [Test]
+        public void TestStringLineGroupWithTrim()
         {
-            new StringSlice("ABC", NewLine.LineFeed),
-            new StringSlice("E", NewLine.LineFeed)
-        };
+            var line1 = new StringSlice("  ABC  ", NewLine.LineFeed);
+            line1.NextChar();
+            line1.NextChar();
 
-        Test(lineGroup.ToCharIterator());
+            var line2 = new StringSlice("  DEF ");
 
-        Test(new StringSlice("ABC\nE\n"));
+            var text = new StringLineGroup(4) { line1, line2}.ToCharIterator();
+            text.TrimStart();
 
-        Test(new StringSlice("Foo\nABC\nE\n", 4, 9));
+            var result = ToString(text);
+            TextAssert.AreEqual("ABC  \n  DEF ", result);
+        }
 
-        static void Test<T>(T iterator) where T : ICharIterator
+        [Test]
+        public void TestStringLineGroupIteratorPeekChar()
         {
-            Assert.AreEqual('A', iterator.CurrentChar); iterator.SkipChar();
-            Assert.AreEqual('B', iterator.CurrentChar); iterator.SkipChar();
-            Assert.AreEqual('C', iterator.CurrentChar); iterator.SkipChar();
-            Assert.AreEqual('\n', iterator.CurrentChar); iterator.SkipChar();
-            Assert.AreEqual('E', iterator.CurrentChar); iterator.SkipChar();
-            Assert.AreEqual('\n', iterator.CurrentChar); iterator.SkipChar();
-            Assert.AreEqual('\0', iterator.CurrentChar); iterator.SkipChar();
-            Assert.AreEqual('\0', iterator.CurrentChar); iterator.SkipChar();
+            var iterator = new StringLineGroup(4)
+            {
+                new StringSlice("ABC", NewLine.LineFeed),
+                new StringSlice("E", NewLine.LineFeed),
+                new StringSlice("F")
+            }.ToCharIterator();
+
+            Assert.AreEqual('A', iterator.CurrentChar);
+            Assert.AreEqual('A', iterator.PeekChar(0));
+            Assert.AreEqual('B', iterator.PeekChar());
+            Assert.AreEqual('B', iterator.PeekChar(1));
+            Assert.AreEqual('C', iterator.PeekChar(2));
+            Assert.AreEqual('\n', iterator.PeekChar(3));
+            Assert.AreEqual('E', iterator.PeekChar(4));
+            Assert.AreEqual('\n', iterator.PeekChar(5));
+            Assert.AreEqual('F', iterator.PeekChar(6));
+            Assert.AreEqual('\0', iterator.PeekChar(7)); // There is no \n appended to the last line
+            Assert.AreEqual('\0', iterator.PeekChar(8));
+            Assert.AreEqual('\0', iterator.PeekChar(100));
+
+            Assert.Throws<ArgumentOutOfRangeException>(() => iterator.PeekChar(-1));
+        }
+
+        [Test]
+        public void TestIteratorSkipChar()
+        {
+            var lineGroup = new StringLineGroup(4)
+            {
+                new StringSlice("ABC", NewLine.LineFeed),
+                new StringSlice("E", NewLine.LineFeed)
+            };
+
+            Test(lineGroup.ToCharIterator());
+
+            Test(new StringSlice("ABC\nE\n"));
+
+            Test(new StringSlice("Foo\nABC\nE\n", 4, 9));
+
+            static void Test<T>(T iterator) where T : ICharIterator
+            {
+                Assert.AreEqual('A', iterator.CurrentChar); iterator.SkipChar();
+                Assert.AreEqual('B', iterator.CurrentChar); iterator.SkipChar();
+                Assert.AreEqual('C', iterator.CurrentChar); iterator.SkipChar();
+                Assert.AreEqual('\n', iterator.CurrentChar); iterator.SkipChar();
+                Assert.AreEqual('E', iterator.CurrentChar); iterator.SkipChar();
+                Assert.AreEqual('\n', iterator.CurrentChar); iterator.SkipChar();
+                Assert.AreEqual('\0', iterator.CurrentChar); iterator.SkipChar();
+                Assert.AreEqual('\0', iterator.CurrentChar); iterator.SkipChar();
+            }
         }
     }
-
-    [Test]
-    public void TestStringLineGroupCharIteratorAtCapacity()
-    {
-        string str = "ABCDEFGHI";
-        var text = new StringLineGroup(1)
-        {
-            // Will store the following line at capacity
-            new StringSlice(str, NewLine.CarriageReturnLineFeed) { Start = 0, End = 2 },
-        };
-
-        var iterator = text.ToCharIterator();
-        var chars = ToString(iterator);
-        TextAssert.AreEqual("ABC\r\n", chars.ToString());
-        TextAssert.AreEqual("ABC", text.ToString());
-    }
-
-    [Test]
-    public void TestStringLineGroupCharIteratorForcingIncreaseCapacity()
-    {
-        string str = "ABCDEFGHI";
-        var text = new StringLineGroup(1)
-        {
-            // Will store the following line at capacity
-            new StringSlice(str, NewLine.CarriageReturnLineFeed) { Start = 0, End = 2 },
-
-            // Will force increase capacity to 2 and store the line at capacity
-            new StringSlice(str, NewLine.CarriageReturnLineFeed) { Start = 3, End = 3 },
-        };
-
-        var iterator = text.ToCharIterator();
-        var chars = ToString(iterator);
-        TextAssert.AreEqual("ABC\r\nD\r\n", chars.ToString());
-        TextAssert.AreEqual("ABC\r\nD", text.ToString());
-    }
-
-    [Test]
-    public void TestStringLineGroup_EnumeratorReturnsRealLines()
-    {
-        string str = "A\r\n";
-        var text = new StringLineGroup(4)
-        {
-            new StringSlice(str, NewLine.CarriageReturnLineFeed) { Start = 0, End = 0 }
-        };
-
-        var enumerator = ((IEnumerable)text).GetEnumerator();
-        Assert.True(enumerator.MoveNext());
-        StringLine currentLine = (StringLine)enumerator.Current;
-        TextAssert.AreEqual("A", currentLine.ToString());
-        Assert.False(enumerator.MoveNext());
-        
-        var nonBoxedEnumerator = text.GetEnumerator();
-
-        Assert.True(nonBoxedEnumerator.MoveNext());
-        currentLine = (StringLine)nonBoxedEnumerator.Current;
-        TextAssert.AreEqual("A", currentLine.ToString());
-        Assert.False(nonBoxedEnumerator.MoveNext());
-    }
-}
+}

src/Markdig.Tests/TestTransformedStringCache.cs

@@ -1,98 +1,102 @@
+using System;
+using System.Linq;
 using Markdig.Helpers;
+using NUnit.Framework;
 
-namespace Markdig.Tests;
-
-public class TestTransformedStringCache
+namespace Markdig.Tests
 {
-    [Test]
-    public void GetRunsTransformationCallback()
+    public class TestTransformedStringCache
     {
-        var cache = new TransformedStringCache(static s => "callback-" + s);
-
-        Assert.AreEqual("callback-foo", cache.Get("foo"));
-        Assert.AreEqual("callback-bar", cache.Get("bar"));
-        Assert.AreEqual("callback-baz", cache.Get("baz"));
-    }
-
-    [Test]
-    public void CachesTransformedInstance()
-    {
-        var cache = new TransformedStringCache(static s => "callback-" + s);
-
-        string transformedBar = cache.Get("bar");
-        Assert.AreSame(transformedBar, cache.Get("bar"));
-
-        string transformedFoo = cache.Get("foo".AsSpan());
-        Assert.AreSame(transformedFoo, cache.Get("foo"));
-
-        Assert.AreSame(cache.Get("baz"), cache.Get("baz".AsSpan()));
-
-        Assert.AreSame(transformedBar, cache.Get("bar"));
-        Assert.AreSame(transformedFoo, cache.Get("foo"));
-        Assert.AreSame(transformedBar, cache.Get("bar".AsSpan()));
-        Assert.AreSame(transformedFoo, cache.Get("foo".AsSpan()));
-    }
-
-    [Test]
-    public void DoesNotCacheEmptyInputs()
-    {
-        var cache = new TransformedStringCache(static s => new string('a', 4));
-
-        string cached = cache.Get("");
-        string cached2 = cache.Get("");
-        string cached3 = cache.Get(ReadOnlySpan<char>.Empty);
-
-        Assert.AreEqual("aaaa", cached);
-        Assert.AreEqual(cached, cached2);
-        Assert.AreEqual(cached, cached3);
-
-        Assert.AreNotSame(cached, cached2);
-        Assert.AreNotSame(cached, cached3);
-        Assert.AreNotSame(cached2, cached3);
-    }
-
-    [Test]
-    [TestCase(TransformedStringCache.InputLengthLimit, true)]
-    [TestCase(TransformedStringCache.InputLengthLimit + 1, false)]
-    public void DoesNotCacheLongInputs(int length, bool shouldBeCached)
-    {
-        var cache = new TransformedStringCache(static s => "callback-" + s);
-
-        string input = new string('a', length);
-
-        string cached = cache.Get(input);
-        string cached2 = cache.Get(input);
-
-        Assert.AreEqual("callback-" + input, cached);
-        Assert.AreEqual(cached, cached2);
-
-        if (shouldBeCached)
+        [Test]
+        public void GetRunsTransformationCallback()
         {
-            Assert.AreSame(cached, cached2);
+            var cache = new TransformedStringCache(static s => "callback-" + s);
+
+            Assert.AreEqual("callback-foo", cache.Get("foo"));
+            Assert.AreEqual("callback-bar", cache.Get("bar"));
+            Assert.AreEqual("callback-baz", cache.Get("baz"));
         }
-        else
+
+        [Test]
+        public void CachesTransformedInstance()
         {
+            var cache = new TransformedStringCache(static s => "callback-" + s);
+
+            string transformedBar = cache.Get("bar");
+            Assert.AreSame(transformedBar, cache.Get("bar"));
+
+            string transformedFoo = cache.Get("foo".AsSpan());
+            Assert.AreSame(transformedFoo, cache.Get("foo"));
+
+            Assert.AreSame(cache.Get("baz"), cache.Get("baz".AsSpan()));
+
+            Assert.AreSame(transformedBar, cache.Get("bar"));
+            Assert.AreSame(transformedFoo, cache.Get("foo"));
+            Assert.AreSame(transformedBar, cache.Get("bar".AsSpan()));
+            Assert.AreSame(transformedFoo, cache.Get("foo".AsSpan()));
+        }
+
+        [Test]
+        public void DoesNotCacheEmptyInputs()
+        {
+            var cache = new TransformedStringCache(static s => new string('a', 4));
+
+            string cached = cache.Get("");
+            string cached2 = cache.Get("");
+            string cached3 = cache.Get(ReadOnlySpan<char>.Empty);
+
+            Assert.AreEqual("aaaa", cached);
+            Assert.AreEqual(cached, cached2);
+            Assert.AreEqual(cached, cached3);
+
             Assert.AreNotSame(cached, cached2);
+            Assert.AreNotSame(cached, cached3);
+            Assert.AreNotSame(cached2, cached3);
         }
-    }
 
-    [Test]
-    public void CachesAtMostNEntriesPerCharacter()
-    {
-        var cache = new TransformedStringCache(static s => "callback-" + s);
-
-        int limit = TransformedStringCache.MaxEntriesPerCharacter;
-
-        string[] a = Enumerable.Range(1, limit + 1).Select(i => $"a{i}").ToArray();
-        string[] cachedAs = a.Select(a => cache.Get(a)).ToArray();
-
-        for (int i = 0; i < limit; i++)
+        [Test]
+        [TestCase(TransformedStringCache.InputLengthLimit, true)]
+        [TestCase(TransformedStringCache.InputLengthLimit + 1, false)]
+        public void DoesNotCacheLongInputs(int length, bool shouldBeCached)
         {
-            Assert.AreSame(cachedAs[i], cache.Get(a[i]));
+            var cache = new TransformedStringCache(static s => "callback-" + s);
+
+            string input = new string('a', length);
+
+            string cached = cache.Get(input);
+            string cached2 = cache.Get(input);
+
+            Assert.AreEqual("callback-" + input, cached);
+            Assert.AreEqual(cached, cached2);
+
+            if (shouldBeCached)
+            {
+                Assert.AreSame(cached, cached2);
+            }
+            else
+            {
+                Assert.AreNotSame(cached, cached2);
+            }
         }
 
-        Assert.AreNotSame(cachedAs[limit], cache.Get(a[limit]));
+        [Test]
+        public void CachesAtMostNEntriesPerCharacter()
+        {
+            var cache = new TransformedStringCache(static s => "callback-" + s);
 
-        Assert.AreSame(cache.Get("b1"), cache.Get("b1"));
+            int limit = TransformedStringCache.MaxEntriesPerCharacter;
+
+            string[] a = Enumerable.Range(1, limit + 1).Select(i => $"a{i}").ToArray();
+            string[] cachedAs = a.Select(a => cache.Get(a)).ToArray();
+
+            for (int i = 0; i < limit; i++)
+            {
+                Assert.AreSame(cachedAs[i], cache.Get(a[i]));
+            }
+
+            Assert.AreNotSame(cachedAs[limit], cache.Get(a[limit]));
+
+            Assert.AreSame(cache.Get("b1"), cache.Get("b1"));
+        }
     }
 }

src/Markdig.Tests/TestYamlFrontMatterExtension.cs

@@ -1,113 +1,78 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
 using Markdig.Extensions.Yaml;
 using Markdig.Renderers;
 using Markdig.Syntax;
+using NUnit.Framework;
 
-namespace Markdig.Tests;
-
-public class TestYamlFrontMatterExtension
+namespace Markdig.Tests
 {
-    [TestCaseSource(nameof(TestCases))]
-    public void ProperYamlFrontMatterRenderersAdded(IMarkdownObjectRenderer[] objectRenderers, bool hasYamlFrontMatterHtmlRenderer, bool hasYamlFrontMatterRoundtripRenderer)
+    public class TestYamlFrontMatterExtension
     {
-        var builder = new MarkdownPipelineBuilder();
-        builder.Extensions.Add(new YamlFrontMatterExtension());
-        var markdownRenderer = new DummyRenderer();
-        markdownRenderer.ObjectRenderers.AddRange(objectRenderers);
-        builder.Build().Setup(markdownRenderer);
-        Assert.That(markdownRenderer.ObjectRenderers.Contains<YamlFrontMatterHtmlRenderer>(), Is.EqualTo(hasYamlFrontMatterHtmlRenderer));
-        Assert.That(markdownRenderer.ObjectRenderers.Contains<YamlFrontMatterRoundtripRenderer>(), Is.EqualTo(hasYamlFrontMatterRoundtripRenderer));
-    }
-
-    [Test]
-    public void AllowYamlFrontMatterInMiddleOfDocument()
-    {
-        var pipeline = new MarkdownPipelineBuilder()
-            .Use(new YamlFrontMatterExtension { AllowInMiddleOfDocument = true })
-            .Build();
-
-        TestParser.TestSpec(
-            "This is a text1\n---\nthis: is a frontmatter\n---\nThis is a text2",
-            "<p>This is a text1</p>\n<p>This is a text2</p>",
-            pipeline);
-    }
-
-    private static IEnumerable<TestCaseData> TestCases()
-    {
-        yield return new TestCaseData(new IMarkdownObjectRenderer[]
+        [TestCaseSource(nameof(TestCases))]
+        public void ProperYamlFrontMatterRenderersAdded(IMarkdownObjectRenderer[] objectRenderers, bool hasYamlFrontMatterHtmlRenderer, bool hasYamlFrontMatterRoundtripRenderer)
         {
-        }, false, false) {TestName = "No ObjectRenderers"};
-
-        yield return new TestCaseData(new IMarkdownObjectRenderer[]
-        {
-            new Markdig.Renderers.Html.CodeBlockRenderer()
-        }, true, false) {TestName = "Html CodeBlock"};
-
-        yield return new TestCaseData(new IMarkdownObjectRenderer[]
-        {
-            new Markdig.Renderers.Roundtrip.CodeBlockRenderer()
-        }, false, true) {TestName = "Roundtrip CodeBlock"};
-
-        yield return new TestCaseData(new IMarkdownObjectRenderer[]
-        {
-            new Markdig.Renderers.Html.CodeBlockRenderer(),
-            new Markdig.Renderers.Roundtrip.CodeBlockRenderer()
-        }, true, true) {TestName = "Html/Roundtrip CodeBlock"};
-
-        yield return new TestCaseData(new IMarkdownObjectRenderer[]
-        {
-            new Markdig.Renderers.Html.CodeBlockRenderer(),
-            new Markdig.Renderers.Roundtrip.CodeBlockRenderer(),
-            new YamlFrontMatterHtmlRenderer()
-        }, true, true) {TestName = "Html/Roundtrip CodeBlock, Yaml Html"};
-
-        yield return new TestCaseData(new IMarkdownObjectRenderer[]
-        {
-            new Markdig.Renderers.Html.CodeBlockRenderer(),
-            new Markdig.Renderers.Roundtrip.CodeBlockRenderer(),
-            new YamlFrontMatterRoundtripRenderer()
-        }, true, true) { TestName = "Html/Roundtrip CodeBlock, Yaml Roundtrip" };
-    }
-
-    private class DummyRenderer : IMarkdownRenderer
-    {
-        public DummyRenderer()
-        {
-            ObjectRenderers = new ObjectRendererCollection();
+            var builder = new MarkdownPipelineBuilder();
+            builder.Extensions.Add(new YamlFrontMatterExtension());
+            var markdownRenderer = new DummyRenderer();
+            markdownRenderer.ObjectRenderers.AddRange(objectRenderers);
+            builder.Build().Setup(markdownRenderer);
+            Assert.That(markdownRenderer.ObjectRenderers.Contains<YamlFrontMatterHtmlRenderer>(), Is.EqualTo(hasYamlFrontMatterHtmlRenderer));
+            Assert.That(markdownRenderer.ObjectRenderers.Contains<YamlFrontMatterRoundtripRenderer>(), Is.EqualTo(hasYamlFrontMatterRoundtripRenderer));
         }
 
-#pragma warning disable CS0067 // ObjectWriteBefore/ObjectWriteAfter is never used
-        public event Action<IMarkdownRenderer, MarkdownObject> ObjectWriteBefore;
-        public event Action<IMarkdownRenderer, MarkdownObject> ObjectWriteAfter;
-#pragma warning restore CS0067
-
-        public ObjectRendererCollection ObjectRenderers { get; }
-        public object Render(MarkdownObject markdownObject)
+        private static IEnumerable<TestCaseData> TestCases()
         {
-            return null;
-        }
-    }
-
-    [TestCase("---\nkey1: value1\nkey2: value2\n---\n\n# Content\n")]
-    [TestCase("---\nkey1: value1\nkey2: value2\nkey3: value3\nkey4: value4\nkey5: value5\nkey6: value6\nkey7: value7\nkey8: value8\n---\n\n# Content\n")]
-    public void FrontMatterBlockLinesCharIterator(string value)
-    {
-        var builder = new MarkdownPipelineBuilder();
-        builder.Extensions.Add(new YamlFrontMatterExtension());
-        var markdownDocument = Markdown.Parse(value, builder.Build());
-
-        var yamlBlocks = markdownDocument.Descendants<YamlFrontMatterBlock>();
-        Assert.True(yamlBlocks.Any());
-
-        foreach (var yamlBlock in yamlBlocks)
-        {
-            var iterator = yamlBlock.Lines.ToCharIterator();
-            while(iterator.CurrentChar != '\0')
+            yield return new TestCaseData(new IMarkdownObjectRenderer[]
             {
-                iterator.NextChar();
+            }, false, false) {TestName = "No ObjectRenderers"};
+
+            yield return new TestCaseData(new IMarkdownObjectRenderer[]
+            {
+                new Markdig.Renderers.Html.CodeBlockRenderer()
+            }, true, false) {TestName = "Html CodeBlock"};
+
+            yield return new TestCaseData(new IMarkdownObjectRenderer[]
+            {
+                new Markdig.Renderers.Roundtrip.CodeBlockRenderer()
+            }, false, true) {TestName = "Roundtrip CodeBlock"};
+
+            yield return new TestCaseData(new IMarkdownObjectRenderer[]
+            {
+                new Markdig.Renderers.Html.CodeBlockRenderer(),
+                new Markdig.Renderers.Roundtrip.CodeBlockRenderer()
+            }, true, true) {TestName = "Html/Roundtrip CodeBlock"};
+
+            yield return new TestCaseData(new IMarkdownObjectRenderer[]
+            {
+                new Markdig.Renderers.Html.CodeBlockRenderer(),
+                new Markdig.Renderers.Roundtrip.CodeBlockRenderer(),
+                new YamlFrontMatterHtmlRenderer()
+            }, true, true) {TestName = "Html/Roundtrip CodeBlock, Yaml Html"};
+
+            yield return new TestCaseData(new IMarkdownObjectRenderer[]
+            {
+                new Markdig.Renderers.Html.CodeBlockRenderer(),
+                new Markdig.Renderers.Roundtrip.CodeBlockRenderer(),
+                new YamlFrontMatterRoundtripRenderer()
+            }, true, true) { TestName = "Html/Roundtrip CodeBlock, Yaml Roundtrip" };
+        }
+
+        private class DummyRenderer : IMarkdownRenderer
+        {
+            public DummyRenderer()
+            {
+                ObjectRenderers = new ObjectRendererCollection();
+            }
+
+            public event Action<IMarkdownRenderer, MarkdownObject> ObjectWriteBefore;
+            public event Action<IMarkdownRenderer, MarkdownObject> ObjectWriteAfter;
+            public ObjectRendererCollection ObjectRenderers { get; }
+            public object Render(MarkdownObject markdownObject)
+            {
+                return null;
             }
         }
-
-        // No exception parsing and iterating through YAML front matter block lines
     }
-
 }

src/Markdig.Tests/TextAssert.cs

@@ -1,115 +1,119 @@
 // 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.Globalization;
+using System.IO;
+using NUnit.Framework;
 
-namespace Markdig.Tests;
-
-/// <summary>
-/// Pretty text assert from https://gist.github.com/Haacked/1610603
-/// Modified version to only print +-10 characters around the first diff
-/// </summary>
-public static class TextAssert
+namespace Markdig.Tests
 {
-    public enum DiffStyle
+    /// <summary>
+    /// Pretty text assert from https://gist.github.com/Haacked/1610603
+    /// Modified version to only print +-10 characters around the first diff
+    /// </summary>
+    public static class TextAssert
     {
-        Full,
-        Minimal
-    }
-
-    public static void AreEqual(string expectedValue, string actualValue)
-    {
-        AreEqual(expectedValue, actualValue, DiffStyle.Full, Console.Out);
-    }
-
-    public static void AreEqual(string expectedValue, string actualValue, DiffStyle diffStyle)
-    {
-        AreEqual(expectedValue, actualValue, diffStyle, Console.Out);
-    }
-
-    public static void AreEqual(string expectedValue, string actualValue, DiffStyle diffStyle, TextWriter output)
-    {
-        if (actualValue == null || expectedValue == null)
+        public enum DiffStyle
         {
+            Full,
+            Minimal
+        }
+
+        public static void AreEqual(string expectedValue, string actualValue)
+        {
+            AreEqual(expectedValue, actualValue, DiffStyle.Full, Console.Out);
+        }
+
+        public static void AreEqual(string expectedValue, string actualValue, DiffStyle diffStyle)
+        {
+            AreEqual(expectedValue, actualValue, diffStyle, Console.Out);
+        }
+
+        public static void AreEqual(string expectedValue, string actualValue, DiffStyle diffStyle, TextWriter output)
+        {
+            if (actualValue == null || expectedValue == null)
+            {
+                Assert.AreEqual(expectedValue, actualValue);
+                return;
+            }
+
+            if (actualValue.Equals(expectedValue, StringComparison.Ordinal))
+            {
+                return;
+            }
+
+            Console.WriteLine();
+            output.WriteLine("Index    Expected     Actual");
+            output.WriteLine("----------------------------");
+            int maxLen = Math.Max(actualValue.Length, expectedValue.Length);
+            int minLen = Math.Min(actualValue.Length, expectedValue.Length);
+
+            if (diffStyle != DiffStyle.Minimal)
+            {
+                int startDifferAt = 0;
+                for (int i = 0; i < maxLen; i++)
+                {
+                    if (i >= minLen || actualValue[i] != expectedValue[i])
+                    {
+                        startDifferAt = i;
+                        break;
+                    }
+                }
+
+                var endDifferAt = Math.Min(startDifferAt + 10, maxLen);
+                startDifferAt = Math.Max(startDifferAt - 10, 0);
+
+                bool isFirstDiff = true;
+                for (int i = startDifferAt; i < endDifferAt; i++)
+                {
+                    if (i >= minLen || actualValue[i] != expectedValue[i])
+                    {
+                        output.WriteLine("{0,-3} {1,-3}    {2,-4} {3,-3}   {4,-4} {5,-3}",
+                            i < minLen && actualValue[i] == expectedValue[i] ? " " : isFirstDiff  ? ">>>": "***",
+                            // put a mark beside a differing row
+                            i, // the index
+                            i < expectedValue.Length ? ((int) expectedValue[i]).ToString() : "",
+                            // character decimal value
+                            i < expectedValue.Length ? expectedValue[i].ToSafeString() : "", // character safe string
+                            i < actualValue.Length ? ((int) actualValue[i]).ToString() : "", // character decimal value
+                            i < actualValue.Length ? actualValue[i].ToSafeString() : "" // character safe string
+                            );
+
+                        isFirstDiff = false;
+                    }
+                }
+                //output.WriteLine();
+            }
+
             Assert.AreEqual(expectedValue, actualValue);
-            return;
         }
 
-        if (actualValue.Equals(expectedValue, StringComparison.Ordinal))
+        private static string ToSafeString(this char c)
         {
-            return;
-        }
-
-        Console.WriteLine();
-        output.WriteLine("Index    Expected     Actual");
-        output.WriteLine("----------------------------");
-        int maxLen = Math.Max(actualValue.Length, expectedValue.Length);
-        int minLen = Math.Min(actualValue.Length, expectedValue.Length);
-
-        if (diffStyle != DiffStyle.Minimal)
-        {
-            int startDifferAt = 0;
-            for (int i = 0; i < maxLen; i++)
+            if (char.IsControl(c) || char.IsWhiteSpace(c))
             {
-                if (i >= minLen || actualValue[i] != expectedValue[i])
+                switch (c)
                 {
-                    startDifferAt = i;
-                    break;
+                    case '\b':
+                        return @"\b";
+                    case '\r':
+                        return @"\r";
+                    case '\n':
+                        return @"\n";
+                    case '\t':
+                        return @"\t";
+                    case '\a':
+                        return @"\a";
+                    case '\v':
+                        return @"\v";
+                    case '\f':
+                        return @"\f";
+                    default:
+                        return $"\\u{(int) c:X};";
                 }
             }
-
-            var endDifferAt = Math.Min(startDifferAt + 10, maxLen);
-            startDifferAt = Math.Max(startDifferAt - 10, 0);
-
-            bool isFirstDiff = true;
-            for (int i = startDifferAt; i < endDifferAt; i++)
-            {
-                if (i >= minLen || actualValue[i] != expectedValue[i])
-                {
-                    output.WriteLine("{0,-3} {1,-3}    {2,-4} {3,-3}   {4,-4} {5,-3}",
-                        i < minLen && actualValue[i] == expectedValue[i] ? " " : isFirstDiff  ? ">>>": "***",
-                        // put a mark beside a differing row
-                        i, // the index
-                        i < expectedValue.Length ? ((int) expectedValue[i]).ToString() : "",
-                        // character decimal value
-                        i < expectedValue.Length ? expectedValue[i].ToSafeString() : "", // character safe string
-                        i < actualValue.Length ? ((int) actualValue[i]).ToString() : "", // character decimal value
-                        i < actualValue.Length ? actualValue[i].ToSafeString() : "" // character safe string
-                        );
-
-                    isFirstDiff = false;
-                }
-            }
-            //output.WriteLine();
+            return c.ToString(CultureInfo.InvariantCulture);
         }
-
-        Assert.AreEqual(expectedValue, actualValue);
-    }
-
-    private static string ToSafeString(this char c)
-    {
-        if (char.IsControl(c) || char.IsWhiteSpace(c))
-        {
-            switch (c)
-            {
-                case '\b':
-                    return @"\b";
-                case '\r':
-                    return @"\r";
-                case '\n':
-                    return @"\n";
-                case '\t':
-                    return @"\t";
-                case '\a':
-                    return @"\a";
-                case '\v':
-                    return @"\v";
-                case '\f':
-                    return @"\f";
-                default:
-                    return $"\\u{(int) c:X};";
-            }
-        }
-        return c.ToString(CultureInfo.InvariantCulture);
     }
 }

src/Markdig.WebApp/ApiController.cs

@@ -1,54 +1,55 @@
+using System;
 using System.Text;
-
 using Microsoft.AspNetCore.Mvc;
 
-namespace Markdig.WebApp;
-
-public class ApiController : Controller
+namespace Markdig.WebApp
 {
-    [HttpGet()]
-    [Route("")]
-    public new string Empty()
+    public class ApiController : Controller
     {
-        return string.Empty;
-    }
-
-    // GET api/to_html?text=xxx&extension=advanced
-    [Route("api/to_html")]
-    [HttpGet()]
-    public object Get([FromQuery] string text, [FromQuery] string extension)
-    {
-        try
+        [HttpGet()]
+        [Route("")]
+        public string Empty()
         {
-            if (text == null)
+            return string.Empty;
+        }
+
+        // GET api/to_html?text=xxx&extension=advanced
+        [Route("api/to_html")]
+        [HttpGet()]
+        public object Get([FromQuery] string text, [FromQuery] string extension)
+        {
+            try
             {
-                text = string.Empty;
-            }
+                if (text == null)
+                {
+                    text = string.Empty;
+                }
 
-            if (text.Length > 1000)
+                if (text.Length > 1000)
+                {
+                    text = text.Substring(0, 1000);
+                }
+
+                var pipeline = new MarkdownPipelineBuilder().Configure(extension).Build();
+                var result = Markdown.ToHtml(text, pipeline);
+
+                return new {name = "markdig", html = result, version = Markdown.Version};
+            }
+            catch (Exception ex)
             {
-                text = text.Substring(0, 1000);
+                return new { name = "markdig", html = "exception: " + GetPrettyMessageFromException(ex), version = Markdown.Version };
             }
-
-            var pipeline = new MarkdownPipelineBuilder().Configure(extension).Build();
-            var result = Markdown.ToHtml(text, pipeline);
-
-            return new {name = "markdig", html = result, version = Markdown.Version};
         }
-        catch (Exception ex)
+
+        private static string GetPrettyMessageFromException(Exception exception)
         {
-            return new { name = "markdig", html = "exception: " + GetPrettyMessageFromException(ex), version = Markdown.Version };
+            var builder = new StringBuilder();
+            while (exception != null)
+            {
+                builder.Append(exception.Message);
+                exception = exception.InnerException;
+            }
+            return builder.ToString();
         }
     }
-
-    private static string GetPrettyMessageFromException(Exception exception)
-    {
-        var builder = new StringBuilder();
-        while (exception != null)
-        {
-            builder.Append(exception.Message);
-            exception = exception.InnerException;
-        }
-        return builder.ToString();
-    }
 }

src/Markdig.WebApp/Markdig.WebApp.csproj

@@ -1,10 +1,9 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
-    <TargetFramework>net8.0</TargetFramework>
+    <TargetFramework>net6.0</TargetFramework>
     <PreserveCompilationContext>true</PreserveCompilationContext>
     <AssemblyName>Markdig.WebApp</AssemblyName>
-    <ImplicitUsings>enable</ImplicitUsings>
     <OutputType>Exe</OutputType>
     <PackageId>Markdig.WebApp</PackageId>
     <ApplicationInsightsResourceId>/subscriptions/b6745039-70e7-4641-994b-5457cb220e2a/resourcegroups/Default-ApplicationInsights-EastUS/providers/microsoft.insights/components/Markdig.WebApp</ApplicationInsightsResourceId>
@@ -14,7 +13,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.ApplicationInsights.AspNetCore" Version="2.22.0" />
+    <PackageReference Include="Microsoft.ApplicationInsights.AspNetCore" Version="2.20.0" />
   </ItemGroup>
 
   <ItemGroup>

src/Markdig.WebApp/Program.cs

@@ -1,16 +1,22 @@
-namespace Markdig.WebApp;
+using System.IO;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.Extensions.Hosting;
 
-public class Program
+namespace Markdig.WebApp
 {
-    public static void Main(string[] args)
+    public class Program
     {
-        CreateHostBuilder(args).Build().Run();
-    }
+        public static void Main(string[] args)
+        {
+            CreateHostBuilder(args).Build().Run();
+        }
 
-    public static IHostBuilder CreateHostBuilder(string[] args) =>
-        Host.CreateDefaultBuilder(args)
-            .ConfigureWebHostDefaults(webBuilder =>
-            {
-                webBuilder.UseStartup<Startup>();
-            });
+        public static IHostBuilder CreateHostBuilder(string[] args) =>
+            Host.CreateDefaultBuilder(args)
+                .ConfigureWebHostDefaults(webBuilder =>
+                {
+                    webBuilder.UseStartup<Startup>();
+                });
+    }
 }

src/Markdig.WebApp/Startup.cs

@@ -1,52 +1,60 @@
-namespace Markdig.WebApp;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
 
-public class Startup
+namespace Markdig.WebApp
 {
-    public Startup(IWebHostEnvironment env)
+    public class Startup
     {
-        var builder = new ConfigurationBuilder()
-            .SetBasePath(env.ContentRootPath)
-            .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
-            .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true);
-
-        if (env.IsEnvironment("Development"))
+        public Startup(IWebHostEnvironment env)
         {
-            // This will push telemetry data through Application Insights pipeline faster, allowing you to view results immediately.
-            builder.AddApplicationInsightsSettings(connectionString: null, developerMode: true);
+            var builder = new ConfigurationBuilder()
+                .SetBasePath(env.ContentRootPath)
+                .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
+                .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true);
+
+            if (env.IsEnvironment("Development"))
+            {
+                // This will push telemetry data through Application Insights pipeline faster, allowing you to view results immediately.
+                builder.AddApplicationInsightsSettings(developerMode: true);
+            }
+
+            builder.AddEnvironmentVariables();
+            Configuration = builder.Build();
         }
 
-        builder.AddEnvironmentVariables();
-        Configuration = builder.Build();
-    }
+        public IConfigurationRoot Configuration { get; }
 
-    public IConfigurationRoot Configuration { get; }
-
-    // This method gets called by the runtime. Use this method to add services to the container
-    public void ConfigureServices(IServiceCollection services)
-    {
-        services.AddControllers();
-        
-        // Add framework services.
-        services.AddApplicationInsightsTelemetry(Configuration);
-    }
-
-    // This method gets called by the runtime. Use this method to configure the HTTP request pipeline
-    public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ILoggerFactory loggerFactory)
-    {
-        if (env.IsDevelopment())
+        // This method gets called by the runtime. Use this method to add services to the container
+        public void ConfigureServices(IServiceCollection services)
         {
-            app.UseDeveloperExceptionPage();
+            services.AddControllers();
+            
+            // Add framework services.
+            services.AddApplicationInsightsTelemetry(Configuration);
         }
 
-        app.UseHttpsRedirection();
-
-        app.UseRouting();
-
-        app.UseAuthorization();
-
-        app.UseEndpoints(endpoints =>
+        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline
+        public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ILoggerFactory loggerFactory)
         {
-            endpoints.MapControllers();
-        });
+            if (env.IsDevelopment())
+            {
+                app.UseDeveloperExceptionPage();
+            }
+
+            app.UseHttpsRedirection();
+
+            app.UseRouting();
+
+            app.UseAuthorization();
+
+            app.UseEndpoints(endpoints =>
+            {
+                endpoints.MapControllers();
+            });
+        }
     }
 }

src/Markdig/Extensions/Abbreviations/Abbreviation.cs

@@ -7,35 +7,36 @@ using Markdig.Helpers;
 using Markdig.Parsers;
 using Markdig.Syntax;
 
-namespace Markdig.Extensions.Abbreviations;
-
-/// <summary>
-/// An abbreviation object stored at the document level. See extension methods in <see cref="AbbreviationHelper"/>.
-/// </summary>
-/// <seealso cref="LeafBlock" />
-[DebuggerDisplay("Abbr {Label} => {Text}")]
-public class Abbreviation : LeafBlock
+namespace Markdig.Extensions.Abbreviations
 {
     /// <summary>
-    /// Initializes a new instance of the <see cref="Abbreviation"/> class.
+    /// An abbreviation object stored at the document level. See extension methods in <see cref="AbbreviationHelper"/>.
     /// </summary>
-    /// <param name="parser">The parser used to create this block.</param>
-    public Abbreviation(BlockParser parser) : base(parser)
+    /// <seealso cref="LeafBlock" />
+    [DebuggerDisplay("Abbr {Label} => {Text}")]
+    public class Abbreviation : LeafBlock
     {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="Abbreviation"/> class.
+        /// </summary>
+        /// <param name="parser">The parser used to create this block.</param>
+        public Abbreviation(BlockParser parser) : base(parser)
+        {
+        }
+
+        /// <summary>
+        /// Gets or sets the label.
+        /// </summary>
+        public string? Label { get; set; }
+
+        /// <summary>
+        /// The text associated to this label.
+        /// </summary>
+        public StringSlice Text;
+
+        /// <summary>
+        /// The label span
+        /// </summary>
+        public SourceSpan LabelSpan;
     }
-
-    /// <summary>
-    /// Gets or sets the label.
-    /// </summary>
-    public string? Label { get; set; }
-
-    /// <summary>
-    /// The text associated to this label.
-    /// </summary>
-    public StringSlice Text;
-
-    /// <summary>
-    /// The label span
-    /// </summary>
-    public SourceSpan LabelSpan;
 }

src/Markdig/Extensions/Abbreviations/AbbreviationExtension.cs

@@ -4,25 +4,26 @@
 
 using Markdig.Renderers;
 
-namespace Markdig.Extensions.Abbreviations;
-
-/// <summary>
-/// Extension to allow abbreviations.
-/// </summary>
-/// <seealso cref="IMarkdownExtension" />
-public class AbbreviationExtension : IMarkdownExtension
+namespace Markdig.Extensions.Abbreviations
 {
-    public void Setup(MarkdownPipelineBuilder pipeline)
+    /// <summary>
+    /// Extension to allow abbreviations.
+    /// </summary>
+    /// <seealso cref="IMarkdownExtension" />
+    public class AbbreviationExtension : IMarkdownExtension
     {
-        pipeline.BlockParsers.AddIfNotAlready<AbbreviationParser>();
-    }
-
-    public void Setup(MarkdownPipeline pipeline, IMarkdownRenderer renderer)
-    {
-        if (renderer is HtmlRenderer htmlRenderer && !htmlRenderer.ObjectRenderers.Contains<HtmlAbbreviationRenderer>())
+        public void Setup(MarkdownPipelineBuilder pipeline)
         {
-            // Must be inserted before CodeBlockRenderer
-            htmlRenderer.ObjectRenderers.Insert(0, new HtmlAbbreviationRenderer());
+            pipeline.BlockParsers.AddIfNotAlready<AbbreviationParser>();
+        }
+
+        public void Setup(MarkdownPipeline pipeline, IMarkdownRenderer renderer)
+        {
+            if (renderer is HtmlRenderer htmlRenderer && !htmlRenderer.ObjectRenderers.Contains<HtmlAbbreviationRenderer>())
+            {
+                // Must be inserted before CodeBlockRenderer
+                htmlRenderer.ObjectRenderers.Insert(0, new HtmlAbbreviationRenderer());
+            }
         }
     }
 }

src/Markdig/Extensions/Abbreviations/AbbreviationHelper.cs

@@ -2,40 +2,42 @@
 // 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 Markdig.Helpers;
 using Markdig.Syntax;
 
-namespace Markdig.Extensions.Abbreviations;
-
-/// <summary>
-/// Extension methods for <see cref="Abbreviation"/>.
-/// </summary>
-public static class AbbreviationHelper
+namespace Markdig.Extensions.Abbreviations
 {
-    private static readonly object DocumentKey = typeof (Abbreviation);
-
-    public static bool HasAbbreviations(this MarkdownDocument document)
+    /// <summary>
+    /// Extension methods for <see cref="Abbreviation"/>.
+    /// </summary>
+    public static class AbbreviationHelper
     {
-        return document.GetAbbreviations() != null;
-    }
+        private static readonly object DocumentKey = typeof (Abbreviation);
 
-    public static void AddAbbreviation(this MarkdownDocument document, string label, Abbreviation abbr)
-    {
-        if (document is null) ThrowHelper.ArgumentNullException(nameof(document));
-        if (label is null) ThrowHelper.ArgumentNullException_label();
-        if (abbr is null) ThrowHelper.ArgumentNullException(nameof(abbr));
-
-        var map = document.GetAbbreviations();
-        if (map is null)
+        public static bool HasAbbreviations(this MarkdownDocument document)
         {
-            map = new Dictionary<string, Abbreviation>();
-            document.SetData(DocumentKey, map);
+            return document.GetAbbreviations() != null;
         }
-        map[label] = abbr;
-    }
 
-    public static Dictionary<string, Abbreviation>? GetAbbreviations(this MarkdownDocument document)
-    {
-        return document.GetData(DocumentKey) as Dictionary<string, Abbreviation>;
+        public static void AddAbbreviation(this MarkdownDocument document, string label, Abbreviation abbr)
+        {
+            if (document is null) ThrowHelper.ArgumentNullException(nameof(document));
+            if (label is null) ThrowHelper.ArgumentNullException_label();
+            if (abbr is null) ThrowHelper.ArgumentNullException(nameof(abbr));
+
+            var map = document.GetAbbreviations();
+            if (map is null)
+            {
+                map = new Dictionary<string, Abbreviation>();
+                document.SetData(DocumentKey, map);
+            }
+            map[label] = abbr;
+        }
+
+        public static Dictionary<string, Abbreviation>? GetAbbreviations(this MarkdownDocument document)
+        {
+            return document.GetData(DocumentKey) as Dictionary<string, Abbreviation>;
+        }
     }
 }

src/Markdig/Extensions/Abbreviations/AbbreviationInline.cs

@@ -5,23 +5,24 @@
 using System.Diagnostics;
 using Markdig.Syntax.Inlines;
 
-namespace Markdig.Extensions.Abbreviations;
-
-/// <summary>
-/// The inline abbreviation.
-/// </summary>
-/// <seealso cref="LeafInline" />
-[DebuggerDisplay("{Abbreviation}")]
-public class AbbreviationInline : LeafInline
+namespace Markdig.Extensions.Abbreviations
 {
     /// <summary>
-    /// Initializes a new instance of the <see cref="AbbreviationInline"/> class.
+    /// The inline abbreviation.
     /// </summary>
-    /// <param name="abbreviation">The abbreviation.</param>
-    public AbbreviationInline(Abbreviation abbreviation)
+    /// <seealso cref="LeafInline" />
+    [DebuggerDisplay("{Abbreviation}")]
+    public class AbbreviationInline : LeafInline
     {
-        Abbreviation = abbreviation;
-    }
+        /// <summary>
+        /// Initializes a new instance of the <see cref="AbbreviationInline"/> class.
+        /// </summary>
+        /// <param name="abbreviation">The abbreviation.</param>
+        public AbbreviationInline(Abbreviation abbreviation)
+        {
+            Abbreviation = abbreviation;
+        }
 
-    public Abbreviation Abbreviation { get; set; }
+        public Abbreviation Abbreviation { get; set; }
+    }
 }