From 5ac1a9b7b96def762614c0596b2df367b3d45fb0 Mon Sep 17 00:00:00 2001
From: David Allemang <david.allemang@kitware.com>
Date: Mon, 11 Nov 2024 12:03:37 -0500
Subject: [PATCH] fix example tests

---
 .envrc           |    3 +
 .gitignore       |    5 +
 build.zig        |    4 +-
 notes.md         |    2 +
 src/examples.zig | 3797 ++++++++++++++++++++++++++++++----------------
 src/main.zig     |   10 +-
 6 files changed, 2511 insertions(+), 1310 deletions(-)
 create mode 100644 .envrc
 create mode 100644 .gitignore

diff --git a/.envrc b/.envrc
new file mode 100644
index 0000000..08f9db7
--- /dev/null
+++ b/.envrc
@@ -0,0 +1,3 @@
+PATH_add zig-out/bin
+source .venv/bin/activate
+
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..e73c22a
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,5 @@
+.zig-cache/
+zig-out/
+
+.spec/
+
diff --git a/build.zig b/build.zig
index 813d69f..271bf91 100644
--- a/build.zig
+++ b/build.zig
@@ -38,7 +38,9 @@ pub fn build(b: *std.Build) void {
         .optimize = optimize,
     });
 
+    const run_example_tests = b.addRunArtifact(example_tests);
+
     const test_step = b.step("test", "Run unit tests");
     test_step.dependOn(&run_exe_unit_tests.step);
-    test_step.dependOn(&example_tests.step);
+    test_step.dependOn(&run_example_tests.step);
 }
diff --git a/notes.md b/notes.md
index 89a6f8a..20bc895 100644
--- a/notes.md
+++ b/notes.md
@@ -2,6 +2,8 @@ The spec is organized into "content blocks", "leaf blocks", and inline content.
 
 So the first task in the parser should be to parse the block structure.
 
+<https://spec.commonmark.org/0.31.2/>
+
 - Blocks
   - Leaf
     - Thematic break
diff --git a/src/examples.zig b/src/examples.zig
index 9fdfbdf..f097d96 100644
--- a/src/examples.zig
+++ b/src/examples.zig
@@ -1,24 +1,39 @@
 const std = @import("std");
 const convert = @import("main.zig").convert;
 
-comptime {
-    std.testing.refAllDecls(@This());
-}
 
 test "Example 1" {
-    return error.BBBBBBBBBBBBb;
+    const alloc = std.testing.allocator;
+
+    const md = (
+        \\→foo→baz→→bim
+
+);
+    const html = (
+        \\<pre><code>foo→baz→→bim
+        \\</code></pre>
+
+);
+
+    const output = try convert(alloc, md);
+    defer alloc.free(output);
+
+    try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 2" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\→foo→baz→→bim
-    );
+
+);
     const html = (
         \\<pre><code>foo→baz→→bim
         \\</code></pre>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -26,17 +41,20 @@ test "Example 2" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 3" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\a→a
-    );
+
+);
     const html = (
         \\<pre><code>a→a
         \\ὐ→a
         \\</code></pre>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -44,12 +62,13 @@ test "Example 3" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 4" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>
@@ -57,7 +76,8 @@ test "Example 4" {
         \\<p>bar</p>
         \\</li>
         \\</ul>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -65,18 +85,19 @@ test "Example 4" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 5" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>
         \\<p>foo</p>
         \\<pre><code>
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -84,16 +105,18 @@ test "Example 5" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 6" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\>→→foo
-    );
+
+);
     const html = (
         \\<blockquote>
         \\<pre><code>
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -101,17 +124,19 @@ test "Example 6" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 7" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-→→foo
-    );
+
+);
     const html = (
         \\<ul>
         \\<li>
         \\<pre><code>
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -119,18 +144,21 @@ test "Example 7" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 8" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo
         \\→bar
-    );
+
+);
     const html = (
         \\<pre><code>foo
         \\bar
         \\</code></pre>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -138,12 +166,13 @@ test "Example 8" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 9" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>foo
@@ -156,7 +185,8 @@ test "Example 9" {
         \\</ul>
         \\</li>
         \\</ul>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -164,15 +194,18 @@ test "Example 9" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 10" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\#→Foo
-    );
+
+);
     const html = (
         \\<h1>Foo</h1>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -180,15 +213,17 @@ test "Example 10" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 11" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\*→*→*→
-    );
+
+);
     const html = (
         \\<hr
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -196,15 +231,18 @@ test "Example 11" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 12" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\\!\"\#\$\%\&\'\(\)\*\+\,\-\.\/\:\;\<\=\>\?\@\[\\\]\^\_\`\{\|\}\~
-    );
+
+);
     const html = (
         \\<p>!&quot;#$%&amp;'()*+,-./:;&lt;=&gt;?@[\]^_`{|}~</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -212,15 +250,16 @@ test "Example 12" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 13" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\\→\A\a\
-    );
+);
     const html = (
         \\<p>\→\A\a\
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -228,15 +267,16 @@ test "Example 13" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 14" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\\*not
-    );
+);
     const html = (
         \\<p>*not
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -244,15 +284,18 @@ test "Example 14" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 15" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\\\*emphasis*
-    );
+
+);
     const html = (
         \\<p>\<em>emphasis</em></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -260,16 +303,18 @@ test "Example 15" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 16" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo\
         \\bar
-    );
+
+);
     const html = (
         \\<p>foo<br
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -277,15 +322,17 @@ test "Example 16" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 17" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\``
-    );
+);
     const html = (
         \\<p><code>\[\`</code></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -293,16 +340,19 @@ test "Example 17" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 18" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\\[\]
-    );
+
+);
     const html = (
         \\<pre><code>\[\]
         \\</code></pre>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -310,6 +360,7 @@ test "Example 18" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 19" {
     const alloc = std.testing.allocator;
 
@@ -317,11 +368,13 @@ test "Example 19" {
         \\~~~
         \\\[\]
         \\~~~
-    );
+
+);
     const html = (
         \\<pre><code>\[\]
         \\</code></pre>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -329,15 +382,17 @@ test "Example 19" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 20" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<https://example.com?find=\*>
-    );
+
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -345,15 +400,16 @@ test "Example 20" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 21" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<a
-    );
+);
     const html = (
         \\<a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -361,15 +417,16 @@ test "Example 21" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 22" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[foo](/bar\*
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -377,6 +434,7 @@ test "Example 22" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 23" {
     const alloc = std.testing.allocator;
 
@@ -384,10 +442,10 @@ test "Example 23" {
         \\[foo]
         \\
         \\[foo]:
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -395,15 +453,16 @@ test "Example 23" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 24" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\```
-    );
+);
     const html = (
         \\<pre><code
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -411,15 +470,16 @@ test "Example 24" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 25" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\&nbsp;
-    );
+);
     const html = (
         \\<p> 
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -427,15 +487,16 @@ test "Example 25" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 26" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\&#35;
-    );
+);
     const html = (
         \\<p>#
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -443,15 +504,16 @@ test "Example 26" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 27" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\&#X22;
-    );
+);
     const html = (
         \\<p>&quot;
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -459,15 +521,16 @@ test "Example 27" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 28" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\&nbsp
-    );
+);
     const html = (
         \\<p>&amp;nbsp
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -475,15 +538,18 @@ test "Example 28" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 29" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\&copy
-    );
+
+);
     const html = (
         \\<p>&amp;copy</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -491,15 +557,18 @@ test "Example 29" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 30" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\&MadeUpEntity;
-    );
+
+);
     const html = (
         \\<p>&amp;MadeUpEntity;</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -507,15 +576,16 @@ test "Example 30" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 31" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<a
-    );
+);
     const html = (
         \\<a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -523,15 +593,16 @@ test "Example 31" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 32" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[foo](/f&ouml;&ouml;
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -539,6 +610,7 @@ test "Example 32" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 33" {
     const alloc = std.testing.allocator;
 
@@ -546,10 +618,10 @@ test "Example 33" {
         \\[foo]
         \\
         \\[foo]:
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -557,15 +629,16 @@ test "Example 33" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 34" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\```
-    );
+);
     const html = (
         \\<pre><code
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -573,15 +646,18 @@ test "Example 34" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 35" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\`f&ouml;&ouml;`
-    );
+
+);
     const html = (
         \\<p><code>f&amp;ouml;&amp;ouml;</code></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -589,16 +665,19 @@ test "Example 35" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 36" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\f&ouml;f&ouml;
-    );
+
+);
     const html = (
         \\<pre><code>f&amp;ouml;f&amp;ouml;
         \\</code></pre>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -606,17 +685,20 @@ test "Example 36" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 37" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\&#42;foo&#42;
         \\*foo*
-    );
+
+);
     const html = (
         \\<p>*foo*
         \\<em>foo</em></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -624,15 +706,16 @@ test "Example 37" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 38" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\&#42;
-    );
+);
     const html = (
         \\<p>*
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -640,17 +723,20 @@ test "Example 38" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 39" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo&#10;&#10;bar
-    );
+
+);
     const html = (
         \\<p>foo
         \\
         \\bar</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -658,15 +744,18 @@ test "Example 39" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 40" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\&#9;foo
-    );
+
+);
     const html = (
         \\<p>→foo</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -674,15 +763,16 @@ test "Example 40" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 41" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[a](url
-    );
+);
     const html = (
         \\<p>[a](url
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -690,18 +780,20 @@ test "Example 41" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 42" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>`one</li>
         \\<li>two`</li>
         \\</ul>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -709,6 +801,7 @@ test "Example 42" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 43" {
     const alloc = std.testing.allocator;
 
@@ -716,10 +809,11 @@ test "Example 43" {
         \\***
         \\---
         \\___
-    );
+
+);
     const html = (
         \\<hr
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -727,15 +821,18 @@ test "Example 43" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 44" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\+++
-    );
+
+);
     const html = (
         \\<p>+++</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -743,15 +840,18 @@ test "Example 44" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 45" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\===
-    );
+
+);
     const html = (
         \\<p>===</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -759,6 +859,7 @@ test "Example 45" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 46" {
     const alloc = std.testing.allocator;
 
@@ -766,12 +867,14 @@ test "Example 46" {
         \\--
         \\**
         \\__
-    );
+
+);
     const html = (
         \\<p>--
         \\**
         \\__</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -779,15 +882,17 @@ test "Example 46" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 47" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\***
-    );
+
+);
     const html = (
         \\<hr
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -795,16 +900,19 @@ test "Example 47" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 48" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\***
-    );
+
+);
     const html = (
         \\<pre><code>***
         \\</code></pre>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -812,16 +920,19 @@ test "Example 48" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 49" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\Foo
-    );
+
+);
     const html = (
         \\<p>Foo
         \\***</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -829,15 +940,17 @@ test "Example 49" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 50" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\_____________________________________
-    );
+
+);
     const html = (
         \\<hr
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -845,15 +958,16 @@ test "Example 50" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 51" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<hr
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -861,15 +975,16 @@ test "Example 51" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 52" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\**
-    );
+);
     const html = (
         \\<hr
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -877,15 +992,16 @@ test "Example 52" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 53" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<hr
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -893,15 +1009,16 @@ test "Example 53" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 54" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<hr
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -909,15 +1026,16 @@ test "Example 54" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 55" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\_
-    );
+);
     const html = (
         \\<p>_
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -925,15 +1043,18 @@ test "Example 55" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 56" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\*-*
-    );
+
+);
     const html = (
         \\<p><em>-</em></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -941,18 +1062,19 @@ test "Example 56" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 57" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>foo</li>
         \\</ul>
         \\<hr
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -960,6 +1082,7 @@ test "Example 57" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 58" {
     const alloc = std.testing.allocator;
 
@@ -967,11 +1090,12 @@ test "Example 58" {
         \\Foo
         \\***
         \\bar
-    );
+
+);
     const html = (
         \\<p>Foo</p>
         \\<hr
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -979,6 +1103,7 @@ test "Example 58" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 59" {
     const alloc = std.testing.allocator;
 
@@ -986,11 +1111,13 @@ test "Example 59" {
         \\Foo
         \\---
         \\bar
-    );
+
+);
     const html = (
         \\<h2>Foo</h2>
         \\<p>bar</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -998,18 +1125,19 @@ test "Example 59" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 60" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\*
-    );
+);
     const html = (
         \\<ul>
         \\<li>Foo</li>
         \\</ul>
         \\<hr
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1017,18 +1145,19 @@ test "Example 60" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 61" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>Foo</li>
         \\<li>
         \\<hr
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1036,12 +1165,13 @@ test "Example 61" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 62" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\#
-    );
+);
     const html = (
         \\<h1>foo</h1>
         \\<h2>foo</h2>
@@ -1049,7 +1179,8 @@ test "Example 62" {
         \\<h4>foo</h4>
         \\<h5>foo</h5>
         \\<h6>foo</h6>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1057,15 +1188,16 @@ test "Example 62" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 63" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\#######
-    );
+);
     const html = (
         \\<p>#######
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1073,15 +1205,16 @@ test "Example 63" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 64" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\#5
-    );
+);
     const html = (
         \\<p>#5
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1089,15 +1222,16 @@ test "Example 64" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 65" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\\##
-    );
+);
     const html = (
         \\<p>##
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1105,15 +1239,16 @@ test "Example 65" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 66" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\#
-    );
+);
     const html = (
         \\<h1>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1121,15 +1256,17 @@ test "Example 66" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 67" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\#
-    );
+);
     const html = (
         \\<h1>foo</h1>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1137,17 +1274,19 @@ test "Example 67" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 68" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\###
-    );
+);
     const html = (
         \\<h3>foo</h3>
         \\<h2>foo</h2>
         \\<h1>foo</h1>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1155,15 +1294,16 @@ test "Example 68" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 69" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\#
-    );
+);
     const html = (
         \\<pre><code>#
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1171,16 +1311,18 @@ test "Example 69" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 70" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo
-    );
+
+);
     const html = (
         \\<p>foo
         \\#
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1188,16 +1330,18 @@ test "Example 70" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 71" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\##
-    );
+);
     const html = (
         \\<h2>foo</h2>
         \\<h3>bar</h3>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1205,16 +1349,18 @@ test "Example 71" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 72" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\#
-    );
+);
     const html = (
         \\<h1>foo</h1>
         \\<h5>foo</h5>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1222,15 +1368,17 @@ test "Example 72" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 73" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\###
-    );
+);
     const html = (
         \\<h3>foo</h3>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1238,15 +1386,16 @@ test "Example 73" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 74" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\###
-    );
+);
     const html = (
         \\<h3>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1254,15 +1403,17 @@ test "Example 74" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 75" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\#
-    );
+);
     const html = (
         \\<h1>foo#</h1>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1270,15 +1421,16 @@ test "Example 75" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 76" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\###
-    );
+);
     const html = (
         \\<h3>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1286,16 +1438,17 @@ test "Example 76" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 77" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\****
         \\##
-    );
+);
     const html = (
         \\<hr
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1303,15 +1456,16 @@ test "Example 77" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 78" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\Foo
-    );
+);
     const html = (
         \\<p>Foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1319,17 +1473,19 @@ test "Example 78" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 79" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\##
-    );
+);
     const html = (
         \\<h2></h2>
         \\<h1></h1>
         \\<h3></h3>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1337,15 +1493,16 @@ test "Example 79" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 80" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\Foo
-    );
+);
     const html = (
         \\<h1>Foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1353,15 +1510,16 @@ test "Example 80" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 81" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\Foo
-    );
+);
     const html = (
         \\<h1>Foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1369,15 +1527,16 @@ test "Example 81" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 82" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\Foo
-    );
+);
     const html = (
         \\<h1>Foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1385,6 +1544,7 @@ test "Example 82" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 83" {
     const alloc = std.testing.allocator;
 
@@ -1394,11 +1554,13 @@ test "Example 83" {
         \\
         \\Foo
         \\=
-    );
+
+);
     const html = (
         \\<h2>Foo</h2>
         \\<h1>Foo</h1>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1406,6 +1568,7 @@ test "Example 83" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 84" {
     const alloc = std.testing.allocator;
 
@@ -1413,12 +1576,14 @@ test "Example 84" {
         \\Foo
         \\---
         \\
-    );
+
+);
     const html = (
         \\<h2>Foo</h2>
         \\<h2>Foo</h2>
         \\<h1>Foo</h1>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1426,12 +1591,14 @@ test "Example 84" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 85" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\Foo
-    );
+
+);
     const html = (
         \\<pre><code>Foo
         \\---
@@ -1439,7 +1606,7 @@ test "Example 85" {
         \\Foo
         \\</code></pre>
         \\<hr
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1447,15 +1614,18 @@ test "Example 85" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 86" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\Foo
-    );
+
+);
     const html = (
         \\<h2>Foo</h2>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1463,16 +1633,19 @@ test "Example 86" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 87" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\Foo
-    );
+
+);
     const html = (
         \\<p>Foo
         \\---</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1480,17 +1653,18 @@ test "Example 87" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 88" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\Foo
         \\=
-    );
+);
     const html = (
         \\<p>Foo
         \\=
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1498,15 +1672,17 @@ test "Example 88" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 89" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\Foo
-    );
+);
     const html = (
         \\<h2>Foo</h2>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1514,16 +1690,19 @@ test "Example 89" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 90" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\Foo\
         \\----
-    );
+
+);
     const html = (
         \\<h2>Foo\</h2>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1531,6 +1710,7 @@ test "Example 90" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 91" {
     const alloc = std.testing.allocator;
 
@@ -1540,12 +1720,12 @@ test "Example 91" {
         \\`
         \\
         \\<a
-    );
+);
     const html = (
         \\<h2>`Foo</h2>
         \\<p>`</p>
         \\<h2>&lt;a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1553,18 +1733,19 @@ test "Example 91" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 92" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\>
-    );
+);
     const html = (
         \\<blockquote>
         \\<p>Foo</p>
         \\</blockquote>
         \\<hr
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1572,19 +1753,21 @@ test "Example 92" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 93" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\>
-    );
+);
     const html = (
         \\<blockquote>
         \\<p>foo
         \\bar
         \\===</p>
         \\</blockquote>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1592,18 +1775,19 @@ test "Example 93" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 94" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>Foo</li>
         \\</ul>
         \\<hr
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1611,6 +1795,7 @@ test "Example 94" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 95" {
     const alloc = std.testing.allocator;
 
@@ -1618,11 +1803,13 @@ test "Example 95" {
         \\Foo
         \\Bar
         \\---
-    );
+
+);
     const html = (
         \\<h2>Foo
         \\Bar</h2>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1630,6 +1817,7 @@ test "Example 95" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 96" {
     const alloc = std.testing.allocator;
 
@@ -1640,10 +1828,11 @@ test "Example 96" {
         \\Bar
         \\---
         \\Baz
-    );
+
+);
     const html = (
         \\<hr
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1651,16 +1840,19 @@ test "Example 96" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 97" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\
         \\====
-    );
+
+);
     const html = (
         \\<p>====</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1668,16 +1860,18 @@ test "Example 97" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 98" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\---
         \\---
-    );
+
+);
     const html = (
         \\<hr
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1685,18 +1879,19 @@ test "Example 98" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 99" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>foo</li>
         \\</ul>
         \\<hr
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1704,18 +1899,20 @@ test "Example 99" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 100" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo
         \\---
-    );
+
+);
     const html = (
         \\<pre><code>foo
         \\</code></pre>
         \\<hr
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1723,18 +1920,19 @@ test "Example 100" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 101" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\>
-    );
+);
     const html = (
         \\<blockquote>
         \\<p>foo</p>
         \\</blockquote>
         \\<hr
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1742,15 +1940,16 @@ test "Example 101" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 102" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\\>
-    );
+);
     const html = (
         \\<h2>&gt;
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1758,6 +1957,7 @@ test "Example 102" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 103" {
     const alloc = std.testing.allocator;
 
@@ -1767,12 +1967,14 @@ test "Example 103" {
         \\bar
         \\---
         \\baz
-    );
+
+);
     const html = (
         \\<p>Foo</p>
         \\<h2>bar</h2>
         \\<p>baz</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1780,6 +1982,7 @@ test "Example 103" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 104" {
     const alloc = std.testing.allocator;
 
@@ -1790,12 +1993,13 @@ test "Example 104" {
         \\---
         \\
         \\baz
-    );
+
+);
     const html = (
         \\<p>Foo
         \\bar</p>
         \\<hr
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1803,6 +2007,7 @@ test "Example 104" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 105" {
     const alloc = std.testing.allocator;
 
@@ -1810,12 +2015,12 @@ test "Example 105" {
         \\Foo
         \\bar
         \\*
-    );
+);
     const html = (
         \\<p>Foo
         \\bar</p>
         \\<hr
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1823,6 +2028,7 @@ test "Example 105" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 106" {
     const alloc = std.testing.allocator;
 
@@ -1831,13 +2037,15 @@ test "Example 106" {
         \\bar
         \\\---
         \\baz
-    );
+
+);
     const html = (
         \\<p>Foo
         \\bar
         \\---
         \\baz</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1845,15 +2053,16 @@ test "Example 106" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 107" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\a
-    );
+);
     const html = (
         \\<pre><code>a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1861,12 +2070,13 @@ test "Example 107" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 108" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>
@@ -1874,7 +2084,8 @@ test "Example 108" {
         \\<p>bar</p>
         \\</li>
         \\</ul>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1882,12 +2093,13 @@ test "Example 108" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 109" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\1.
-    );
+);
     const html = (
         \\<ol>
         \\<li>
@@ -1897,7 +2109,8 @@ test "Example 109" {
         \\</ul>
         \\</li>
         \\</ol>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1905,18 +2118,20 @@ test "Example 109" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 110" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<a/>
-    );
+
+);
     const html = (
         \\<pre><code>&lt;a/&gt;
         \\*hi*
         \\
         \\-
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1924,13 +2139,15 @@ test "Example 110" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 111" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\chunk1
         \\
-    );
+
+);
     const html = (
         \\<pre><code>chunk1
         \\
@@ -1940,7 +2157,8 @@ test "Example 111" {
         \\
         \\chunk3
         \\</code></pre>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1948,15 +2166,18 @@ test "Example 111" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 112" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\chunk1
-    );
+
+);
     const html = (
         \\<pre><code>chunk1
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1964,16 +2185,19 @@ test "Example 112" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 113" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\Foo
-    );
+
+);
     const html = (
         \\<p>Foo
         \\bar</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -1981,18 +2205,21 @@ test "Example 113" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 114" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo
         \\bar
-    );
+
+);
     const html = (
         \\<pre><code>foo
         \\</code></pre>
         \\<p>bar</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2000,12 +2227,13 @@ test "Example 114" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 115" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\#
-    );
+);
     const html = (
         \\<h1>Heading</h1>
         \\<pre><code>foo
@@ -2014,7 +2242,7 @@ test "Example 115" {
         \\<pre><code>foo
         \\</code></pre>
         \\<hr
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2022,15 +2250,17 @@ test "Example 115" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 116" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo
-    );
+
+);
     const html = (
         \\<pre><code>
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2038,16 +2268,19 @@ test "Example 116" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 117" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\
-    );
+
+);
     const html = (
         \\<pre><code>foo
         \\</code></pre>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2055,15 +2288,16 @@ test "Example 117" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 118" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo
-    );
+);
     const html = (
         \\<pre><code>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2071,16 +2305,19 @@ test "Example 118" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 119" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\```
         \\<
-    );
+
+);
     const html = (
         \\<pre><code>&lt;
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2088,16 +2325,19 @@ test "Example 119" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 120" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\~~~
         \\<
-    );
+
+);
     const html = (
         \\<pre><code>&lt;
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2105,6 +2345,7 @@ test "Example 120" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 121" {
     const alloc = std.testing.allocator;
 
@@ -2112,10 +2353,12 @@ test "Example 121" {
         \\``
         \\foo
         \\``
-    );
+
+);
     const html = (
         \\<p><code>foo</code></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2123,6 +2366,7 @@ test "Example 121" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 122" {
     const alloc = std.testing.allocator;
 
@@ -2131,12 +2375,14 @@ test "Example 122" {
         \\aaa
         \\~~~
         \\```
-    );
+
+);
     const html = (
         \\<pre><code>aaa
         \\~~~
         \\</code></pre>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2144,6 +2390,7 @@ test "Example 122" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 123" {
     const alloc = std.testing.allocator;
 
@@ -2152,12 +2399,14 @@ test "Example 123" {
         \\aaa
         \\```
         \\~~~
-    );
+
+);
     const html = (
         \\<pre><code>aaa
         \\```
         \\</code></pre>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2165,6 +2414,7 @@ test "Example 123" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 124" {
     const alloc = std.testing.allocator;
 
@@ -2173,12 +2423,14 @@ test "Example 124" {
         \\aaa
         \\```
         \\``````
-    );
+
+);
     const html = (
         \\<pre><code>aaa
         \\```
         \\</code></pre>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2186,6 +2438,7 @@ test "Example 124" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 125" {
     const alloc = std.testing.allocator;
 
@@ -2194,12 +2447,14 @@ test "Example 125" {
         \\aaa
         \\~~~
         \\~~~~
-    );
+
+);
     const html = (
         \\<pre><code>aaa
         \\~~~
         \\</code></pre>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2207,15 +2462,18 @@ test "Example 125" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 126" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\```
-    );
+
+);
     const html = (
         \\<pre><code></code></pre>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2223,6 +2481,7 @@ test "Example 126" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 127" {
     const alloc = std.testing.allocator;
 
@@ -2231,13 +2490,15 @@ test "Example 127" {
         \\
         \\```
         \\aaa
-    );
+
+);
     const html = (
         \\<pre><code>
         \\```
         \\aaa
         \\</code></pre>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2245,19 +2506,21 @@ test "Example 127" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 128" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\>
-    );
+);
     const html = (
         \\<blockquote>
         \\<pre><code>aaa
         \\</code></pre>
         \\</blockquote>
         \\<p>bbb</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2265,16 +2528,19 @@ test "Example 128" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 129" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\```
         \\
-    );
+
+);
     const html = (
         \\<pre><code>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2282,16 +2548,19 @@ test "Example 129" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 130" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\```
         \\```
-    );
+
+);
     const html = (
         \\<pre><code></code></pre>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2299,17 +2568,20 @@ test "Example 130" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 131" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\```
-    );
+
+);
     const html = (
         \\<pre><code>aaa
         \\aaa
         \\</code></pre>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2317,19 +2589,22 @@ test "Example 131" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 132" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\```
         \\aaa
-    );
+
+);
     const html = (
         \\<pre><code>aaa
         \\aaa
         \\aaa
         \\</code></pre>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2337,15 +2612,18 @@ test "Example 132" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 133" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\```
-    );
+
+);
     const html = (
         \\<pre><code>aaa
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2353,18 +2631,21 @@ test "Example 133" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 134" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\```
-    );
+
+);
     const html = (
         \\<pre><code>```
         \\aaa
         \\```
         \\</code></pre>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2372,17 +2653,20 @@ test "Example 134" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 135" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\```
         \\aaa
-    );
+
+);
     const html = (
         \\<pre><code>aaa
         \\</code></pre>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2390,17 +2674,20 @@ test "Example 135" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 136" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\```
         \\aaa
-    );
+
+);
     const html = (
         \\<pre><code>aaa
         \\</code></pre>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2408,16 +2695,19 @@ test "Example 136" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 137" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\```
         \\aaa
-    );
+
+);
     const html = (
         \\<pre><code>aaa
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2425,15 +2715,16 @@ test "Example 137" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 138" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\```
-    );
+);
     const html = (
         \\<p><code>
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2441,6 +2732,7 @@ test "Example 138" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 139" {
     const alloc = std.testing.allocator;
 
@@ -2448,11 +2740,11 @@ test "Example 139" {
         \\~~~~~~
         \\aaa
         \\~~~
-    );
+);
     const html = (
         \\<pre><code>aaa
         \\~~~
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2460,6 +2752,7 @@ test "Example 139" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 140" {
     const alloc = std.testing.allocator;
 
@@ -2469,13 +2762,15 @@ test "Example 140" {
         \\bar
         \\```
         \\baz
-    );
+
+);
     const html = (
         \\<p>foo</p>
         \\<pre><code>bar
         \\</code></pre>
         \\<p>baz</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2483,6 +2778,7 @@ test "Example 140" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 141" {
     const alloc = std.testing.allocator;
 
@@ -2493,13 +2789,14 @@ test "Example 141" {
         \\bar
         \\~~~
         \\#
-    );
+);
     const html = (
         \\<h2>foo</h2>
         \\<pre><code>bar
         \\</code></pre>
         \\<h1>baz</h1>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2507,16 +2804,17 @@ test "Example 141" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 142" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\```ruby
         \\def
-    );
+);
     const html = (
         \\<pre><code
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2524,15 +2822,16 @@ test "Example 142" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 143" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\~~~~
-    );
+);
     const html = (
         \\<pre><code
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2540,16 +2839,18 @@ test "Example 143" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 144" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\````;
         \\````
-    );
+
+);
     const html = (
         \\<pre><code
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2557,16 +2858,18 @@ test "Example 144" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 145" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\```
-    );
+);
     const html = (
         \\<p><code>aa</code>
         \\foo</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2574,15 +2877,16 @@ test "Example 145" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 146" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\~~~
-    );
+);
     const html = (
         \\<pre><code
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2590,16 +2894,17 @@ test "Example 146" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 147" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\```
         \\```
-    );
+);
     const html = (
         \\<pre><code>```
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2607,6 +2912,7 @@ test "Example 147" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 148" {
     const alloc = std.testing.allocator;
 
@@ -2618,7 +2924,8 @@ test "Example 148" {
         \\_world_.
         \\</pre>
         \\</td></tr></table>
-    );
+
+);
     const html = (
         \\<table><tr><td>
         \\<pre>
@@ -2626,7 +2933,8 @@ test "Example 148" {
         \\<p><em>world</em>.
         \\</pre></p>
         \\</td></tr></table>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2634,15 +2942,18 @@ test "Example 148" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 149" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<table>
-    );
+
+);
     const html = (
         \\<table>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2650,15 +2961,18 @@ test "Example 149" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 150" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<div>
-    );
+
+);
     const html = (
         \\<div>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2666,17 +2980,20 @@ test "Example 150" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 151" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\</div>
         \\*foo*
-    );
+
+);
     const html = (
         \\</div>
         \\*foo*
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2684,15 +3001,16 @@ test "Example 151" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 152" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<DIV
-    );
+);
     const html = (
         \\<DIV
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2700,15 +3018,16 @@ test "Example 152" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 153" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<div
-    );
+);
     const html = (
         \\<div
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2716,15 +3035,16 @@ test "Example 153" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 154" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<div
-    );
+);
     const html = (
         \\<div
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2732,6 +3052,7 @@ test "Example 154" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 155" {
     const alloc = std.testing.allocator;
 
@@ -2740,12 +3061,14 @@ test "Example 155" {
         \\*foo*
         \\
         \\*bar*
-    );
+
+);
     const html = (
         \\<div>
         \\*foo*
         \\<p><em>bar</em></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2753,15 +3076,16 @@ test "Example 155" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 156" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<div
-    );
+);
     const html = (
         \\<div
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2769,15 +3093,16 @@ test "Example 156" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 157" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<div
-    );
+);
     const html = (
         \\<div
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2785,15 +3110,16 @@ test "Example 157" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 158" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<div
-    );
+);
     const html = (
         \\<div
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2801,15 +3127,16 @@ test "Example 158" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 159" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<div><a
-    );
+);
     const html = (
         \\<div><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2817,6 +3144,7 @@ test "Example 159" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 160" {
     const alloc = std.testing.allocator;
 
@@ -2824,12 +3152,14 @@ test "Example 160" {
         \\<table><tr><td>
         \\foo
         \\</td></tr></table>
-    );
+
+);
     const html = (
         \\<table><tr><td>
         \\foo
         \\</td></tr></table>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2837,17 +3167,18 @@ test "Example 160" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 161" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<div></div>
         \\```
-    );
+);
     const html = (
         \\<div></div>
         \\```
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2855,15 +3186,16 @@ test "Example 161" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 162" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<a
-    );
+);
     const html = (
         \\<a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2871,6 +3203,7 @@ test "Example 162" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 163" {
     const alloc = std.testing.allocator;
 
@@ -2878,12 +3211,14 @@ test "Example 163" {
         \\<Warning>
         \\*bar*
         \\</Warning>
-    );
+
+);
     const html = (
         \\<Warning>
         \\*bar*
         \\</Warning>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2891,15 +3226,16 @@ test "Example 163" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 164" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<i
-    );
+);
     const html = (
         \\<i
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2907,17 +3243,20 @@ test "Example 164" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 165" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\</ins>
         \\*bar*
-    );
+
+);
     const html = (
         \\</ins>
         \\*bar*
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2925,6 +3264,7 @@ test "Example 165" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 166" {
     const alloc = std.testing.allocator;
 
@@ -2932,12 +3272,14 @@ test "Example 166" {
         \\<del>
         \\*foo*
         \\</del>
-    );
+
+);
     const html = (
         \\<del>
         \\*foo*
         \\</del>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2945,6 +3287,7 @@ test "Example 166" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 167" {
     const alloc = std.testing.allocator;
 
@@ -2954,12 +3297,14 @@ test "Example 167" {
         \\*foo*
         \\
         \\</del>
-    );
+
+);
     const html = (
         \\<del>
         \\<p><em>foo</em></p>
         \\</del>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2967,15 +3312,18 @@ test "Example 167" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 168" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<del>*foo*</del>
-    );
+
+);
     const html = (
         \\<p><del><em>foo</em></del></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2983,15 +3331,16 @@ test "Example 168" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 169" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<pre
-    );
+);
     const html = (
         \\<pre
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -2999,15 +3348,16 @@ test "Example 169" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 170" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<script
-    );
+);
     const html = (
         \\<script
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3015,6 +3365,7 @@ test "Example 170" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 171" {
     const alloc = std.testing.allocator;
 
@@ -3026,7 +3377,8 @@ test "Example 171" {
         \\_bar_
         \\
         \\</textarea>
-    );
+
+);
     const html = (
         \\<textarea>
         \\
@@ -3035,7 +3387,8 @@ test "Example 171" {
         \\_bar_
         \\
         \\</textarea>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3043,15 +3396,18 @@ test "Example 171" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 172" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<style
-    );
+
+);
     const html = (
         \\<style
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3059,15 +3415,18 @@ test "Example 172" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 173" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<style
-    );
+
+);
     const html = (
         \\<style
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3075,19 +3434,21 @@ test "Example 173" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 174" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\>
-    );
+);
     const html = (
         \\<blockquote>
         \\<div>
         \\foo
         \\</blockquote>
         \\<p>bar</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3095,12 +3456,13 @@ test "Example 174" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 175" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>
@@ -3108,7 +3470,8 @@ test "Example 175" {
         \\</li>
         \\<li>foo</li>
         \\</ul>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3116,17 +3479,20 @@ test "Example 175" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 176" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<style>p{color:red;}</style>
         \\*foo*
-    );
+
+);
     const html = (
         \\<style>p{color:red;}</style>
         \\<p><em>foo</em></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3134,15 +3500,16 @@ test "Example 176" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 177" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<!--
-    );
+);
     const html = (
         \\<!--
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3150,6 +3517,7 @@ test "Example 177" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 178" {
     const alloc = std.testing.allocator;
 
@@ -3157,12 +3525,12 @@ test "Example 178" {
         \\<script>
         \\foo
         \\</script>1.
-    );
+);
     const html = (
         \\<script>
         \\foo
         \\</script>1.
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3170,15 +3538,16 @@ test "Example 178" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 179" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<!--
-    );
+);
     const html = (
         \\<!--
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3186,17 +3555,20 @@ test "Example 179" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 180" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<?php
         \\
-    );
+
+);
     const html = (
         \\<?php
         \\
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3204,15 +3576,16 @@ test "Example 180" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 181" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<!DOCTYPE
-    );
+);
     const html = (
         \\<!DOCTYPE
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3220,17 +3593,18 @@ test "Example 181" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 182" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<![CDATA[
         \\function
-    );
+);
     const html = (
         \\<![CDATA[
         \\function
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3238,15 +3612,16 @@ test "Example 182" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 183" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<!--
-    );
+);
     const html = (
         \\<!--
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3254,18 +3629,21 @@ test "Example 183" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 184" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<div>
         \\
-    );
+
+);
     const html = (
         \\<div>
         \\<pre><code>&lt;div&gt;
         \\</code></pre>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3273,6 +3651,7 @@ test "Example 184" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 185" {
     const alloc = std.testing.allocator;
 
@@ -3281,13 +3660,15 @@ test "Example 185" {
         \\<div>
         \\bar
         \\</div>
-    );
+
+);
     const html = (
         \\<p>Foo</p>
         \\<div>
         \\bar
         \\</div>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3295,6 +3676,7 @@ test "Example 185" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 186" {
     const alloc = std.testing.allocator;
 
@@ -3303,13 +3685,15 @@ test "Example 186" {
         \\bar
         \\</div>
         \\*foo*
-    );
+
+);
     const html = (
         \\<div>
         \\bar
         \\</div>
         \\*foo*
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3317,17 +3701,18 @@ test "Example 186" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 187" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\Foo
         \\<a
-    );
+);
     const html = (
         \\<p>Foo
         \\<a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3335,6 +3720,7 @@ test "Example 187" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 188" {
     const alloc = std.testing.allocator;
 
@@ -3342,11 +3728,11 @@ test "Example 188" {
         \\<div>
         \\
         \\*Emphasized*
-    );
+);
     const html = (
         \\<div>
         \\<p><em>Emphasized</em>
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3354,17 +3740,18 @@ test "Example 188" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 189" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<div>
         \\*Emphasized*
-    );
+);
     const html = (
         \\<div>
         \\*Emphasized*
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3372,6 +3759,7 @@ test "Example 189" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 190" {
     const alloc = std.testing.allocator;
 
@@ -3387,7 +3775,8 @@ test "Example 190" {
         \\</tr>
         \\
         \\</table>
-    );
+
+);
     const html = (
         \\<table>
         \\<tr>
@@ -3396,7 +3785,8 @@ test "Example 190" {
         \\</td>
         \\</tr>
         \\</table>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3404,16 +3794,19 @@ test "Example 190" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 191" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<table>
         \\
-    );
+
+);
     const html = (
         \\<table>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3421,15 +3814,16 @@ test "Example 191" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 192" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[foo]:
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3437,15 +3831,16 @@ test "Example 192" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 193" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[foo]:
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3453,15 +3848,16 @@ test "Example 193" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 194" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[Foo*bar\]]:my_(url)
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3469,15 +3865,16 @@ test "Example 194" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 195" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[Foo
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3485,15 +3882,16 @@ test "Example 195" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 196" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[foo]:
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3501,15 +3899,16 @@ test "Example 196" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 197" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[foo]:
-    );
+);
     const html = (
         \\<p>[foo]:
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3517,6 +3916,7 @@ test "Example 197" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 198" {
     const alloc = std.testing.allocator;
 
@@ -3525,10 +3925,11 @@ test "Example 198" {
         \\/url
         \\
         \\[foo]
-    );
+
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3536,6 +3937,7 @@ test "Example 198" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 199" {
     const alloc = std.testing.allocator;
 
@@ -3543,11 +3945,13 @@ test "Example 199" {
         \\[foo]:
         \\
         \\[foo]
-    );
+
+);
     const html = (
         \\<p>[foo]:</p>
         \\<p>[foo]</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3555,15 +3959,16 @@ test "Example 199" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 200" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[foo]:
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3571,15 +3976,16 @@ test "Example 200" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 201" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[foo]:
-    );
+);
     const html = (
         \\<p>[foo]:
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3587,15 +3993,16 @@ test "Example 201" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 202" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[foo]:
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3603,6 +4010,7 @@ test "Example 202" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 203" {
     const alloc = std.testing.allocator;
 
@@ -3610,10 +4018,10 @@ test "Example 203" {
         \\[foo]
         \\
         \\[foo]:
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3621,6 +4029,7 @@ test "Example 203" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 204" {
     const alloc = std.testing.allocator;
 
@@ -3628,10 +4037,10 @@ test "Example 204" {
         \\[foo]
         \\
         \\[foo]:
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3639,15 +4048,16 @@ test "Example 204" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 205" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[FOO]:
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3655,15 +4065,16 @@ test "Example 205" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 206" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[ΑΓΩ]:
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3671,13 +4082,16 @@ test "Example 206" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 207" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[foo]:
-    );
-    const html = ("");
+);
+    const html = (
+""
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3685,6 +4099,7 @@ test "Example 207" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 208" {
     const alloc = std.testing.allocator;
 
@@ -3692,10 +4107,11 @@ test "Example 208" {
         \\[
         \\foo
         \\]:
-    );
+);
     const html = (
         \\<p>bar</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3703,15 +4119,16 @@ test "Example 208" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 209" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[foo]:
-    );
+);
     const html = (
         \\<p>[foo]:
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3719,15 +4136,16 @@ test "Example 209" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 210" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[foo]:
-    );
+);
     const html = (
         \\<p>&quot;title&quot;
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3735,15 +4153,16 @@ test "Example 210" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 211" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[foo]:
-    );
+);
     const html = (
         \\<pre><code>[foo]:
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3751,16 +4170,17 @@ test "Example 211" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 212" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\```
         \\[foo]:
-    );
+);
     const html = (
         \\<pre><code>[foo]:
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3768,17 +4188,18 @@ test "Example 212" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 213" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\Foo
         \\[bar]:
-    );
+);
     const html = (
         \\<p>Foo
         \\[bar]:
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3786,15 +4207,16 @@ test "Example 213" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 214" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\#
-    );
+);
     const html = (
         \\<h1><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3802,16 +4224,17 @@ test "Example 214" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 215" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[foo]:
-    );
+);
     const html = (
         \\<h1>bar</h1>
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3819,16 +4242,17 @@ test "Example 215" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 216" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[foo]:
-    );
+);
     const html = (
         \\<p>===
         \\<a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3836,15 +4260,16 @@ test "Example 216" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 217" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[foo]:
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3852,6 +4277,7 @@ test "Example 217" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 218" {
     const alloc = std.testing.allocator;
 
@@ -3859,10 +4285,10 @@ test "Example 218" {
         \\[foo]
         \\
         \\>
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3870,6 +4296,7 @@ test "Example 218" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 219" {
     const alloc = std.testing.allocator;
 
@@ -3877,11 +4304,13 @@ test "Example 219" {
         \\aaa
         \\
         \\bbb
-    );
+
+);
     const html = (
         \\<p>aaa</p>
         \\<p>bbb</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3889,6 +4318,7 @@ test "Example 219" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 220" {
     const alloc = std.testing.allocator;
 
@@ -3898,13 +4328,15 @@ test "Example 220" {
         \\
         \\ccc
         \\ddd
-    );
+
+);
     const html = (
         \\<p>aaa
         \\bbb</p>
         \\<p>ccc
         \\ddd</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3912,6 +4344,7 @@ test "Example 220" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 221" {
     const alloc = std.testing.allocator;
 
@@ -3920,11 +4353,13 @@ test "Example 221" {
         \\
         \\
         \\bbb
-    );
+
+);
     const html = (
         \\<p>aaa</p>
         \\<p>bbb</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3932,16 +4367,19 @@ test "Example 221" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 222" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\aaa
-    );
+
+);
     const html = (
         \\<p>aaa
         \\bbb</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3949,17 +4387,20 @@ test "Example 222" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 223" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\aaa
-    );
+
+);
     const html = (
         \\<p>aaa
         \\bbb
         \\ccc</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3967,17 +4408,20 @@ test "Example 223" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 224" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\aaa
         \\bbb
-    );
+
+);
     const html = (
         \\<p>aaa
         \\bbb</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -3985,18 +4429,21 @@ test "Example 224" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 225" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\aaa
         \\bbb
-    );
+
+);
     const html = (
         \\<pre><code>aaa
         \\</code></pre>
         \\<p>bbb</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4004,15 +4451,16 @@ test "Example 225" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 226" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\aaa
-    );
+);
     const html = (
         \\<p>aaa<br
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4020,6 +4468,7 @@ test "Example 226" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 227" {
     const alloc = std.testing.allocator;
 
@@ -4027,11 +4476,13 @@ test "Example 227" {
         \\
         \\
         \\aaa
-    );
+
+);
     const html = (
         \\<p>aaa</p>
         \\<h1>aaa</h1>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4039,19 +4490,21 @@ test "Example 227" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 228" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\>
-    );
+);
     const html = (
         \\<blockquote>
         \\<h1>Foo</h1>
         \\<p>bar
         \\baz</p>
         \\</blockquote>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4059,19 +4512,21 @@ test "Example 228" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 229" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\>#
-    );
+);
     const html = (
         \\<blockquote>
         \\<h1>Foo</h1>
         \\<p>bar
         \\baz</p>
         \\</blockquote>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4079,19 +4534,21 @@ test "Example 229" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 230" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\>
-    );
+);
     const html = (
         \\<blockquote>
         \\<h1>Foo</h1>
         \\<p>bar
         \\baz</p>
         \\</blockquote>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4099,15 +4556,16 @@ test "Example 230" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 231" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\>
-    );
+);
     const html = (
         \\<pre><code>&gt;
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4115,19 +4573,21 @@ test "Example 231" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 232" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\>
-    );
+);
     const html = (
         \\<blockquote>
         \\<h1>Foo</h1>
         \\<p>bar
         \\baz</p>
         \\</blockquote>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4135,19 +4595,21 @@ test "Example 232" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 233" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\>
-    );
+);
     const html = (
         \\<blockquote>
         \\<p>bar
         \\baz
         \\foo</p>
         \\</blockquote>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4155,18 +4617,19 @@ test "Example 233" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 234" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\>
-    );
+);
     const html = (
         \\<blockquote>
         \\<p>foo</p>
         \\</blockquote>
         \\<hr
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4174,12 +4637,13 @@ test "Example 234" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 235" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\>
-    );
+);
     const html = (
         \\<blockquote>
         \\<ul>
@@ -4189,7 +4653,8 @@ test "Example 235" {
         \\<ul>
         \\<li>bar</li>
         \\</ul>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4197,12 +4662,13 @@ test "Example 235" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 236" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\>
-    );
+);
     const html = (
         \\<blockquote>
         \\<pre><code>foo
@@ -4210,7 +4676,8 @@ test "Example 236" {
         \\</blockquote>
         \\<pre><code>bar
         \\</code></pre>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4218,19 +4685,21 @@ test "Example 236" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 237" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\>
-    );
+);
     const html = (
         \\<blockquote>
         \\<pre><code></code></pre>
         \\</blockquote>
         \\<p>foo</p>
         \\<pre><code></code></pre>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4238,17 +4707,18 @@ test "Example 237" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 238" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\>
-    );
+);
     const html = (
         \\<blockquote>
         \\<p>foo
         \\-
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4256,16 +4726,19 @@ test "Example 238" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 239" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\>
-    );
+
+);
     const html = (
         \\<blockquote>
         \\</blockquote>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4273,17 +4746,19 @@ test "Example 239" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 240" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\>
         \\>
-    );
+);
     const html = (
         \\<blockquote>
         \\</blockquote>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4291,18 +4766,20 @@ test "Example 240" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 241" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\>
         \\>
-    );
+);
     const html = (
         \\<blockquote>
         \\<p>foo</p>
         \\</blockquote>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4310,12 +4787,13 @@ test "Example 241" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 242" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\>
-    );
+);
     const html = (
         \\<blockquote>
         \\<p>foo</p>
@@ -4323,7 +4801,8 @@ test "Example 242" {
         \\<blockquote>
         \\<p>bar</p>
         \\</blockquote>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4331,18 +4810,20 @@ test "Example 242" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 243" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\>
-    );
+);
     const html = (
         \\<blockquote>
         \\<p>foo
         \\bar</p>
         \\</blockquote>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4350,18 +4831,20 @@ test "Example 243" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 244" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\>
-    );
+);
     const html = (
         \\<blockquote>
         \\<p>foo</p>
         \\<p>bar</p>
         \\</blockquote>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4369,19 +4852,21 @@ test "Example 244" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 245" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo
         \\>
-    );
+);
     const html = (
         \\<p>foo</p>
         \\<blockquote>
         \\<p>bar</p>
         \\</blockquote>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4389,18 +4874,19 @@ test "Example 245" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 246" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\>
-    );
+);
     const html = (
         \\<blockquote>
         \\<p>aaa</p>
         \\</blockquote>
         \\<hr
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4408,18 +4894,20 @@ test "Example 246" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 247" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\>
-    );
+);
     const html = (
         \\<blockquote>
         \\<p>bar
         \\baz</p>
         \\</blockquote>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4427,18 +4915,20 @@ test "Example 247" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 248" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\>
-    );
+);
     const html = (
         \\<blockquote>
         \\<p>bar</p>
         \\</blockquote>
         \\<p>baz</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4446,18 +4936,20 @@ test "Example 248" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 249" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\>
-    );
+);
     const html = (
         \\<blockquote>
         \\<p>bar</p>
         \\</blockquote>
         \\<p>baz</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4465,12 +4957,13 @@ test "Example 249" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 250" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\>
-    );
+);
     const html = (
         \\<blockquote>
         \\<blockquote>
@@ -4480,7 +4973,8 @@ test "Example 250" {
         \\</blockquote>
         \\</blockquote>
         \\</blockquote>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4488,12 +4982,13 @@ test "Example 250" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 251" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\>>>
-    );
+);
     const html = (
         \\<blockquote>
         \\<blockquote>
@@ -4504,7 +4999,8 @@ test "Example 251" {
         \\</blockquote>
         \\</blockquote>
         \\</blockquote>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4512,12 +5008,13 @@ test "Example 251" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 252" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\>
-    );
+);
     const html = (
         \\<blockquote>
         \\<pre><code>code
@@ -4525,7 +5022,7 @@ test "Example 252" {
         \\</blockquote>
         \\<blockquote>
         \\<p>not
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4533,15 +5030,16 @@ test "Example 252" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 253" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\A
-    );
+);
     const html = (
         \\<p>A
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4549,17 +5047,18 @@ test "Example 253" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 254" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\1.
-    );
+);
     const html = (
         \\<ol>
         \\<li>
         \\<p>A
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4567,18 +5066,20 @@ test "Example 254" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 255" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>one</li>
         \\</ul>
         \\<p>two</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4586,12 +5087,13 @@ test "Example 255" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 256" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>
@@ -4599,7 +5101,8 @@ test "Example 256" {
         \\<p>two</p>
         \\</li>
         \\</ul>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4607,18 +5110,19 @@ test "Example 256" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 257" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>one</li>
         \\</ul>
         \\<pre><code>
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4626,12 +5130,13 @@ test "Example 257" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 258" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>
@@ -4639,7 +5144,8 @@ test "Example 258" {
         \\<p>two</p>
         \\</li>
         \\</ul>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4647,12 +5153,13 @@ test "Example 258" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 259" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\>
-    );
+);
     const html = (
         \\<blockquote>
         \\<blockquote>
@@ -4664,7 +5171,8 @@ test "Example 259" {
         \\</ol>
         \\</blockquote>
         \\</blockquote>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4672,12 +5180,13 @@ test "Example 259" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 260" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\>>-
-    );
+);
     const html = (
         \\<blockquote>
         \\<blockquote>
@@ -4687,7 +5196,8 @@ test "Example 260" {
         \\<p>two</p>
         \\</blockquote>
         \\</blockquote>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4695,6 +5205,7 @@ test "Example 260" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 261" {
     const alloc = std.testing.allocator;
 
@@ -4702,11 +5213,13 @@ test "Example 261" {
         \\-one
         \\
         \\2.two
-    );
+
+);
     const html = (
         \\<p>-one</p>
         \\<p>2.two</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4714,12 +5227,13 @@ test "Example 261" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 262" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>
@@ -4727,7 +5241,8 @@ test "Example 262" {
         \\<p>bar</p>
         \\</li>
         \\</ul>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4735,12 +5250,13 @@ test "Example 262" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 263" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\1.
-    );
+);
     const html = (
         \\<ol>
         \\<li>
@@ -4753,7 +5269,8 @@ test "Example 263" {
         \\</blockquote>
         \\</li>
         \\</ol>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4761,12 +5278,13 @@ test "Example 263" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 264" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>
@@ -4778,7 +5296,8 @@ test "Example 264" {
         \\</code></pre>
         \\</li>
         \\</ul>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4786,15 +5305,16 @@ test "Example 264" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 265" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\123456789.
-    );
+);
     const html = (
         \\<ol
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4802,15 +5322,16 @@ test "Example 265" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 266" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\1234567890.
-    );
+);
     const html = (
         \\<p>1234567890.
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4818,15 +5339,16 @@ test "Example 266" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 267" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\0.
-    );
+);
     const html = (
         \\<ol
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4834,15 +5356,16 @@ test "Example 267" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 268" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\003.
-    );
+);
     const html = (
         \\<ol
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4850,15 +5373,16 @@ test "Example 268" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 269" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-1.
-    );
+);
     const html = (
         \\<p>-1.
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4866,12 +5390,13 @@ test "Example 269" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 270" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>
@@ -4880,7 +5405,8 @@ test "Example 270" {
         \\</code></pre>
         \\</li>
         \\</ul>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4888,15 +5414,16 @@ test "Example 270" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 271" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\10.
-    );
+);
     const html = (
         \\<ol
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4904,15 +5431,16 @@ test "Example 271" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 272" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\indented
-    );
+);
     const html = (
         \\<pre><code>indented
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4920,17 +5448,18 @@ test "Example 272" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 273" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\1.
-    );
+);
     const html = (
         \\<ol>
         \\<li>
         \\<pre><code>indented
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4938,17 +5467,18 @@ test "Example 273" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 274" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\1.
-    );
+);
     const html = (
         \\<ol>
         \\<li>
         \\<pre><code>
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4956,6 +5486,7 @@ test "Example 274" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 275" {
     const alloc = std.testing.allocator;
 
@@ -4963,11 +5494,13 @@ test "Example 275" {
         \\foo
         \\
         \\bar
-    );
+
+);
     const html = (
         \\<p>foo</p>
         \\<p>bar</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4975,18 +5508,20 @@ test "Example 275" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 276" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>foo</li>
         \\</ul>
         \\<p>bar</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -4994,12 +5529,13 @@ test "Example 276" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 277" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>
@@ -5007,7 +5543,8 @@ test "Example 277" {
         \\<p>bar</p>
         \\</li>
         \\</ul>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5015,12 +5552,14 @@ test "Example 277" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 278" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+
+);
     const html = (
         \\<ul>
         \\<li>foo</li>
@@ -5033,7 +5572,8 @@ test "Example 278" {
         \\</code></pre>
         \\</li>
         \\</ul>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5041,17 +5581,19 @@ test "Example 278" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 279" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>foo</li>
         \\</ul>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5059,19 +5601,22 @@ test "Example 279" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 280" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
         \\
-    );
+
+);
     const html = (
         \\<ul>
         \\<li></li>
         \\</ul>
         \\<p>foo</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5079,19 +5624,21 @@ test "Example 280" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 281" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>foo</li>
         \\<li></li>
         \\<li>bar</li>
         \\</ul>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5099,19 +5646,21 @@ test "Example 281" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 282" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>foo</li>
         \\<li></li>
         \\<li>bar</li>
         \\</ul>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5119,19 +5668,21 @@ test "Example 282" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 283" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\1.
-    );
+);
     const html = (
         \\<ol>
         \\<li>foo</li>
         \\<li></li>
         \\<li>bar</li>
         \\</ol>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5139,17 +5690,20 @@ test "Example 283" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 284" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\*
-    );
+
+);
     const html = (
         \\<ul>
         \\<li></li>
         \\</ul>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5157,6 +5711,7 @@ test "Example 284" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 285" {
     const alloc = std.testing.allocator;
 
@@ -5166,13 +5721,15 @@ test "Example 285" {
         \\
         \\foo
         \\1.
-    );
+
+);
     const html = (
         \\<p>foo
         \\*</p>
         \\<p>foo
         \\1.</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5180,17 +5737,18 @@ test "Example 285" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 286" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\1.
-    );
+);
     const html = (
         \\<ol>
         \\<li>
         \\<p>A
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5198,17 +5756,18 @@ test "Example 286" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 287" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\1.
-    );
+);
     const html = (
         \\<ol>
         \\<li>
         \\<p>A
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5216,17 +5775,18 @@ test "Example 287" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 288" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\1.
-    );
+);
     const html = (
         \\<ol>
         \\<li>
         \\<p>A
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5234,15 +5794,16 @@ test "Example 288" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 289" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\1.
-    );
+);
     const html = (
         \\<pre><code>1.
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5250,17 +5811,18 @@ test "Example 289" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 290" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\1.
-    );
+);
     const html = (
         \\<ol>
         \\<li>
         \\<p>A
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5268,16 +5830,17 @@ test "Example 290" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 291" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\1.
-    );
+);
     const html = (
         \\<ol>
         \\<li>A
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5285,12 +5848,13 @@ test "Example 291" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 292" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\>
-    );
+);
     const html = (
         \\<blockquote>
         \\<ol>
@@ -5298,7 +5862,7 @@ test "Example 292" {
         \\<blockquote>
         \\<p>Blockquote
         \\continued
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5306,12 +5870,13 @@ test "Example 292" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 293" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\>
-    );
+);
     const html = (
         \\<blockquote>
         \\<ol>
@@ -5319,7 +5884,7 @@ test "Example 293" {
         \\<blockquote>
         \\<p>Blockquote
         \\continued
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5327,12 +5892,13 @@ test "Example 293" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 294" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>foo
@@ -5349,7 +5915,8 @@ test "Example 294" {
         \\</ul>
         \\</li>
         \\</ul>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5357,12 +5924,13 @@ test "Example 294" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 295" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>foo</li>
@@ -5370,7 +5938,8 @@ test "Example 295" {
         \\<li>baz</li>
         \\<li>boo</li>
         \\</ul>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5378,15 +5947,16 @@ test "Example 295" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 296" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\10)
-    );
+);
     const html = (
         \\<ol
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5394,15 +5964,16 @@ test "Example 296" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 297" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\10)
-    );
+);
     const html = (
         \\<ol
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5410,12 +5981,13 @@ test "Example 297" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 298" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>
@@ -5424,7 +5996,8 @@ test "Example 298" {
         \\</ul>
         \\</li>
         \\</ul>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5432,19 +6005,20 @@ test "Example 298" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 299" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\1.
-    );
+);
     const html = (
         \\<ol>
         \\<li>
         \\<ul>
         \\<li>
         \\<ol
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5452,12 +6026,13 @@ test "Example 299" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 300" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>
@@ -5467,7 +6042,8 @@ test "Example 300" {
         \\<h2>Bar</h2>
         \\baz</li>
         \\</ul>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5475,12 +6051,13 @@ test "Example 300" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 301" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>foo</li>
@@ -5489,7 +6066,8 @@ test "Example 301" {
         \\<ul>
         \\<li>baz</li>
         \\</ul>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5497,19 +6075,20 @@ test "Example 301" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 302" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\1.
-    );
+);
     const html = (
         \\<ol>
         \\<li>foo</li>
         \\<li>bar</li>
         \\</ol>
         \\<ol
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5517,20 +6096,22 @@ test "Example 302" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 303" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\Foo
         \\-
-    );
+);
     const html = (
         \\<p>Foo</p>
         \\<ul>
         \\<li>bar</li>
         \\<li>baz</li>
         \\</ul>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5538,15 +6119,16 @@ test "Example 303" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 304" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\The
-    );
+);
     const html = (
         \\<p>The
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5554,15 +6136,16 @@ test "Example 304" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 305" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\The
-    );
+);
     const html = (
         \\<p>The
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5570,12 +6153,13 @@ test "Example 305" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 306" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>
@@ -5588,7 +6172,8 @@ test "Example 306" {
         \\<p>baz</p>
         \\</li>
         \\</ul>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5596,12 +6181,13 @@ test "Example 306" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 307" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>foo
@@ -5617,7 +6203,8 @@ test "Example 307" {
         \\</ul>
         \\</li>
         \\</ul>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5625,19 +6212,20 @@ test "Example 307" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 308" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>foo</li>
         \\<li>bar</li>
         \\</ul>
         \\<!--
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5645,12 +6233,13 @@ test "Example 308" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 309" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>
@@ -5662,7 +6251,7 @@ test "Example 309" {
         \\</li>
         \\</ul>
         \\<!--
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5670,12 +6259,13 @@ test "Example 309" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 310" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>a</li>
@@ -5686,7 +6276,8 @@ test "Example 310" {
         \\<li>f</li>
         \\<li>g</li>
         \\</ul>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5694,12 +6285,13 @@ test "Example 310" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 311" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\1.
-    );
+);
     const html = (
         \\<ol>
         \\<li>
@@ -5712,7 +6304,8 @@ test "Example 311" {
         \\<p>c</p>
         \\</li>
         \\</ol>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5720,12 +6313,13 @@ test "Example 311" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 312" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>a</li>
@@ -5733,7 +6327,7 @@ test "Example 312" {
         \\<li>c</li>
         \\<li>d
         \\-
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5741,12 +6335,13 @@ test "Example 312" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 313" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\1.
-    );
+);
     const html = (
         \\<ol>
         \\<li>
@@ -5757,7 +6352,7 @@ test "Example 313" {
         \\</li>
         \\</ol>
         \\<pre><code>3.
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5765,12 +6360,13 @@ test "Example 313" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 314" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>
@@ -5783,7 +6379,8 @@ test "Example 314" {
         \\<p>c</p>
         \\</li>
         \\</ul>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5791,12 +6388,13 @@ test "Example 314" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 315" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\*
-    );
+);
     const html = (
         \\<ul>
         \\<li>
@@ -5807,7 +6405,8 @@ test "Example 315" {
         \\<p>c</p>
         \\</li>
         \\</ul>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5815,12 +6414,13 @@ test "Example 315" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 316" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>
@@ -5834,7 +6434,8 @@ test "Example 316" {
         \\<p>d</p>
         \\</li>
         \\</ul>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5842,12 +6443,13 @@ test "Example 316" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 317" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>
@@ -5860,7 +6462,8 @@ test "Example 317" {
         \\<p>d</p>
         \\</li>
         \\</ul>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5868,12 +6471,13 @@ test "Example 317" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 318" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>a</li>
@@ -5885,7 +6489,8 @@ test "Example 318" {
         \\</li>
         \\<li>c</li>
         \\</ul>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5893,12 +6498,13 @@ test "Example 318" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 319" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>a
@@ -5911,7 +6517,8 @@ test "Example 319" {
         \\</li>
         \\<li>d</li>
         \\</ul>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5919,12 +6526,13 @@ test "Example 319" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 320" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\*
-    );
+);
     const html = (
         \\<ul>
         \\<li>a
@@ -5934,7 +6542,8 @@ test "Example 320" {
         \\</li>
         \\<li>c</li>
         \\</ul>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5942,12 +6551,13 @@ test "Example 320" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 321" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>a
@@ -5959,7 +6569,8 @@ test "Example 321" {
         \\</li>
         \\<li>d</li>
         \\</ul>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5967,17 +6578,19 @@ test "Example 321" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 322" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>a</li>
         \\</ul>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -5985,12 +6598,13 @@ test "Example 322" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 323" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>a
@@ -5999,7 +6613,8 @@ test "Example 323" {
         \\</ul>
         \\</li>
         \\</ul>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6007,12 +6622,13 @@ test "Example 323" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 324" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\1.
-    );
+);
     const html = (
         \\<ol>
         \\<li>
@@ -6021,7 +6637,8 @@ test "Example 324" {
         \\<p>bar</p>
         \\</li>
         \\</ol>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6029,12 +6646,13 @@ test "Example 324" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 325" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\*
-    );
+);
     const html = (
         \\<ul>
         \\<li>
@@ -6045,7 +6663,8 @@ test "Example 325" {
         \\<p>baz</p>
         \\</li>
         \\</ul>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6053,12 +6672,13 @@ test "Example 325" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 326" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\-
-    );
+);
     const html = (
         \\<ul>
         \\<li>
@@ -6076,7 +6696,8 @@ test "Example 326" {
         \\</ul>
         \\</li>
         \\</ul>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6084,15 +6705,18 @@ test "Example 326" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 327" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\`hi`lo`
-    );
+
+);
     const html = (
         \\<p><code>hi</code>lo`</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6100,15 +6724,18 @@ test "Example 327" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 328" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\`foo`
-    );
+
+);
     const html = (
         \\<p><code>foo</code></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6116,15 +6743,16 @@ test "Example 328" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 329" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\``
-    );
+);
     const html = (
         \\<p><code>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6132,15 +6760,17 @@ test "Example 329" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 330" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\`
-    );
+);
     const html = (
         \\<p><code>``</code></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6148,15 +6778,16 @@ test "Example 330" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 331" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\`
-    );
+);
     const html = (
         \\<p><code>
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6164,15 +6795,16 @@ test "Example 331" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 332" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\`
-    );
+);
     const html = (
         \\<p><code>
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6180,15 +6812,18 @@ test "Example 332" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 333" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\` b `
-    );
+
+);
     const html = (
         \\<p><code> b </code></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6196,17 +6831,18 @@ test "Example 333" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 334" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\` `
         \\`
-    );
+);
     const html = (
         \\<p><code> </code>
         \\<code>
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6214,6 +6850,7 @@ test "Example 334" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 335" {
     const alloc = std.testing.allocator;
 
@@ -6221,10 +6858,10 @@ test "Example 335" {
         \\``
         \\foo
         \\bar
-    );
+);
     const html = (
         \\<p><code>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6232,16 +6869,17 @@ test "Example 335" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 336" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\``
         \\foo
-    );
+);
     const html = (
         \\<p><code>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6249,15 +6887,16 @@ test "Example 336" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 337" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\`foo
-    );
+);
     const html = (
         \\<p><code>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6265,15 +6904,18 @@ test "Example 337" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 338" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\`foo\`bar`
-    );
+
+);
     const html = (
         \\<p><code>foo\</code>bar`</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6281,15 +6923,18 @@ test "Example 338" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 339" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\``foo`bar``
-    );
+
+);
     const html = (
         \\<p><code>foo`bar</code></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6297,15 +6942,16 @@ test "Example 339" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 340" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\`
-    );
+);
     const html = (
         \\<p><code>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6313,15 +6959,18 @@ test "Example 340" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 341" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\*foo`*`
-    );
+
+);
     const html = (
         \\<p>*foo<code>*</code></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6329,15 +6978,16 @@ test "Example 341" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 342" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[not
-    );
+);
     const html = (
         \\<p>[not
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6345,15 +6995,16 @@ test "Example 342" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 343" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\`<a
-    );
+);
     const html = (
         \\<p><code>&lt;a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6361,15 +7012,16 @@ test "Example 343" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 344" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<a
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6377,15 +7029,18 @@ test "Example 344" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 345" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\`<https://foo.bar.`baz>`
-    );
+
+);
     const html = (
         \\<p><code>&lt;https://foo.bar.</code>baz&gt;`</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6393,15 +7048,17 @@ test "Example 345" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 346" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<https://foo.bar.`baz>`
-    );
+
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6409,15 +7066,18 @@ test "Example 346" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 347" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\```foo``
-    );
+
+);
     const html = (
         \\<p>```foo``</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6425,15 +7085,18 @@ test "Example 347" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 348" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\`foo
-    );
+
+);
     const html = (
         \\<p>`foo</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6441,15 +7104,18 @@ test "Example 348" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 349" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\`foo``bar``
-    );
+
+);
     const html = (
         \\<p>`foo<code>bar</code></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6457,15 +7123,16 @@ test "Example 349" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 350" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\*foo
-    );
+);
     const html = (
         \\<p><em>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6473,15 +7140,16 @@ test "Example 350" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 351" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\a
-    );
+);
     const html = (
         \\<p>a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6489,15 +7157,18 @@ test "Example 351" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 352" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\a*"foo"*
-    );
+
+);
     const html = (
         \\<p>a*&quot;foo&quot;*</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6505,15 +7176,18 @@ test "Example 352" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 353" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\* a *
-    );
+
+);
     const html = (
         \\<p>* a *</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6521,6 +7195,7 @@ test "Example 353" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 354" {
     const alloc = std.testing.allocator;
 
@@ -6530,12 +7205,14 @@ test "Example 354" {
         \\*£*bravo.
         \\
         \\*€*charlie.
-    );
+
+);
     const html = (
         \\<p>*$*alpha.</p>
         \\<p>*£*bravo.</p>
         \\<p>*€*charlie.</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6543,15 +7220,18 @@ test "Example 354" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 355" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo*bar*
-    );
+
+);
     const html = (
         \\<p>foo<em>bar</em></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6559,15 +7239,18 @@ test "Example 355" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 356" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\5*6*78
-    );
+
+);
     const html = (
         \\<p>5<em>6</em>78</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6575,15 +7258,16 @@ test "Example 356" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 357" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\_foo
-    );
+);
     const html = (
         \\<p><em>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6591,15 +7275,16 @@ test "Example 357" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 358" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\_
-    );
+);
     const html = (
         \\<p>_
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6607,15 +7292,18 @@ test "Example 358" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 359" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\a_"foo"_
-    );
+
+);
     const html = (
         \\<p>a_&quot;foo&quot;_</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6623,15 +7311,18 @@ test "Example 359" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 360" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo_bar_
-    );
+
+);
     const html = (
         \\<p>foo_bar_</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6639,15 +7330,18 @@ test "Example 360" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 361" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\5_6_78
-    );
+
+);
     const html = (
         \\<p>5_6_78</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6655,15 +7349,18 @@ test "Example 361" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 362" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\пристаням_стремятся_
-    );
+
+);
     const html = (
         \\<p>пристаням_стремятся_</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6671,15 +7368,18 @@ test "Example 362" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 363" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\aa_"bb"_cc
-    );
+
+);
     const html = (
         \\<p>aa_&quot;bb&quot;_cc</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6687,15 +7387,18 @@ test "Example 363" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 364" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo-_(bar)_
-    );
+
+);
     const html = (
         \\<p>foo-<em>(bar)</em></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6703,15 +7406,18 @@ test "Example 364" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 365" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\_foo*
-    );
+
+);
     const html = (
         \\<p>_foo*</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6719,15 +7425,16 @@ test "Example 365" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 366" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\*foo
-    );
+);
     const html = (
         \\<p>*foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6735,15 +7442,16 @@ test "Example 366" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 367" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\*foo
-    );
+);
     const html = (
         \\<p>*foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6751,15 +7459,18 @@ test "Example 367" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 368" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\*(*foo)
-    );
+
+);
     const html = (
         \\<p>*(*foo)</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6767,15 +7478,18 @@ test "Example 368" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 369" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\*(*foo*)*
-    );
+
+);
     const html = (
         \\<p><em>(<em>foo</em>)</em></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6783,15 +7497,18 @@ test "Example 369" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 370" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\*foo*bar
-    );
+
+);
     const html = (
         \\<p><em>foo</em>bar</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6799,15 +7516,16 @@ test "Example 370" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 371" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\_foo
-    );
+);
     const html = (
         \\<p>_foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6815,15 +7533,18 @@ test "Example 371" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 372" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\_(_foo)
-    );
+
+);
     const html = (
         \\<p>_(_foo)</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6831,15 +7552,18 @@ test "Example 372" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 373" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\_(_foo_)_
-    );
+
+);
     const html = (
         \\<p><em>(<em>foo</em>)</em></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6847,15 +7571,18 @@ test "Example 373" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 374" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\_foo_bar
-    );
+
+);
     const html = (
         \\<p>_foo_bar</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6863,15 +7590,18 @@ test "Example 374" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 375" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\_пристаням_стремятся
-    );
+
+);
     const html = (
         \\<p>_пристаням_стремятся</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6879,15 +7609,18 @@ test "Example 375" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 376" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\_foo_bar_baz_
-    );
+
+);
     const html = (
         \\<p><em>foo_bar_baz</em></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6895,15 +7628,18 @@ test "Example 376" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 377" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\_(bar)_.
-    );
+
+);
     const html = (
         \\<p><em>(bar)</em>.</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6911,15 +7647,16 @@ test "Example 377" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 378" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\**foo
-    );
+);
     const html = (
         \\<p><strong>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6927,15 +7664,16 @@ test "Example 378" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 379" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\**
-    );
+);
     const html = (
         \\<p>**
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6943,15 +7681,18 @@ test "Example 379" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 380" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\a**"foo"**
-    );
+
+);
     const html = (
         \\<p>a**&quot;foo&quot;**</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6959,15 +7700,18 @@ test "Example 380" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 381" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo**bar**
-    );
+
+);
     const html = (
         \\<p>foo<strong>bar</strong></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6975,15 +7719,16 @@ test "Example 381" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 382" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\__foo
-    );
+);
     const html = (
         \\<p><strong>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -6991,15 +7736,16 @@ test "Example 382" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 383" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\__
-    );
+);
     const html = (
         \\<p>__
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7007,17 +7753,18 @@ test "Example 383" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 384" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\__
         \\foo
-    );
+);
     const html = (
         \\<p>__
         \\foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7025,15 +7772,18 @@ test "Example 384" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 385" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\a__"foo"__
-    );
+
+);
     const html = (
         \\<p>a__&quot;foo&quot;__</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7041,15 +7791,18 @@ test "Example 385" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 386" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo__bar__
-    );
+
+);
     const html = (
         \\<p>foo__bar__</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7057,15 +7810,18 @@ test "Example 386" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 387" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\5__6__78
-    );
+
+);
     const html = (
         \\<p>5__6__78</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7073,15 +7829,18 @@ test "Example 387" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 388" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\пристаням__стремятся__
-    );
+
+);
     const html = (
         \\<p>пристаням__стремятся__</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7089,15 +7848,16 @@ test "Example 388" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 389" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\__foo,
-    );
+);
     const html = (
         \\<p><strong>foo,
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7105,15 +7865,18 @@ test "Example 389" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 390" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo-__(bar)__
-    );
+
+);
     const html = (
         \\<p>foo-<strong>(bar)</strong></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7121,15 +7884,16 @@ test "Example 390" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 391" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\**foo
-    );
+);
     const html = (
         \\<p>**foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7137,15 +7901,18 @@ test "Example 391" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 392" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\**(**foo)
-    );
+
+);
     const html = (
         \\<p>**(**foo)</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7153,15 +7920,18 @@ test "Example 392" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 393" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\*(**foo**)*
-    );
+
+);
     const html = (
         \\<p><em>(<strong>foo</strong>)</em></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7169,15 +7939,16 @@ test "Example 393" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 394" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\**Gomphocarpus
-    );
+);
     const html = (
         \\<p><strong>Gomphocarpus
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7185,15 +7956,16 @@ test "Example 394" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 395" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\**foo
-    );
+);
     const html = (
         \\<p><strong>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7201,15 +7973,18 @@ test "Example 395" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 396" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\**foo**bar
-    );
+
+);
     const html = (
         \\<p><strong>foo</strong>bar</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7217,15 +7992,16 @@ test "Example 396" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 397" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\__foo
-    );
+);
     const html = (
         \\<p>__foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7233,15 +8009,18 @@ test "Example 397" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 398" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\__(__foo)
-    );
+
+);
     const html = (
         \\<p>__(__foo)</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7249,15 +8028,18 @@ test "Example 398" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 399" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\_(__foo__)_
-    );
+
+);
     const html = (
         \\<p><em>(<strong>foo</strong>)</em></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7265,15 +8047,18 @@ test "Example 399" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 400" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\__foo__bar
-    );
+
+);
     const html = (
         \\<p>__foo__bar</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7281,15 +8066,18 @@ test "Example 400" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 401" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\__пристаням__стремятся
-    );
+
+);
     const html = (
         \\<p>__пристаням__стремятся</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7297,15 +8085,18 @@ test "Example 401" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 402" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\__foo__bar__baz__
-    );
+
+);
     const html = (
         \\<p><strong>foo__bar__baz</strong></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7313,15 +8104,18 @@ test "Example 402" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 403" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\__(bar)__.
-    );
+
+);
     const html = (
         \\<p><strong>(bar)</strong>.</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7329,15 +8123,16 @@ test "Example 403" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 404" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\*foo
-    );
+);
     const html = (
         \\<p><em>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7345,17 +8140,20 @@ test "Example 404" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 405" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\*foo
         \\bar*
-    );
+
+);
     const html = (
         \\<p><em>foo
         \\bar</em></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7363,15 +8161,16 @@ test "Example 405" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 406" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\_foo
-    );
+);
     const html = (
         \\<p><em>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7379,15 +8178,16 @@ test "Example 406" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 407" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\_foo
-    );
+);
     const html = (
         \\<p><em>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7395,15 +8195,16 @@ test "Example 407" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 408" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\__foo_
-    );
+);
     const html = (
         \\<p><em><em>foo</em>
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7411,15 +8212,16 @@ test "Example 408" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 409" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\*foo
-    );
+);
     const html = (
         \\<p><em>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7427,15 +8229,16 @@ test "Example 409" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 410" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\*foo
-    );
+);
     const html = (
         \\<p><em>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7443,15 +8246,18 @@ test "Example 410" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 411" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\*foo**bar**baz*
-    );
+
+);
     const html = (
         \\<p><em>foo<strong>bar</strong>baz</em></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7459,15 +8265,18 @@ test "Example 411" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 412" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\*foo**bar*
-    );
+
+);
     const html = (
         \\<p><em>foo**bar</em></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7475,15 +8284,16 @@ test "Example 412" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 413" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\***foo**
-    );
+);
     const html = (
         \\<p><em><strong>foo</strong>
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7491,15 +8301,16 @@ test "Example 413" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 414" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\*foo
-    );
+);
     const html = (
         \\<p><em>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7507,15 +8318,18 @@ test "Example 414" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 415" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\*foo**bar***
-    );
+
+);
     const html = (
         \\<p><em>foo<strong>bar</strong></em></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7523,15 +8337,18 @@ test "Example 415" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 416" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo***bar***baz
-    );
+
+);
     const html = (
         \\<p>foo<em><strong>bar</strong></em>baz</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7539,15 +8356,18 @@ test "Example 416" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 417" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo******bar*********baz
-    );
+
+);
     const html = (
         \\<p>foo<strong><strong><strong>bar</strong></strong></strong>***baz</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7555,15 +8375,16 @@ test "Example 417" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 418" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\*foo
-    );
+);
     const html = (
         \\<p><em>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7571,15 +8392,16 @@ test "Example 418" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 419" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\*foo
-    );
+);
     const html = (
         \\<p><em>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7587,15 +8409,16 @@ test "Example 419" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 420" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\**
-    );
+);
     const html = (
         \\<p>**
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7603,15 +8426,16 @@ test "Example 420" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 421" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\****
-    );
+);
     const html = (
         \\<p>****
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7619,15 +8443,16 @@ test "Example 421" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 422" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\**foo
-    );
+);
     const html = (
         \\<p><strong>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7635,17 +8460,20 @@ test "Example 422" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 423" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\**foo
         \\bar**
-    );
+
+);
     const html = (
         \\<p><strong>foo
         \\bar</strong></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7653,15 +8481,16 @@ test "Example 423" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 424" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\__foo
-    );
+);
     const html = (
         \\<p><strong>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7669,15 +8498,16 @@ test "Example 424" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 425" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\__foo
-    );
+);
     const html = (
         \\<p><strong>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7685,15 +8515,16 @@ test "Example 425" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 426" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\____foo__
-    );
+);
     const html = (
         \\<p><strong><strong>foo</strong>
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7701,15 +8532,16 @@ test "Example 426" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 427" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\**foo
-    );
+);
     const html = (
         \\<p><strong>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7717,15 +8549,16 @@ test "Example 427" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 428" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\**foo
-    );
+);
     const html = (
         \\<p><strong>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7733,15 +8566,18 @@ test "Example 428" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 429" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\**foo*bar*baz**
-    );
+
+);
     const html = (
         \\<p><strong>foo<em>bar</em>baz</strong></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7749,15 +8585,16 @@ test "Example 429" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 430" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\***foo*
-    );
+);
     const html = (
         \\<p><strong><em>foo</em>
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7765,15 +8602,16 @@ test "Example 430" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 431" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\**foo
-    );
+);
     const html = (
         \\<p><strong>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7781,15 +8619,16 @@ test "Example 431" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 432" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\**foo
-    );
+);
     const html = (
         \\<p><strong>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7797,15 +8636,16 @@ test "Example 432" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 433" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\**foo
-    );
+);
     const html = (
         \\<p><strong>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7813,15 +8653,16 @@ test "Example 433" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 434" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\__
-    );
+);
     const html = (
         \\<p>__
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7829,15 +8670,16 @@ test "Example 434" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 435" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\____
-    );
+);
     const html = (
         \\<p>____
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7845,15 +8687,16 @@ test "Example 435" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 436" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo
-    );
+);
     const html = (
         \\<p>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7861,15 +8704,16 @@ test "Example 436" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 437" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo
-    );
+);
     const html = (
         \\<p>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7877,15 +8721,16 @@ test "Example 437" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 438" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo
-    );
+);
     const html = (
         \\<p>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7893,15 +8738,16 @@ test "Example 438" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 439" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo
-    );
+);
     const html = (
         \\<p>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7909,15 +8755,16 @@ test "Example 439" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 440" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo
-    );
+);
     const html = (
         \\<p>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7925,15 +8772,16 @@ test "Example 440" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 441" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo
-    );
+);
     const html = (
         \\<p>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7941,15 +8789,18 @@ test "Example 441" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 442" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\**foo*
-    );
+
+);
     const html = (
         \\<p>*<em>foo</em></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7957,15 +8808,18 @@ test "Example 442" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 443" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\*foo**
-    );
+
+);
     const html = (
         \\<p><em>foo</em>*</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7973,15 +8827,18 @@ test "Example 443" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 444" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\***foo**
-    );
+
+);
     const html = (
         \\<p>*<strong>foo</strong></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -7989,15 +8846,18 @@ test "Example 444" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 445" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\****foo*
-    );
+
+);
     const html = (
         \\<p>***<em>foo</em></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8005,15 +8865,18 @@ test "Example 445" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 446" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\**foo***
-    );
+
+);
     const html = (
         \\<p><strong>foo</strong>*</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8021,15 +8884,18 @@ test "Example 446" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 447" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\*foo****
-    );
+
+);
     const html = (
         \\<p><em>foo</em>***</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8037,15 +8903,16 @@ test "Example 447" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 448" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo
-    );
+);
     const html = (
         \\<p>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8053,15 +8920,16 @@ test "Example 448" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 449" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo
-    );
+);
     const html = (
         \\<p>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8069,15 +8937,16 @@ test "Example 449" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 450" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo
-    );
+);
     const html = (
         \\<p>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8085,15 +8954,16 @@ test "Example 450" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 451" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo
-    );
+);
     const html = (
         \\<p>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8101,15 +8971,16 @@ test "Example 451" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 452" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo
-    );
+);
     const html = (
         \\<p>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8117,15 +8988,16 @@ test "Example 452" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 453" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo
-    );
+);
     const html = (
         \\<p>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8133,15 +9005,18 @@ test "Example 453" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 454" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\__foo_
-    );
+
+);
     const html = (
         \\<p>_<em>foo</em></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8149,15 +9024,18 @@ test "Example 454" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 455" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\_foo__
-    );
+
+);
     const html = (
         \\<p><em>foo</em>_</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8165,15 +9043,18 @@ test "Example 455" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 456" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\___foo__
-    );
+
+);
     const html = (
         \\<p>_<strong>foo</strong></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8181,15 +9062,18 @@ test "Example 456" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 457" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\____foo_
-    );
+
+);
     const html = (
         \\<p>___<em>foo</em></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8197,15 +9081,18 @@ test "Example 457" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 458" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\__foo___
-    );
+
+);
     const html = (
         \\<p><strong>foo</strong>_</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8213,15 +9100,18 @@ test "Example 458" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 459" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\_foo____
-    );
+
+);
     const html = (
         \\<p><em>foo</em>___</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8229,15 +9119,18 @@ test "Example 459" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 460" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\**foo**
-    );
+
+);
     const html = (
         \\<p><strong>foo</strong></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8245,15 +9138,18 @@ test "Example 460" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 461" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\*_foo_*
-    );
+
+);
     const html = (
         \\<p><em><em>foo</em></em></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8261,15 +9157,18 @@ test "Example 461" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 462" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\__foo__
-    );
+
+);
     const html = (
         \\<p><strong>foo</strong></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8277,15 +9176,18 @@ test "Example 462" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 463" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\_*foo*_
-    );
+
+);
     const html = (
         \\<p><em><em>foo</em></em></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8293,15 +9195,18 @@ test "Example 463" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 464" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\****foo****
-    );
+
+);
     const html = (
         \\<p><strong><strong>foo</strong></strong></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8309,15 +9214,18 @@ test "Example 464" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 465" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\____foo____
-    );
+
+);
     const html = (
         \\<p><strong><strong>foo</strong></strong></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8325,15 +9233,18 @@ test "Example 465" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 466" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\******foo******
-    );
+
+);
     const html = (
         \\<p><strong><strong><strong>foo</strong></strong></strong></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8341,15 +9252,18 @@ test "Example 466" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 467" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\***foo***
-    );
+
+);
     const html = (
         \\<p><em><strong>foo</strong></em></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8357,15 +9271,18 @@ test "Example 467" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 468" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\_____foo_____
-    );
+
+);
     const html = (
         \\<p><em><strong><strong>foo</strong></strong></em></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8373,15 +9290,16 @@ test "Example 468" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 469" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\*foo
-    );
+);
     const html = (
         \\<p><em>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8389,15 +9307,16 @@ test "Example 469" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 470" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\*foo
-    );
+);
     const html = (
         \\<p><em>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8405,15 +9324,16 @@ test "Example 470" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 471" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\**foo
-    );
+);
     const html = (
         \\<p>**foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8421,15 +9341,16 @@ test "Example 471" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 472" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\*foo
-    );
+);
     const html = (
         \\<p>*foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8437,15 +9358,17 @@ test "Example 472" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 473" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\*[bar*](/url)
-    );
+
+);
     const html = (
         \\<p>*<a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8453,15 +9376,16 @@ test "Example 473" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 474" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\_foo
-    );
+);
     const html = (
         \\<p>_foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8469,15 +9393,16 @@ test "Example 474" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 475" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\*<img
-    );
+);
     const html = (
         \\<p>*<img
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8485,15 +9410,16 @@ test "Example 475" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 476" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\**<a
-    );
+);
     const html = (
         \\<p>**<a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8501,15 +9427,16 @@ test "Example 476" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 477" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\__<a
-    );
+);
     const html = (
         \\<p>__<a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8517,15 +9444,16 @@ test "Example 477" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 478" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\*a
-    );
+);
     const html = (
         \\<p><em>a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8533,15 +9461,16 @@ test "Example 478" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 479" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\_a
-    );
+);
     const html = (
         \\<p><em>a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8549,15 +9478,17 @@ test "Example 479" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 480" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\**a<https://foo.bar/?q=**>
-    );
+
+);
     const html = (
         \\<p>**a<a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8565,15 +9496,17 @@ test "Example 480" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 481" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\__a<https://foo.bar/?q=__>
-    );
+
+);
     const html = (
         \\<p>__a<a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8581,15 +9514,16 @@ test "Example 481" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 482" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[link](/uri
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8597,15 +9531,17 @@ test "Example 482" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 483" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[link](/uri)
-    );
+
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8613,15 +9549,17 @@ test "Example 483" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 484" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[](./target.md)
-    );
+
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8629,15 +9567,17 @@ test "Example 484" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 485" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[link]()
-    );
+
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8645,15 +9585,17 @@ test "Example 485" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 486" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[link](<>)
-    );
+
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8661,15 +9603,17 @@ test "Example 486" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 487" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[]()
-    );
+
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8677,15 +9621,16 @@ test "Example 487" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 488" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[link](/my
-    );
+);
     const html = (
         \\<p>[link](/my
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8693,15 +9638,16 @@ test "Example 488" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 489" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[link](</my
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8709,17 +9655,20 @@ test "Example 489" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 490" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[link](foo
         \\bar)
-    );
+
+);
     const html = (
         \\<p>[link](foo
         \\bar)</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8727,17 +9676,20 @@ test "Example 490" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 491" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[link](<foo
         \\bar>)
-    );
+
+);
     const html = (
         \\<p>[link](<foo
         \\bar>)</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8745,15 +9697,17 @@ test "Example 491" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 492" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[a](<b)c>)
-    );
+
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8761,15 +9715,18 @@ test "Example 492" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 493" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[link](<foo\>)
-    );
+
+);
     const html = (
         \\<p>[link](&lt;foo&gt;)</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8777,6 +9734,7 @@ test "Example 493" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 494" {
     const alloc = std.testing.allocator;
 
@@ -8784,12 +9742,14 @@ test "Example 494" {
         \\[a](<b)c
         \\[a](<b)c>
         \\[a](<b>c)
-    );
+
+);
     const html = (
         \\<p>[a](&lt;b)c
         \\[a](&lt;b)c&gt;
         \\[a](<b>c)</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8797,15 +9757,17 @@ test "Example 494" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 495" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[link](\(foo\))
-    );
+
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8813,15 +9775,17 @@ test "Example 495" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 496" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[link](foo(and(bar)))
-    );
+
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8829,15 +9793,18 @@ test "Example 496" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 497" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[link](foo(and(bar))
-    );
+
+);
     const html = (
         \\<p>[link](foo(and(bar))</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8845,15 +9812,17 @@ test "Example 497" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 498" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[link](foo\(and\(bar\))
-    );
+
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8861,15 +9830,17 @@ test "Example 498" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 499" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[link](<foo(and(bar)>)
-    );
+
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8877,15 +9848,17 @@ test "Example 499" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 500" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[link](foo\)\:)
-    );
+
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8893,6 +9866,7 @@ test "Example 500" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 501" {
     const alloc = std.testing.allocator;
 
@@ -8902,10 +9876,11 @@ test "Example 501" {
         \\[link](https://example.com#fragment)
         \\
         \\[link](https://example.com?foo=3#frag)
-    );
+
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8913,15 +9888,17 @@ test "Example 501" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 502" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[link](foo\bar)
-    );
+
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8929,15 +9906,17 @@ test "Example 502" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 503" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[link](foo%20b&auml;)
-    );
+
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8945,15 +9924,17 @@ test "Example 503" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 504" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[link]("title")
-    );
+
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8961,15 +9942,16 @@ test "Example 504" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 505" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[link](/url
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8977,15 +9959,16 @@ test "Example 505" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 506" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[link](/url
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -8993,15 +9976,17 @@ test "Example 506" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 507" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[link](/url "title")
-    );
+
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9009,15 +9994,16 @@ test "Example 507" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 508" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[link](/url
-    );
+);
     const html = (
         \\<p>[link](/url
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9025,15 +10011,16 @@ test "Example 508" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 509" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[link](/url
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9041,15 +10028,16 @@ test "Example 509" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 510" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[link](
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9057,15 +10045,16 @@ test "Example 510" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 511" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[link]
-    );
+);
     const html = (
         \\<p>[link]
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9073,15 +10062,16 @@ test "Example 511" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 512" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[link
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9089,15 +10079,16 @@ test "Example 512" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 513" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[link]
-    );
+);
     const html = (
         \\<p>[link]
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9105,15 +10096,16 @@ test "Example 513" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 514" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[link
-    );
+);
     const html = (
         \\<p>[link
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9121,15 +10113,16 @@ test "Example 514" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 515" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[link
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9137,15 +10130,16 @@ test "Example 515" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 516" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[link
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9153,15 +10147,17 @@ test "Example 516" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 517" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[![moon](moon.jpg)](/uri)
-    );
+
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9169,15 +10165,16 @@ test "Example 517" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 518" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[foo
-    );
+);
     const html = (
         \\<p>[foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9185,15 +10182,16 @@ test "Example 518" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 519" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[foo
-    );
+);
     const html = (
         \\<p>[foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9201,15 +10199,17 @@ test "Example 519" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 520" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\![[[foo](uri1)](uri2)](uri3)
-    );
+
+);
     const html = (
         \\<p><img
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9217,15 +10217,17 @@ test "Example 520" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 521" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\*[foo*](/uri)
-    );
+
+);
     const html = (
         \\<p>*<a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9233,15 +10235,16 @@ test "Example 521" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 522" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[foo
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9249,15 +10252,16 @@ test "Example 522" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 523" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\*foo
-    );
+);
     const html = (
         \\<p><em>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9265,15 +10269,16 @@ test "Example 523" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 524" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[foo
-    );
+);
     const html = (
         \\<p>[foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9281,15 +10286,18 @@ test "Example 524" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 525" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[foo`](/uri)`
-    );
+
+);
     const html = (
         \\<p>[foo<code>](/uri)</code></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9297,15 +10305,17 @@ test "Example 525" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 526" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[foo<https://example.com/?search=](uri)>
-    );
+
+);
     const html = (
         \\<p>[foo<a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9313,6 +10323,7 @@ test "Example 526" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 527" {
     const alloc = std.testing.allocator;
 
@@ -9320,10 +10331,10 @@ test "Example 527" {
         \\[foo][bar]
         \\
         \\[bar]:
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9331,15 +10342,16 @@ test "Example 527" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 528" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[link
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9347,15 +10359,16 @@ test "Example 528" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 529" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[link
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9363,15 +10376,16 @@ test "Example 529" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 530" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[link
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9379,6 +10393,7 @@ test "Example 530" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 531" {
     const alloc = std.testing.allocator;
 
@@ -9386,10 +10401,10 @@ test "Example 531" {
         \\[![moon](moon.jpg)][ref]
         \\
         \\[ref]:
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9397,15 +10412,16 @@ test "Example 531" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 532" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[foo
-    );
+);
     const html = (
         \\<p>[foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9413,15 +10429,16 @@ test "Example 532" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 533" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[foo
-    );
+);
     const html = (
         \\<p>[foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9429,6 +10446,7 @@ test "Example 533" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 534" {
     const alloc = std.testing.allocator;
 
@@ -9436,10 +10454,10 @@ test "Example 534" {
         \\*[foo*][ref]
         \\
         \\[ref]:
-    );
+);
     const html = (
         \\<p>*<a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9447,15 +10465,16 @@ test "Example 534" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 535" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[foo
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9463,15 +10482,16 @@ test "Example 535" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 536" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[foo
-    );
+);
     const html = (
         \\<p>[foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9479,6 +10499,7 @@ test "Example 536" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 537" {
     const alloc = std.testing.allocator;
 
@@ -9486,10 +10507,11 @@ test "Example 537" {
         \\[foo`][ref]`
         \\
         \\[ref]:
-    );
+);
     const html = (
         \\<p>[foo<code>][ref]</code></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9497,6 +10519,7 @@ test "Example 537" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 538" {
     const alloc = std.testing.allocator;
 
@@ -9504,10 +10527,10 @@ test "Example 538" {
         \\[foo<https://example.com/?search=][ref]>
         \\
         \\[ref]:
-    );
+);
     const html = (
         \\<p>[foo<a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9515,6 +10538,7 @@ test "Example 538" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 539" {
     const alloc = std.testing.allocator;
 
@@ -9522,10 +10546,10 @@ test "Example 539" {
         \\[foo][BaR]
         \\
         \\[bar]:
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9533,6 +10557,7 @@ test "Example 539" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 540" {
     const alloc = std.testing.allocator;
 
@@ -9540,10 +10565,10 @@ test "Example 540" {
         \\[ẞ]
         \\
         \\[SS]:
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9551,15 +10576,17 @@ test "Example 540" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 541" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[Foo
-    );
+
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9567,15 +10594,16 @@ test "Example 541" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 542" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[foo]
-    );
+);
     const html = (
         \\<p>[foo]
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9583,6 +10611,7 @@ test "Example 542" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 543" {
     const alloc = std.testing.allocator;
 
@@ -9591,11 +10620,11 @@ test "Example 543" {
         \\[bar]
         \\
         \\[bar]:
-    );
+);
     const html = (
         \\<p>[foo]
         \\<a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9603,15 +10632,16 @@ test "Example 543" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 544" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[foo]:
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9619,6 +10649,7 @@ test "Example 544" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 545" {
     const alloc = std.testing.allocator;
 
@@ -9626,10 +10657,11 @@ test "Example 545" {
         \\[bar][foo\!]
         \\
         \\[foo!]:
-    );
+);
     const html = (
         \\<p>[bar][foo!]</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9637,6 +10669,7 @@ test "Example 545" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 546" {
     const alloc = std.testing.allocator;
 
@@ -9644,11 +10677,11 @@ test "Example 546" {
         \\[foo][ref[]
         \\
         \\[ref[]:
-    );
+);
     const html = (
         \\<p>[foo][ref[]</p>
         \\<p>[ref[]:
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9656,6 +10689,7 @@ test "Example 546" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 547" {
     const alloc = std.testing.allocator;
 
@@ -9663,11 +10697,11 @@ test "Example 547" {
         \\[foo][ref[bar]]
         \\
         \\[ref[bar]]:
-    );
+);
     const html = (
         \\<p>[foo][ref[bar]]</p>
         \\<p>[ref[bar]]:
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9675,6 +10709,7 @@ test "Example 547" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 548" {
     const alloc = std.testing.allocator;
 
@@ -9682,11 +10717,11 @@ test "Example 548" {
         \\[[[foo]]]
         \\
         \\[[[foo]]]:
-    );
+);
     const html = (
         \\<p>[[[foo]]]</p>
         \\<p>[[[foo]]]:
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9694,6 +10729,7 @@ test "Example 548" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 549" {
     const alloc = std.testing.allocator;
 
@@ -9701,10 +10737,10 @@ test "Example 549" {
         \\[foo][ref\[]
         \\
         \\[ref\[]:
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9712,15 +10748,16 @@ test "Example 549" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 550" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[bar\\]:
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9728,6 +10765,7 @@ test "Example 550" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 551" {
     const alloc = std.testing.allocator;
 
@@ -9735,11 +10773,11 @@ test "Example 551" {
         \\[]
         \\
         \\[]:
-    );
+);
     const html = (
         \\<p>[]</p>
         \\<p>[]:
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9747,18 +10785,20 @@ test "Example 551" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 552" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[
-    );
+
+);
     const html = (
         \\<p>[
         \\]</p>
         \\<p>[
         \\]:
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9766,6 +10806,7 @@ test "Example 552" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 553" {
     const alloc = std.testing.allocator;
 
@@ -9773,10 +10814,10 @@ test "Example 553" {
         \\[foo][]
         \\
         \\[foo]:
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9784,15 +10825,16 @@ test "Example 553" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 554" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[*foo*
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9800,6 +10842,7 @@ test "Example 554" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 555" {
     const alloc = std.testing.allocator;
 
@@ -9807,10 +10850,10 @@ test "Example 555" {
         \\[Foo][]
         \\
         \\[foo]:
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9818,15 +10861,16 @@ test "Example 555" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 556" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[foo]
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9834,6 +10878,7 @@ test "Example 556" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 557" {
     const alloc = std.testing.allocator;
 
@@ -9841,10 +10886,10 @@ test "Example 557" {
         \\[foo]
         \\
         \\[foo]:
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9852,15 +10897,16 @@ test "Example 557" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 558" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[*foo*
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9868,15 +10914,16 @@ test "Example 558" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 559" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[[*foo*
-    );
+);
     const html = (
         \\<p>[<a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9884,15 +10931,16 @@ test "Example 559" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 560" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[[bar
-    );
+);
     const html = (
         \\<p>[[bar
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9900,6 +10948,7 @@ test "Example 560" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 561" {
     const alloc = std.testing.allocator;
 
@@ -9907,10 +10956,10 @@ test "Example 561" {
         \\[Foo]
         \\
         \\[foo]:
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9918,15 +10967,16 @@ test "Example 561" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 562" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[foo]
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9934,6 +10984,7 @@ test "Example 562" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 563" {
     const alloc = std.testing.allocator;
 
@@ -9941,10 +10992,11 @@ test "Example 563" {
         \\\[foo]
         \\
         \\[foo]:
-    );
+);
     const html = (
         \\<p>[foo]</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9952,15 +11004,16 @@ test "Example 563" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 564" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[foo*]:
-    );
+);
     const html = (
         \\<p>*<a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9968,6 +11021,7 @@ test "Example 564" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 565" {
     const alloc = std.testing.allocator;
 
@@ -9975,10 +11029,10 @@ test "Example 565" {
         \\[foo][bar]
         \\
         \\[foo]:
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -9986,6 +11040,7 @@ test "Example 565" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 566" {
     const alloc = std.testing.allocator;
 
@@ -9993,10 +11048,10 @@ test "Example 566" {
         \\[foo][]
         \\
         \\[foo]:
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10004,6 +11059,7 @@ test "Example 566" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 567" {
     const alloc = std.testing.allocator;
 
@@ -10011,10 +11067,10 @@ test "Example 567" {
         \\[foo]()
         \\
         \\[foo]:
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10022,15 +11078,16 @@ test "Example 567" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 568" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\[foo](not
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10038,6 +11095,7 @@ test "Example 568" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 569" {
     const alloc = std.testing.allocator;
 
@@ -10045,10 +11103,10 @@ test "Example 569" {
         \\[foo][bar][baz]
         \\
         \\[baz]:
-    );
+);
     const html = (
         \\<p>[foo]<a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10056,6 +11114,7 @@ test "Example 569" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 570" {
     const alloc = std.testing.allocator;
 
@@ -10063,10 +11122,10 @@ test "Example 570" {
         \\[foo][bar][baz]
         \\
         \\[baz]:
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10074,6 +11133,7 @@ test "Example 570" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 571" {
     const alloc = std.testing.allocator;
 
@@ -10081,10 +11141,10 @@ test "Example 571" {
         \\[foo][bar][baz]
         \\
         \\[baz]:
-    );
+);
     const html = (
         \\<p>[foo]<a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10092,15 +11152,16 @@ test "Example 571" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 572" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\![foo](/url
-    );
+);
     const html = (
         \\<p><img
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10108,15 +11169,16 @@ test "Example 572" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 573" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\![foo
-    );
+);
     const html = (
         \\<p><img
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10124,15 +11186,16 @@ test "Example 573" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 574" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\![foo
-    );
+);
     const html = (
         \\<p><img
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10140,15 +11203,16 @@ test "Example 574" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 575" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\![foo
-    );
+);
     const html = (
         \\<p><img
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10156,15 +11220,16 @@ test "Example 575" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 576" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\![foo
-    );
+);
     const html = (
         \\<p><img
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10172,15 +11237,16 @@ test "Example 576" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 577" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\![foo
-    );
+);
     const html = (
         \\<p><img
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10188,15 +11254,17 @@ test "Example 577" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 578" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\![foo](train.jpg)
-    );
+
+);
     const html = (
         \\<p><img
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10204,15 +11272,16 @@ test "Example 578" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 579" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\My
-    );
+);
     const html = (
         \\<p>My
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10220,15 +11289,17 @@ test "Example 579" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 580" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\![foo](<url>)
-    );
+
+);
     const html = (
         \\<p><img
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10236,15 +11307,17 @@ test "Example 580" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 581" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\![](/url)
-    );
+
+);
     const html = (
         \\<p><img
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10252,6 +11325,7 @@ test "Example 581" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 582" {
     const alloc = std.testing.allocator;
 
@@ -10259,10 +11333,10 @@ test "Example 582" {
         \\![foo][bar]
         \\
         \\[bar]:
-    );
+);
     const html = (
         \\<p><img
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10270,6 +11344,7 @@ test "Example 582" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 583" {
     const alloc = std.testing.allocator;
 
@@ -10277,10 +11352,10 @@ test "Example 583" {
         \\![foo][bar]
         \\
         \\[BAR]:
-    );
+);
     const html = (
         \\<p><img
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10288,6 +11363,7 @@ test "Example 583" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 584" {
     const alloc = std.testing.allocator;
 
@@ -10295,10 +11371,10 @@ test "Example 584" {
         \\![foo][]
         \\
         \\[foo]:
-    );
+);
     const html = (
         \\<p><img
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10306,15 +11382,16 @@ test "Example 584" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 585" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\![*foo*
-    );
+);
     const html = (
         \\<p><img
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10322,6 +11399,7 @@ test "Example 585" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 586" {
     const alloc = std.testing.allocator;
 
@@ -10329,10 +11407,10 @@ test "Example 586" {
         \\![Foo][]
         \\
         \\[foo]:
-    );
+);
     const html = (
         \\<p><img
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10340,15 +11418,16 @@ test "Example 586" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 587" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\![foo]
-    );
+);
     const html = (
         \\<p><img
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10356,6 +11435,7 @@ test "Example 587" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 588" {
     const alloc = std.testing.allocator;
 
@@ -10363,10 +11443,10 @@ test "Example 588" {
         \\![foo]
         \\
         \\[foo]:
-    );
+);
     const html = (
         \\<p><img
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10374,15 +11454,16 @@ test "Example 588" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 589" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\![*foo*
-    );
+);
     const html = (
         \\<p><img
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10390,6 +11471,7 @@ test "Example 589" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 590" {
     const alloc = std.testing.allocator;
 
@@ -10397,11 +11479,11 @@ test "Example 590" {
         \\![[foo]]
         \\
         \\[[foo]]:
-    );
+);
     const html = (
         \\<p>![[foo]]</p>
         \\<p>[[foo]]:
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10409,6 +11491,7 @@ test "Example 590" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 591" {
     const alloc = std.testing.allocator;
 
@@ -10416,10 +11499,10 @@ test "Example 591" {
         \\![Foo]
         \\
         \\[foo]:
-    );
+);
     const html = (
         \\<p><img
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10427,6 +11510,7 @@ test "Example 591" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 592" {
     const alloc = std.testing.allocator;
 
@@ -10434,10 +11518,11 @@ test "Example 592" {
         \\!\[foo]
         \\
         \\[foo]:
-    );
+);
     const html = (
         \\<p>![foo]</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10445,6 +11530,7 @@ test "Example 592" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 593" {
     const alloc = std.testing.allocator;
 
@@ -10452,10 +11538,10 @@ test "Example 593" {
         \\\![foo]
         \\
         \\[foo]:
-    );
+);
     const html = (
         \\<p>!<a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10463,15 +11549,17 @@ test "Example 593" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 594" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<http://foo.bar.baz>
-    );
+
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10479,15 +11567,17 @@ test "Example 594" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 595" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<https://foo.bar.baz/test?q=hello&id=22&boolean>
-    );
+
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10495,15 +11585,17 @@ test "Example 595" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 596" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<irc://foo.bar:2233/baz>
-    );
+
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10511,15 +11603,17 @@ test "Example 596" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 597" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<MAILTO:FOO@BAR.BAZ>
-    );
+
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10527,15 +11621,17 @@ test "Example 597" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 598" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<a+b+c:d>
-    );
+
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10543,15 +11639,17 @@ test "Example 598" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 599" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<made-up-scheme://foo,bar>
-    );
+
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10559,15 +11657,17 @@ test "Example 599" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 600" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<https://../>
-    );
+
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10575,15 +11675,17 @@ test "Example 600" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 601" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<localhost:5001/foo>
-    );
+
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10591,15 +11693,16 @@ test "Example 601" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 602" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<https://foo.bar/baz
-    );
+);
     const html = (
         \\<p>&lt;https://foo.bar/baz
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10607,15 +11710,17 @@ test "Example 602" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 603" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<https://example.com/\[\>
-    );
+
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10623,15 +11728,17 @@ test "Example 603" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 604" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<foo@bar.example.com>
-    );
+
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10639,15 +11746,17 @@ test "Example 604" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 605" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<foo+special@Bar.baz-bar0.com>
-    );
+
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10655,15 +11764,18 @@ test "Example 605" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 606" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<foo\+@bar.example.com>
-    );
+
+);
     const html = (
         \\<p>&lt;foo+@bar.example.com&gt;</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10671,15 +11783,18 @@ test "Example 606" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 607" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<>
-    );
+
+);
     const html = (
         \\<p>&lt;&gt;</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10687,15 +11802,16 @@ test "Example 607" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 608" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<
-    );
+);
     const html = (
         \\<p>&lt;
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10703,15 +11819,18 @@ test "Example 608" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 609" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<m:abc>
-    );
+
+);
     const html = (
         \\<p>&lt;m:abc&gt;</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10719,15 +11838,18 @@ test "Example 609" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 610" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<foo.bar.baz>
-    );
+
+);
     const html = (
         \\<p>&lt;foo.bar.baz&gt;</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10735,15 +11857,18 @@ test "Example 610" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 611" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\https://example.com
-    );
+
+);
     const html = (
         \\<p>https://example.com</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10751,15 +11876,18 @@ test "Example 611" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 612" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo@bar.example.com
-    );
+
+);
     const html = (
         \\<p>foo@bar.example.com</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10767,15 +11895,18 @@ test "Example 612" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 613" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<a><bab><c2c>
-    );
+
+);
     const html = (
         \\<p><a><bab><c2c></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10783,15 +11914,18 @@ test "Example 613" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 614" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<a/><b2/>
-    );
+
+);
     const html = (
         \\<p><a/><b2/></p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10799,15 +11933,16 @@ test "Example 614" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 615" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<a
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10815,15 +11950,16 @@ test "Example 615" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 616" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<a
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10831,15 +11967,16 @@ test "Example 616" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 617" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\Foo
-    );
+);
     const html = (
         \\<p>Foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10847,15 +11984,16 @@ test "Example 617" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 618" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<33>
-    );
+);
     const html = (
         \\<p>&lt;33&gt;
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10863,15 +12001,16 @@ test "Example 618" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 619" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<a
-    );
+);
     const html = (
         \\<p>&lt;a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10879,15 +12018,16 @@ test "Example 619" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 620" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<a
-    );
+);
     const html = (
         \\<p>&lt;a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10895,15 +12035,16 @@ test "Example 620" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 621" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<
-    );
+);
     const html = (
         \\<p>&lt;
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10911,15 +12052,16 @@ test "Example 621" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 622" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<a
-    );
+);
     const html = (
         \\<p>&lt;a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10927,15 +12069,16 @@ test "Example 622" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 623" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\</a></foo
-    );
+);
     const html = (
         \\<p></a></foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10943,15 +12086,16 @@ test "Example 623" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 624" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\</a
-    );
+);
     const html = (
         \\<p>&lt;/a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10959,15 +12103,16 @@ test "Example 624" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 625" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo
-    );
+);
     const html = (
         \\<p>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10975,15 +12120,16 @@ test "Example 625" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 626" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo
-    );
+);
     const html = (
         \\<p>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -10991,15 +12137,16 @@ test "Example 626" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 627" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo
-    );
+);
     const html = (
         \\<p>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -11007,15 +12154,16 @@ test "Example 627" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 628" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo
-    );
+);
     const html = (
         \\<p>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -11023,15 +12171,16 @@ test "Example 628" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 629" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo
-    );
+);
     const html = (
         \\<p>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -11039,15 +12188,16 @@ test "Example 629" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 630" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo
-    );
+);
     const html = (
         \\<p>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -11055,15 +12205,16 @@ test "Example 630" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 631" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo
-    );
+);
     const html = (
         \\<p>foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -11071,15 +12222,16 @@ test "Example 631" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 632" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<a
-    );
+);
     const html = (
         \\<p>&lt;a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -11087,15 +12239,16 @@ test "Example 632" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 633" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo
-    );
+);
     const html = (
         \\<p>foo<br
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -11103,16 +12256,18 @@ test "Example 633" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 634" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo\
         \\baz
-    );
+
+);
     const html = (
         \\<p>foo<br
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -11120,15 +12275,16 @@ test "Example 634" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 635" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo
-    );
+);
     const html = (
         \\<p>foo<br
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -11136,15 +12292,16 @@ test "Example 635" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 636" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo
-    );
+);
     const html = (
         \\<p>foo<br
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -11152,15 +12309,17 @@ test "Example 636" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 637" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo\
-    );
+
+);
     const html = (
         \\<p>foo<br
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -11168,15 +12327,16 @@ test "Example 637" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 638" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\*foo
-    );
+);
     const html = (
         \\<p><em>foo<br
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -11184,16 +12344,18 @@ test "Example 638" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 639" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\*foo\
         \\bar*
-    );
+
+);
     const html = (
         \\<p><em>foo<br
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -11201,15 +12363,16 @@ test "Example 639" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 640" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\`code
-    );
+);
     const html = (
         \\<p><code>code
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -11217,16 +12380,18 @@ test "Example 640" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 641" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\`code\
         \\span`
-    );
+
+);
     const html = (
         \\<p><code>code\
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -11234,15 +12399,16 @@ test "Example 641" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 642" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<a
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -11250,15 +12416,16 @@ test "Example 642" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 643" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\<a
-    );
+);
     const html = (
         \\<p><a
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -11266,15 +12433,18 @@ test "Example 643" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 644" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo\
-    );
+
+);
     const html = (
         \\<p>foo\</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -11282,15 +12452,17 @@ test "Example 644" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 645" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo
-    );
+);
     const html = (
         \\<p>foo</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -11298,15 +12470,17 @@ test "Example 645" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 646" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\###
-    );
+);
     const html = (
         \\<h3>foo\</h3>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -11314,15 +12488,17 @@ test "Example 646" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 647" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\###
-    );
+);
     const html = (
         \\<h3>foo</h3>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -11330,17 +12506,20 @@ test "Example 647" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 648" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo
         \\baz
-    );
+
+);
     const html = (
         \\<p>foo
         \\baz</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -11348,16 +12527,18 @@ test "Example 648" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 649" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\foo
-    );
+);
     const html = (
         \\<p>foo
         \\baz</p>
-    );
+
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -11365,15 +12546,16 @@ test "Example 649" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 650" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\hello
-    );
+);
     const html = (
         \\<p>hello
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -11381,15 +12563,16 @@ test "Example 650" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 651" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\Foo
-    );
+);
     const html = (
         \\<p>Foo
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
@@ -11397,18 +12580,20 @@ test "Example 651" {
     try std.testing.expectEqualStrings(html, output);
 }
 
+
 test "Example 652" {
     const alloc = std.testing.allocator;
 
     const md = (
         \\Multiple
-    );
+);
     const html = (
         \\<p>Multiple
-    );
+);
 
     const output = try convert(alloc, md);
     defer alloc.free(output);
 
     try std.testing.expectEqualStrings(html, output);
 }
+
diff --git a/src/main.zig b/src/main.zig
index 249e7bf..b50c9b9 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -21,10 +21,14 @@ pub fn find_blocks(src: []const u8, blocks: *std.ArrayList([]const u8)) !void {
 }
 
 pub fn convert(alloc: std.mem.Allocator, md: []const u8) ![]const u8 {
-    _ = alloc;
-    _ = md;
-    return error.UhOh;
+    return try alloc.dupe(u8, md);
+
+    // _ = alloc;
+    // _ = md;
+    // return error.UhOh;
     // return error.NotImplemented;
+
+    // return alloc.dupe(u8, "Hello World!");
 }
 
 pub fn main() !void {