diff --git a/create_tests.py b/create_tests.py
index 77d92bd..249fa21 100644
--- a/create_tests.py
+++ b/create_tests.py
@@ -30,7 +30,10 @@ with open("tests/test.json", "r") as txt:
 const Document = @import("attempt_2.zig").Document;
 const std = @import("std");
 const Token = @import("Token.zig");
-const expect = std.testing.expect;    
+const expect = std.testing.expect;
+
+const print_output: bool = true;
+
 """)
     tests : dict = json.loads(txt.read())
     for test_name, test_value in tests["basic_unit_tests"].items():
@@ -41,33 +44,37 @@ const expect = std.testing.expect;
             token_type = list(token.keys())[0]
             
             tokens += f"""
-        Token{{
-            .type = .{token_type},
-            .data = "{token[token_type].encode("unicode_escape").decode("utf-8")}",
-        }},"""
+//          Token{{
+//              .type = .{token_type},
+//              .data = "{token[token_type].encode("unicode_escape").decode("utf-8")}",
+//          }},"""
 
         print(f"""
-test "{test_name}" {{
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "{test_value["input"].encode("unicode_escape").decode("utf-8")}";
-    const parsed = [_]Token{{{tokens}
-    }};
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {{
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }}
-
-    doc.deinit(std.testing.allocator);
-}}
+// test "{test_name}" {{
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "{test_value["input"].encode("unicode_escape").decode("utf-8")}";
+//     const parsed = [_]Token{{{tokens}
+//     }};
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {{
+//         if (print_output) {{
+//             std.debug.print("expected_token : {{f}} | actual_token : {{f}}\\n", .{{ expected_token, actual_token }});
+//         }} else {{
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }}
+//     }}
+// 
+//     doc.deinit(std.testing.allocator);
+// }}
 """)
         # pprint(test_value["parsed"])
 
diff --git a/src/attempt_2.zig b/src/attempt_2.zig
index e40c0a7..221f3e6 100644
--- a/src/attempt_2.zig
+++ b/src/attempt_2.zig
@@ -26,10 +26,12 @@ const DocumentStyle = struct {
 
     heading_char: u8 = '#',
     heading_levels: usize = 6,
+    unordered_chars: []const u8 = "-++*",
 
     pub const default = Self{
         .heading_char = '#',
         .heading_levels = 6,
+        .unordered_chars = "-++*",
     };
 };
 
@@ -75,6 +77,7 @@ pub const Document = struct {
 
         try doc.appendStartLineParsers(alloc, &[_]StartLineParserFn{
             &headingParser,
+            &listOrderedParser,
         });
 
         try doc.appendInlineParsers(alloc, &[_]InlineParserFn{
@@ -101,6 +104,11 @@ pub const Document = struct {
         self.inline_parsers.deinit(alloc);
     }
 
+    fn consumeChars(line: *[]const u8, amount_of_chars_to_consume: usize) error{too_many_chars_to_consume}!void {
+        if (line.len < amount_of_chars_to_consume) return error.too_many_chars_to_consume;
+        line.* = line.*[amount_of_chars_to_consume..];
+    }
+
     fn baseLineParser(self: *Self, alloc: std.mem.Allocator, line: *[]const u8) !FoundToken {
         try self.tokens.append(alloc, Token{
             .data = stripWhiteSpace(line.*),
@@ -112,11 +120,21 @@ pub const Document = struct {
 
     // im going to need to hide a stack in here somewhere
     fn inlineParser(self: *Self, alloc: std.mem.Allocator, line: *[]const u8) !void {
+        if (line.len == 0) return;
+
         for (self.inline_parsers.items) |parser| {
             _ = try parser(self, alloc, line);
         }
     }
 
+    fn appendNewLineToken(self: *Self, alloc: std.mem.Allocator) !void {
+        try self.tokens.append(alloc, Token{
+            .data = "\n",
+            .padding = 0,
+            .type = .newline,
+        });
+    }
+
     pub fn parse(self: *Self, alloc: std.mem.Allocator, document: []const u8) !void {
         var line_iter = std.mem.splitSequence(u8, document, self.newline_char.chars);
 
@@ -124,20 +142,27 @@ pub const Document = struct {
             var current_line = line;
 
             for (self.start_line_parsers.items) |parser| {
+                std.debug.print("line : \"{s}\"\n", .{line});
                 const token_found = try parser(self, alloc, &current_line);
 
                 if (token_found) break;
             }
 
             try self.inlineParser(alloc, &current_line);
+
+            try self.appendNewLineToken(alloc);
         }
     }
 
     pub fn headingParser(self: *Self, alloc: std.mem.Allocator, line: *[]const u8) !FoundToken {
+        // ignore empty lines
+        if (line.len == 0) return false;
+
         const heading_end_index: usize = blk: {
             var i: usize = 0;
             while (i < self.document_style.heading_levels) : (i += 1) {
                 if (line.*[i] == self.document_style.heading_char) continue;
+                break;
             }
             break :blk i;
         };
@@ -154,7 +179,87 @@ pub const Document = struct {
             .type = .heading,
         });
 
-        line.* = line.*[heading_end_index + space_remove ..];
+        try consumeChars(line, heading_end_index + space_remove);
+
         return true;
     }
+
+    pub fn listOrderedParser(self: *Self, alloc: std.mem.Allocator, line: *[]const u8) !FoundToken {
+        const clean_line = stripWhiteSpace(line.*);
+        const whitespace_chars_removed = countWhiteSpace(line.*, self.tab_width);
+        // check for the min length of chars
+        if (clean_line.len < 2) return false;
+
+        // find a point within the line
+        const index_of_dot = blk: {
+            if (std.mem.indexOf(u8, clean_line, ". ")) |i| {
+                break :blk i;
+            }
+            return false;
+        };
+        const number = clean_line[0..index_of_dot];
+        // if it has any spaces its not a order list id
+        if (std.mem.containsAtLeastScalar(u8, number, 1, ' ') or
+            std.mem.containsAtLeastScalar(u8, number, 1, '\t'))
+        {
+            return false;
+        }
+        // now work out what the number is
+        // "I": 1,
+        // "V": 5,
+        // "X": 10,
+        // "L": 50,
+        // "C": 100,
+        // "D": 500,
+        // "M": 1000
+
+        // roman numerials ill deal with these later
+
+        // these can be the same
+        // numbers
+
+        // letters & roman (at least all the i's)
+
+        const is_number = blk: {
+            _ = std.fmt.parseInt(usize, number, 10) catch break :blk false;
+            break :blk true;
+        };
+        const is_letter = std.ascii.isAlphabetic(number[0]);
+
+        // might change this so lists can start from 0 like a real programmer
+        if (is_number or is_letter) {
+            try self.tokens.append(alloc, Token{
+                .data = line.*[0 .. whitespace_chars_removed + number.len + 1],
+                .padding = whitespace_chars_removed,
+                .type = .ordered_list,
+            });
+
+            try consumeChars(line, whitespace_chars_removed + number.len + 2);
+        }
+
+        return false;
+    }
+
+    pub fn listUnorderedParser(self: *Self, alloc: std.mem.Allocator, line: *[]const u8) !FoundToken {
+        const clean_line = stripWhiteSpace(line);
+        const whitespace_chars_removed = @intFromPtr(clean_line.ptr) - @intFromPtr(line.ptr);
+        // check for the min length of chars
+        if (clean_line.len < 2) return null;
+
+        // check there is a space seperating the char and the text
+        if (clean_line[1] != ' ') return null;
+
+        if (clean_line[0] == '-' or clean_line[0] == '=' or clean_line[0] == '+' or clean_line[0] == '*') {
+            return LineParserReturn{
+                // +2 to remove "-. "
+                .pointer_offset = whitespace_chars_removed + 2,
+                .token = .{
+                    .data = clean_line[0..1],
+                    .type = .unordered_list,
+                },
+            };
+        }
+
+        return null;
+    }
 };
diff --git a/src/tests.zig b/src/tests.zig
index 9a7d06b..c78c163 100644
--- a/src/tests.zig
+++ b/src/tests.zig
@@ -3,6 +3,8 @@ const std = @import("std");
 const Token = @import("Token.zig");
 const expect = std.testing.expect;
 
+const print_output: bool = false;
+
 test "heading_1" {
     std.testing.refAllDecls(@This());
 
@@ -26,2873 +28,3190 @@ test "heading_1" {
 
     try doc.parse(std.testing.allocator, input);
 
-    // try expect(doc.tokens.items.len >= parsed.len);
+    if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
 
     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
-        // try expect(expected_token.type == actual_token.type);
-        // try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+        if (print_output) {
+            std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+        } else {
+            try expect(expected_token.type == actual_token.type);
+            try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+        }
     }
 
     doc.deinit(std.testing.allocator);
 }
 
-// test "heading_2" {
-//     std.testing.refAllDecls(@This());
+test "heading_2" {
+    std.testing.refAllDecls(@This());
 
-//     const doc = Document.initDefault(std.testing.allocator);
+    var doc = try Document.initDefault(std.testing.allocator);
 
-//     const input = "## hello this is a heading\n";
-//     const parsed = [_]Token{
-//         Token{
-//             .type = .heading,
-//             .data = "##",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "hello this is a heading",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//     };
+    const input = "## hello this is a heading\n";
+    const parsed = [_]Token{
+        Token{
+            .type = .heading,
+            .data = "##",
+        },
+        Token{
+            .type = .text,
+            .data = "hello this is a heading",
+        },
+        Token{
+            .type = .newline,
+            .data = "\n",
+        },
+    };
 
-//     try doc.parse(input, std.testing.allocator);
+    try doc.parse(std.testing.allocator, input);
 
-//     try expect(doc.tokens.items.len >= parsed.len);
+    if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
 
-//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-//     }
+    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+        if (print_output) {
+            std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+        } else {
+            try expect(expected_token.type == actual_token.type);
+            try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+        }
+    }
 
-//     doc.deinit(std.testing.allocator);
-// }
+    doc.deinit(std.testing.allocator);
+}
 
-// test "heading_3" {
-//     std.testing.refAllDecls(@This());
+test "heading_3" {
+    std.testing.refAllDecls(@This());
 
-//     const doc = Document.initDefault(std.testing.allocator);
+    var doc = try Document.initDefault(std.testing.allocator);
 
-//     const input = "### hello this is a heading\n";
-//     const parsed = [_]Token{
-//         Token{
-//             .type = .heading,
-//             .data = "###",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "hello this is a heading",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//     };
+    const input = "### hello this is a heading\n";
+    const parsed = [_]Token{
+        Token{
+            .type = .heading,
+            .data = "###",
+        },
+        Token{
+            .type = .text,
+            .data = "hello this is a heading",
+        },
+        Token{
+            .type = .newline,
+            .data = "\n",
+        },
+    };
 
-//     try doc.parse(input, std.testing.allocator);
+    try doc.parse(std.testing.allocator, input);
 
-//     try expect(doc.tokens.items.len >= parsed.len);
+    if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
 
-//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-//     }
+    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+        if (print_output) {
+            std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+        } else {
+            try expect(expected_token.type == actual_token.type);
+            try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+        }
+    }
 
-//     doc.deinit(std.testing.allocator);
-// }
+    doc.deinit(std.testing.allocator);
+}
 
-// test "heading_4" {
-//     std.testing.refAllDecls(@This());
+test "heading_4" {
+    std.testing.refAllDecls(@This());
 
-//     const doc = Document.initDefault(std.testing.allocator);
+    var doc = try Document.initDefault(std.testing.allocator);
 
-//     const input = "#### hello this is a heading\n";
-//     const parsed = [_]Token{
-//         Token{
-//             .type = .heading,
-//             .data = "####",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "hello this is a heading",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//     };
+    const input = "#### hello this is a heading\n";
+    const parsed = [_]Token{
+        Token{
+            .type = .heading,
+            .data = "####",
+        },
+        Token{
+            .type = .text,
+            .data = "hello this is a heading",
+        },
+        Token{
+            .type = .newline,
+            .data = "\n",
+        },
+    };
 
-//     try doc.parse(input, std.testing.allocator);
+    try doc.parse(std.testing.allocator, input);
 
-//     try expect(doc.tokens.items.len >= parsed.len);
+    if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
 
-//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-//     }
+    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+        if (print_output) {
+            std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+        } else {
+            try expect(expected_token.type == actual_token.type);
+            try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+        }
+    }
 
-//     doc.deinit(std.testing.allocator);
-// }
+    doc.deinit(std.testing.allocator);
+}
 
-// test "heading_5" {
-//     std.testing.refAllDecls(@This());
+test "heading_5" {
+    std.testing.refAllDecls(@This());
 
-//     const doc = Document.initDefault(std.testing.allocator);
+    var doc = try Document.initDefault(std.testing.allocator);
 
-//     const input = "##### hello this is a heading\n";
-//     const parsed = [_]Token{
-//         Token{
-//             .type = .heading,
-//             .data = "#####",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "hello this is a heading",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//     };
+    const input = "##### hello this is a heading\n";
+    const parsed = [_]Token{
+        Token{
+            .type = .heading,
+            .data = "#####",
+        },
+        Token{
+            .type = .text,
+            .data = "hello this is a heading",
+        },
+        Token{
+            .type = .newline,
+            .data = "\n",
+        },
+    };
 
-//     try doc.parse(input, std.testing.allocator);
+    try doc.parse(std.testing.allocator, input);
 
-//     try expect(doc.tokens.items.len >= parsed.len);
+    if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
 
-//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-//     }
+    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+        if (print_output) {
+            std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+        } else {
+            try expect(expected_token.type == actual_token.type);
+            try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+        }
+    }
 
-//     doc.deinit(std.testing.allocator);
-// }
+    doc.deinit(std.testing.allocator);
+}
 
-// test "heading_6" {
-//     std.testing.refAllDecls(@This());
+test "heading_6" {
+    std.testing.refAllDecls(@This());
 
-//     const doc = Document.initDefault(std.testing.allocator);
+    var doc = try Document.initDefault(std.testing.allocator);
 
-//     const input = "###### hello this is a heading\n";
-//     const parsed = [_]Token{
-//         Token{
-//             .type = .heading,
-//             .data = "######",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "hello this is a heading",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//     };
+    const input = "###### hello this is a heading\n";
+    const parsed = [_]Token{
+        Token{
+            .type = .heading,
+            .data = "######",
+        },
+        Token{
+            .type = .text,
+            .data = "hello this is a heading",
+        },
+        Token{
+            .type = .newline,
+            .data = "\n",
+        },
+    };
 
-//     try doc.parse(input, std.testing.allocator);
+    try doc.parse(std.testing.allocator, input);
 
-//     try expect(doc.tokens.items.len >= parsed.len);
+    if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
 
-//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-//     }
+    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+        if (print_output) {
+            std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+        } else {
+            try expect(expected_token.type == actual_token.type);
+            try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+        }
+    }
 
-//     doc.deinit(std.testing.allocator);
-// }
+    doc.deinit(std.testing.allocator);
+}
 
-// test "header_no_text" {
-//     std.testing.refAllDecls(@This());
+test "header_no_text" {
+    std.testing.refAllDecls(@This());
 
-//     const doc = Document.initDefault(std.testing.allocator);
+    var doc = try Document.initDefault(std.testing.allocator);
 
-//     const input = "######\n";
-//     const parsed = [_]Token{
-//         Token{
-//             .type = .heading,
-//             .data = "######",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//     };
+    const input = "######\n";
+    const parsed = [_]Token{
+        Token{
+            .type = .heading,
+            .data = "######",
+        },
+        Token{
+            .type = .newline,
+            .data = "\n",
+        },
+    };
 
-//     try doc.parse(input, std.testing.allocator);
+    try doc.parse(std.testing.allocator, input);
 
-//     try expect(doc.tokens.items.len >= parsed.len);
+    if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
 
-//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-//     }
+    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+        if (print_output) {
+            std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+        } else {
+            try expect(expected_token.type == actual_token.type);
+            try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+        }
+    }
 
-//     doc.deinit(std.testing.allocator);
-// }
+    doc.deinit(std.testing.allocator);
+}
 
-// test "text" {
-//     std.testing.refAllDecls(@This());
+test "text" {
+    std.testing.refAllDecls(@This());
 
-//     const doc = Document.initDefault(std.testing.allocator);
+    var doc = try Document.initDefault(std.testing.allocator);
 
-//     const input = "plain test\n";
-//     const parsed = [_]Token{
-//         Token{
-//             .type = .text,
-//             .data = "plain test",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//     };
+    const input = "plain test\n";
+    const parsed = [_]Token{
+        Token{
+            .type = .text,
+            .data = "plain test",
+        },
+        Token{
+            .type = .newline,
+            .data = "\n",
+        },
+    };
 
-//     try doc.parse(input, std.testing.allocator);
+    try doc.parse(std.testing.allocator, input);
 
-//     try expect(doc.tokens.items.len >= parsed.len);
+    if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
 
-//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-//     }
+    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+        if (print_output) {
+            std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+        } else {
+            try expect(expected_token.type == actual_token.type);
+            try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+        }
+    }
 
-//     doc.deinit(std.testing.allocator);
-// }
+    doc.deinit(std.testing.allocator);
+}
 
 // test "text_style_code" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "`plain test`\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .inline_style,
-//             .data = "`",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "plain test",
-//         },
-//         Token{
-//             .type = .inline_style,
-//             .data = "`",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .inline_style,
+//              .data = "`",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "plain test",
+//          },
+//          Token{
+//              .type = .inline_style,
+//              .data = "`",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "text_style_bold" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "!plain test!\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .inline_style,
-//             .data = "!",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "plain test",
-//         },
-//         Token{
-//             .type = .inline_style,
-//             .data = "!",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .inline_style,
+//              .data = "!",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "plain test",
+//          },
+//          Token{
+//              .type = .inline_style,
+//              .data = "!",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "text_style_italic" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "*plain test*\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .inline_style,
-//             .data = "*",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "plain test",
-//         },
-//         Token{
-//             .type = .inline_style,
-//             .data = "*",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .inline_style,
+//              .data = "*",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "plain test",
+//          },
+//          Token{
+//              .type = .inline_style,
+//              .data = "*",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "text_style_underline" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "_plain test_\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .inline_style,
-//             .data = "_",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "plain test",
-//         },
-//         Token{
-//             .type = .inline_style,
-//             .data = "_",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .inline_style,
+//              .data = "_",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "plain test",
+//          },
+//          Token{
+//              .type = .inline_style,
+//              .data = "_",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "text_style_strikethrough" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "~plain test~\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .inline_style,
-//             .data = "~",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "plain test",
-//         },
-//         Token{
-//             .type = .inline_style,
-//             .data = "~",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .inline_style,
+//              .data = "~",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "plain test",
+//          },
+//          Token{
+//              .type = .inline_style,
+//              .data = "~",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "text_style_highlighted" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "|plain test|\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .inline_style,
-//             .data = "|",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "plain test",
-//         },
-//         Token{
-//             .type = .inline_style,
-//             .data = "|",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .inline_style,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "plain test",
+//          },
+//          Token{
+//              .type = .inline_style,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "text_style_&" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "&plain test&\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .inline_style,
-//             .data = "&",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "plain test",
-//         },
-//         Token{
-//             .type = .inline_style,
-//             .data = "&",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .inline_style,
+//              .data = "&",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "plain test",
+//          },
+//          Token{
+//              .type = .inline_style,
+//              .data = "&",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "text_style_%" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "%plain test%\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .inline_style,
-//             .data = "%",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "plain test",
-//         },
-//         Token{
-//             .type = .inline_style,
-//             .data = "%",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .inline_style,
+//              .data = "%",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "plain test",
+//          },
+//          Token{
+//              .type = .inline_style,
+//              .data = "%",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "text_style_$" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "$plain test$\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .inline_style,
-//             .data = "$",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "plain test",
-//         },
-//         Token{
-//             .type = .inline_style,
-//             .data = "$",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .inline_style,
+//              .data = "$",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "plain test",
+//          },
+//          Token{
+//              .type = .inline_style,
+//              .data = "$",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "text_style_#" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "#plain test#\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .inline_style,
-//             .data = "#",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "plain test",
-//         },
-//         Token{
-//             .type = .inline_style,
-//             .data = "#",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .inline_style,
+//              .data = "#",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "plain test",
+//          },
+//          Token{
+//              .type = .inline_style,
+//              .data = "#",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "text_style_-" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "-plain test-\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .inline_style,
-//             .data = "-",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "plain test",
-//         },
-//         Token{
-//             .type = .inline_style,
-//             .data = "-",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .inline_style,
+//              .data = "-",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "plain test",
+//          },
+//          Token{
+//              .type = .inline_style,
+//              .data = "-",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "text_style_+" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "+plain test+\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .inline_style,
-//             .data = "+",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "plain test",
-//         },
-//         Token{
-//             .type = .inline_style,
-//             .data = "+",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .inline_style,
+//              .data = "+",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "plain test",
+//          },
+//          Token{
+//              .type = .inline_style,
+//              .data = "+",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "text_style_=" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "=plain test=\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .inline_style,
-//             .data = "=",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "plain test",
-//         },
-//         Token{
-//             .type = .inline_style,
-//             .data = "=",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .inline_style,
+//              .data = "=",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "plain test",
+//          },
+//          Token{
+//              .type = .inline_style,
+//              .data = "=",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "text_style_espaced" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "\\`plain test`\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .text,
-//             .data = "`plain test`",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .text,
+//              .data = "`plain test`",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "text_style_with_style_char_in_string" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "+plain something + something else test+\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .inline_style,
-//             .data = "+",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "plain something + something else test",
-//         },
-//         Token{
-//             .type = .inline_style,
-//             .data = "+",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .inline_style,
+//              .data = "+",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "plain something + something else test",
+//          },
+//          Token{
+//              .type = .inline_style,
+//              .data = "+",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "text_style_with_space right after" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "+ plain something + something else test+\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .text,
-//             .data = "+ plain something + something else test+",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .text,
+//              .data = "+ plain something + something else test+",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "text_style_super_script" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "sometext^2\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .text,
-//             .data = "sometext",
-//         },
-//         Token{
-//             .type = .sup,
-//             .data = "^",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "2",
-//         },
+//          Token{
+//              .type = .text,
+//              .data = "sometext",
+//          },
+//          Token{
+//              .type = .sup,
+//              .data = "^",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "2",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "text_style_sub_script" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "sometext_2\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .text,
-//             .data = "sometext",
-//         },
-//         Token{
-//             .type = .sub,
-//             .data = "_",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "2",
-//         },
+//          Token{
+//              .type = .text,
+//              .data = "sometext",
+//          },
+//          Token{
+//              .type = .sub,
+//              .data = "_",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "2",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
-// test "list_ordered_number" {
-//     std.testing.refAllDecls(@This());
+test "list_ordered_number" {
+    std.testing.refAllDecls(@This());
 
-//     const doc = Document.initDefault(std.testing.allocator);
+    var doc = try Document.initDefault(std.testing.allocator);
 
-//     const input = "1. ordered list\n2. ordered list\n3. ordered list\n";
-//     const parsed = [_]Token{
-//         Token{
-//             .type = .ordered_list,
-//             .data = "1.",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "ordered list",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//         Token{
-//             .type = .ordered_list,
-//             .data = "2.",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "ordered list",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//         Token{
-//             .type = .ordered_list,
-//             .data = "3.",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "ordered list",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//     };
+    const input = "1. ordered list\n2. ordered list\n3. ordered list\n";
+    const parsed = [_]Token{
+        Token{
+            .type = .ordered_list,
+            .data = "1.",
+        },
+        Token{
+            .type = .text,
+            .data = "ordered list",
+        },
+        Token{
+            .type = .newline,
+            .data = "\n",
+        },
+        Token{
+            .type = .ordered_list,
+            .data = "2.",
+        },
+        Token{
+            .type = .text,
+            .data = "ordered list",
+        },
+        Token{
+            .type = .newline,
+            .data = "\n",
+        },
+        Token{
+            .type = .ordered_list,
+            .data = "3.",
+        },
+        Token{
+            .type = .text,
+            .data = "ordered list",
+        },
+        Token{
+            .type = .newline,
+            .data = "\n",
+        },
+    };
 
-//     try doc.parse(input, std.testing.allocator);
+    try doc.parse(std.testing.allocator, input);
 
-//     try expect(doc.tokens.items.len >= parsed.len);
+    if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
 
-//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-//     }
+    // for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+    //     if (print_output) {
+    //         std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+    //     } else {
+    //         try expect(expected_token.type == actual_token.type);
+    //         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+    //     }
+    // }
 
-//     doc.deinit(std.testing.allocator);
-// }
+    for (doc.tokens.items) |actual_token| {
+        std.debug.print("actual_token : {f}\n", .{actual_token});
+    }
 
-// test "list_ordered_i" {
-//     std.testing.refAllDecls(@This());
+    doc.deinit(std.testing.allocator);
+}
 
-//     const doc = Document.initDefault(std.testing.allocator);
+test "list_ordered_i" {
+    std.testing.refAllDecls(@This());
 
-//     const input = "i. ordered list\nii. ordered list\niii. ordered list\n";
-//     const parsed = [_]Token{
-//         Token{
-//             .type = .ordered_list,
-//             .data = "i.",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "ordered list",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//         Token{
-//             .type = .ordered_list,
-//             .data = "ii.",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "ordered list",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//         Token{
-//             .type = .ordered_list,
-//             .data = "iii.",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "ordered list",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//     };
+    var doc = try Document.initDefault(std.testing.allocator);
 
-//     try doc.parse(input, std.testing.allocator);
+    const input = "i. ordered list\nii. ordered list\niii. ordered list\n";
+    const parsed = [_]Token{
+        Token{
+            .type = .ordered_list,
+            .data = "i.",
+        },
+        Token{
+            .type = .text,
+            .data = "ordered list",
+        },
+        Token{
+            .type = .newline,
+            .data = "\n",
+        },
+        Token{
+            .type = .ordered_list,
+            .data = "ii.",
+        },
+        Token{
+            .type = .text,
+            .data = "ordered list",
+        },
+        Token{
+            .type = .newline,
+            .data = "\n",
+        },
+        Token{
+            .type = .ordered_list,
+            .data = "iii.",
+        },
+        Token{
+            .type = .text,
+            .data = "ordered list",
+        },
+        Token{
+            .type = .newline,
+            .data = "\n",
+        },
+    };
 
-//     try expect(doc.tokens.items.len >= parsed.len);
+    try doc.parse(std.testing.allocator, input);
 
-//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-//     }
+    if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
 
-//     doc.deinit(std.testing.allocator);
-// }
+    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+        if (print_output) {
+            std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+        } else {
+            try expect(expected_token.type == actual_token.type);
+            try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+        }
+    }
 
-// test "list_ordered_letter" {
-//     std.testing.refAllDecls(@This());
+    doc.deinit(std.testing.allocator);
+}
 
-//     const doc = Document.initDefault(std.testing.allocator);
+test "list_ordered_letter" {
+    std.testing.refAllDecls(@This());
 
-//     const input = "a. ordered list\nb. ordered list\nc. ordered list\n";
-//     const parsed = [_]Token{
-//         Token{
-//             .type = .ordered_list,
-//             .data = "a.",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "ordered list",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//         Token{
-//             .type = .ordered_list,
-//             .data = "b.",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "ordered list",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//         Token{
-//             .type = .ordered_list,
-//             .data = "c.",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "ordered list",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//     };
+    var doc = try Document.initDefault(std.testing.allocator);
 
-//     try doc.parse(input, std.testing.allocator);
+    const input = "a. ordered list\nb. ordered list\nc. ordered list\n";
+    const parsed = [_]Token{
+        Token{
+            .type = .ordered_list,
+            .data = "a.",
+        },
+        Token{
+            .type = .text,
+            .data = "ordered list",
+        },
+        Token{
+            .type = .newline,
+            .data = "\n",
+        },
+        Token{
+            .type = .ordered_list,
+            .data = "b.",
+        },
+        Token{
+            .type = .text,
+            .data = "ordered list",
+        },
+        Token{
+            .type = .newline,
+            .data = "\n",
+        },
+        Token{
+            .type = .ordered_list,
+            .data = "c.",
+        },
+        Token{
+            .type = .text,
+            .data = "ordered list",
+        },
+        Token{
+            .type = .newline,
+            .data = "\n",
+        },
+    };
 
-//     try expect(doc.tokens.items.len >= parsed.len);
+    try doc.parse(std.testing.allocator, input);
 
-//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-//     }
+    if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
 
-//     doc.deinit(std.testing.allocator);
-// }
+    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+        if (print_output) {
+            std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+        } else {
+            try expect(expected_token.type == actual_token.type);
+            try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+        }
+    }
+
+    doc.deinit(std.testing.allocator);
+}
 
 // test "list_unordered_dashed" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "- unordered list\n- unordered list\n- unordered list\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .unordered_list,
-//             .data = "-",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "unordered list",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//         Token{
-//             .type = .unordered_list,
-//             .data = "-",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "unordered list",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//         Token{
-//             .type = .unordered_list,
-//             .data = "-",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "unordered list",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .unordered_list,
+//              .data = "-",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "unordered list",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .unordered_list,
+//              .data = "-",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "unordered list",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .unordered_list,
+//              .data = "-",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "unordered list",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "list_unordered_eq" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "= unordered list\n= unordered list\n= unordered list\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .unordered_list,
-//             .data = "=",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "unordered list",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//         Token{
-//             .type = .unordered_list,
-//             .data = "=",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "unordered list",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//         Token{
-//             .type = .unordered_list,
-//             .data = "=",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "unordered list",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .unordered_list,
+//              .data = "=",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "unordered list",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .unordered_list,
+//              .data = "=",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "unordered list",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .unordered_list,
+//              .data = "=",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "unordered list",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "list_unordered_plus" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "+ unordered list\n+ unordered list\n+ unordered list\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .unordered_list,
-//             .data = "+",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "unordered list",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//         Token{
-//             .type = .unordered_list,
-//             .data = "+",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "unordered list",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//         Token{
-//             .type = .unordered_list,
-//             .data = "+",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "unordered list",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .unordered_list,
+//              .data = "+",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "unordered list",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .unordered_list,
+//              .data = "+",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "unordered list",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .unordered_list,
+//              .data = "+",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "unordered list",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "list_unordered_dot" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "* unordered list\n* unordered list\n* unordered list\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .unordered_list,
-//             .data = "*",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "unordered list",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//         Token{
-//             .type = .unordered_list,
-//             .data = "*",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "unordered list",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//         Token{
-//             .type = .unordered_list,
-//             .data = "*",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "unordered list",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .unordered_list,
+//              .data = "*",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "unordered list",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .unordered_list,
+//              .data = "*",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "unordered list",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .unordered_list,
+//              .data = "*",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "unordered list",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "embed_image" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "![figure text](relitive path to image)\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .embed,
-//             .data = "!",
-//         },
-//         Token{
-//             .type = .bracket_open,
-//             .data = "[",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "figure text",
-//         },
-//         Token{
-//             .type = .bracket_close,
-//             .data = "]",
-//         },
-//         Token{
-//             .type = .bracket_open,
-//             .data = "(",
-//         },
-//         Token{
-//             .type = .raw_text,
-//             .data = "relitive path to image",
-//         },
-//         Token{
-//             .type = .bracket_close,
-//             .data = ")",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .embed,
+//              .data = "!",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "[",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "figure text",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = "]",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "(",
+//          },
+//          Token{
+//              .type = .raw_text,
+//              .data = "relitive path to image",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = ")",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "embed_table" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "#[table text](relitive path to tabulated data)\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .embed,
-//             .data = "#",
-//         },
-//         Token{
-//             .type = .bracket_open,
-//             .data = "[",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "table text",
-//         },
-//         Token{
-//             .type = .bracket_close,
-//             .data = "]",
-//         },
-//         Token{
-//             .type = .bracket_open,
-//             .data = "(",
-//         },
-//         Token{
-//             .type = .raw_text,
-//             .data = "relitive path to tabulated data",
-//         },
-//         Token{
-//             .type = .bracket_close,
-//             .data = ")",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .embed,
+//              .data = "#",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "[",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "table text",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = "]",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "(",
+//          },
+//          Token{
+//              .type = .raw_text,
+//              .data = "relitive path to tabulated data",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = ")",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "embed_file" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "$[file text](path to file#starting_line:ending_line)\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .embed,
-//             .data = "$",
-//         },
-//         Token{
-//             .type = .bracket_open,
-//             .data = "[",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "file text",
-//         },
-//         Token{
-//             .type = .bracket_close,
-//             .data = "]",
-//         },
-//         Token{
-//             .type = .bracket_open,
-//             .data = "(",
-//         },
-//         Token{
-//             .type = .raw_text,
-//             .data = "path to file#starting_line:ending_line",
-//         },
-//         Token{
-//             .type = .bracket_close,
-//             .data = ")",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .embed,
+//              .data = "$",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "[",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "file text",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = "]",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "(",
+//          },
+//          Token{
+//              .type = .raw_text,
+//              .data = "path to file#starting_line:ending_line",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = ")",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "embed_*" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "*[file text](file_path)\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .embed,
-//             .data = "*",
-//         },
-//         Token{
-//             .type = .bracket_open,
-//             .data = "[",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "file text",
-//         },
-//         Token{
-//             .type = .bracket_close,
-//             .data = "]",
-//         },
-//         Token{
-//             .type = .bracket_open,
-//             .data = "(",
-//         },
-//         Token{
-//             .type = .raw_text,
-//             .data = "file_path",
-//         },
-//         Token{
-//             .type = .bracket_close,
-//             .data = ")",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .embed,
+//              .data = "*",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "[",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "file text",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = "]",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "(",
+//          },
+//          Token{
+//              .type = .raw_text,
+//              .data = "file_path",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = ")",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "embed__" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "_[file text](file_path)\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .embed,
-//             .data = "_",
-//         },
-//         Token{
-//             .type = .bracket_open,
-//             .data = "[",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "file text",
-//         },
-//         Token{
-//             .type = .bracket_close,
-//             .data = "]",
-//         },
-//         Token{
-//             .type = .bracket_open,
-//             .data = "(",
-//         },
-//         Token{
-//             .type = .raw_text,
-//             .data = "file_path",
-//         },
-//         Token{
-//             .type = .bracket_close,
-//             .data = ")",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .embed,
+//              .data = "_",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "[",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "file text",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = "]",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "(",
+//          },
+//          Token{
+//              .type = .raw_text,
+//              .data = "file_path",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = ")",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "embed_~" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "~[file text](file_path)\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .embed,
-//             .data = "~",
-//         },
-//         Token{
-//             .type = .bracket_open,
-//             .data = "[",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "file text",
-//         },
-//         Token{
-//             .type = .bracket_close,
-//             .data = "]",
-//         },
-//         Token{
-//             .type = .bracket_open,
-//             .data = "(",
-//         },
-//         Token{
-//             .type = .raw_text,
-//             .data = "file_path",
-//         },
-//         Token{
-//             .type = .bracket_close,
-//             .data = ")",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .embed,
+//              .data = "~",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "[",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "file text",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = "]",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "(",
+//          },
+//          Token{
+//              .type = .raw_text,
+//              .data = "file_path",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = ")",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "embed_|" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "|[file text](file_path)\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .embed,
-//             .data = "|",
-//         },
-//         Token{
-//             .type = .bracket_open,
-//             .data = "[",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "file text",
-//         },
-//         Token{
-//             .type = .bracket_close,
-//             .data = "]",
-//         },
-//         Token{
-//             .type = .bracket_open,
-//             .data = "(",
-//         },
-//         Token{
-//             .type = .raw_text,
-//             .data = "file_path",
-//         },
-//         Token{
-//             .type = .bracket_close,
-//             .data = ")",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .embed,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "[",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "file text",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = "]",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "(",
+//          },
+//          Token{
+//              .type = .raw_text,
+//              .data = "file_path",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = ")",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "embed_&" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "&[file text](file_path)\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .embed,
-//             .data = "&",
-//         },
-//         Token{
-//             .type = .bracket_open,
-//             .data = "[",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "file text",
-//         },
-//         Token{
-//             .type = .bracket_close,
-//             .data = "]",
-//         },
-//         Token{
-//             .type = .bracket_open,
-//             .data = "(",
-//         },
-//         Token{
-//             .type = .raw_text,
-//             .data = "file_path",
-//         },
-//         Token{
-//             .type = .bracket_close,
-//             .data = ")",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .embed,
+//              .data = "&",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "[",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "file text",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = "]",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "(",
+//          },
+//          Token{
+//              .type = .raw_text,
+//              .data = "file_path",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = ")",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "embed_%" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "%[file text](file_path)\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .embed,
-//             .data = "%",
-//         },
-//         Token{
-//             .type = .bracket_open,
-//             .data = "[",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "file text",
-//         },
-//         Token{
-//             .type = .bracket_close,
-//             .data = "]",
-//         },
-//         Token{
-//             .type = .bracket_open,
-//             .data = "(",
-//         },
-//         Token{
-//             .type = .raw_text,
-//             .data = "file_path",
-//         },
-//         Token{
-//             .type = .bracket_close,
-//             .data = ")",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .embed,
+//              .data = "%",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "[",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "file text",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = "]",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "(",
+//          },
+//          Token{
+//              .type = .raw_text,
+//              .data = "file_path",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = ")",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "embed_-" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "-[file text](file_path)\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .embed,
-//             .data = "-",
-//         },
-//         Token{
-//             .type = .bracket_open,
-//             .data = "[",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "file text",
-//         },
-//         Token{
-//             .type = .bracket_close,
-//             .data = "]",
-//         },
-//         Token{
-//             .type = .bracket_open,
-//             .data = "(",
-//         },
-//         Token{
-//             .type = .raw_text,
-//             .data = "file_path",
-//         },
-//         Token{
-//             .type = .bracket_close,
-//             .data = ")",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .embed,
+//              .data = "-",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "[",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "file text",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = "]",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "(",
+//          },
+//          Token{
+//              .type = .raw_text,
+//              .data = "file_path",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = ")",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "embed_+" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "+[file text](file_path)\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .embed,
-//             .data = "+",
-//         },
-//         Token{
-//             .type = .bracket_open,
-//             .data = "[",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "file text",
-//         },
-//         Token{
-//             .type = .bracket_close,
-//             .data = "]",
-//         },
-//         Token{
-//             .type = .bracket_open,
-//             .data = "(",
-//         },
-//         Token{
-//             .type = .raw_text,
-//             .data = "file_path",
-//         },
-//         Token{
-//             .type = .bracket_close,
-//             .data = ")",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .embed,
+//              .data = "+",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "[",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "file text",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = "]",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "(",
+//          },
+//          Token{
+//              .type = .raw_text,
+//              .data = "file_path",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = ")",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "embed_=" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "=[file text](file_path)\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .embed,
-//             .data = "=",
-//         },
-//         Token{
-//             .type = .bracket_open,
-//             .data = "[",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "file text",
-//         },
-//         Token{
-//             .type = .bracket_close,
-//             .data = "]",
-//         },
-//         Token{
-//             .type = .bracket_open,
-//             .data = "(",
-//         },
-//         Token{
-//             .type = .raw_text,
-//             .data = "file_path",
-//         },
-//         Token{
-//             .type = .bracket_close,
-//             .data = ")",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .embed,
+//              .data = "=",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "[",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "file text",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = "]",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "(",
+//          },
+//          Token{
+//              .type = .raw_text,
+//              .data = "file_path",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = ")",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "embed_link" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "/[file text](link to something)\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .link,
-//             .data = "/",
-//         },
-//         Token{
-//             .type = .bracket_open,
-//             .data = "[",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "file text",
-//         },
-//         Token{
-//             .type = .bracket_close,
-//             .data = "]",
-//         },
-//         Token{
-//             .type = .bracket_open,
-//             .data = "(",
-//         },
-//         Token{
-//             .type = .raw_text,
-//             .data = "link to something",
-//         },
-//         Token{
-//             .type = .bracket_close,
-//             .data = ")",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .link,
+//              .data = "/",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "[",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "file text",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = "]",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "(",
+//          },
+//          Token{
+//              .type = .raw_text,
+//              .data = "link to something",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = ")",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "table" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "| col | col | col |\n| --- | --- | --- |\n| row | row | row |\n| row | row | row |\n| row | row | row |\n| row | row | row |\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .table_sep,
-//             .data = "|",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = " col ",
-//         },
-//         Token{
-//             .type = .table_sep,
-//             .data = "|",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = " col ",
-//         },
-//         Token{
-//             .type = .table_sep,
-//             .data = "|",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = " col ",
-//         },
-//         Token{
-//             .type = .table_sep,
-//             .data = "|",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//         Token{
-//             .type = .table_sep,
-//             .data = "|",
-//         },
-//         Token{
-//             .type = .table_row_sep,
-//             .data = " --- ",
-//         },
-//         Token{
-//             .type = .table_sep,
-//             .data = "|",
-//         },
-//         Token{
-//             .type = .table_row_sep,
-//             .data = " --- ",
-//         },
-//         Token{
-//             .type = .table_sep,
-//             .data = "|",
-//         },
-//         Token{
-//             .type = .table_row_sep,
-//             .data = " --- ",
-//         },
-//         Token{
-//             .type = .table_sep,
-//             .data = "|",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//         Token{
-//             .type = .table_sep,
-//             .data = "|",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = " row ",
-//         },
-//         Token{
-//             .type = .table_sep,
-//             .data = "|",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = " row ",
-//         },
-//         Token{
-//             .type = .table_sep,
-//             .data = "|",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = " row ",
-//         },
-//         Token{
-//             .type = .table_sep,
-//             .data = "|",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//         Token{
-//             .type = .table_sep,
-//             .data = "|",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = " row ",
-//         },
-//         Token{
-//             .type = .table_sep,
-//             .data = "|",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = " row ",
-//         },
-//         Token{
-//             .type = .table_sep,
-//             .data = "|",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = " row ",
-//         },
-//         Token{
-//             .type = .table_sep,
-//             .data = "|",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//         Token{
-//             .type = .table_sep,
-//             .data = "|",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = " row ",
-//         },
-//         Token{
-//             .type = .table_sep,
-//             .data = "|",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = " row ",
-//         },
-//         Token{
-//             .type = .table_sep,
-//             .data = "|",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = " row ",
-//         },
-//         Token{
-//             .type = .table_sep,
-//             .data = "|",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//         Token{
-//             .type = .table_sep,
-//             .data = "|",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = " row ",
-//         },
-//         Token{
-//             .type = .table_sep,
-//             .data = "|",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = " row ",
-//         },
-//         Token{
-//             .type = .table_sep,
-//             .data = "|",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = " row ",
-//         },
-//         Token{
-//             .type = .table_sep,
-//             .data = "|",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = " col ",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = " col ",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = " col ",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .table_row_sep,
+//              .data = " --- ",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .table_row_sep,
+//              .data = " --- ",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .table_row_sep,
+//              .data = " --- ",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = " row ",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = " row ",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = " row ",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = " row ",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = " row ",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = " row ",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = " row ",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = " row ",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = " row ",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = " row ",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = " row ",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = " row ",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "quote_arrow" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "> quote\n> quote\n> quote\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .quote,
-//             .data = ">",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "quote",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//         Token{
-//             .type = .quote,
-//             .data = ">",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "quote",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//         Token{
-//             .type = .quote,
-//             .data = ">",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "quote",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .quote,
+//              .data = ">",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "quote",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .quote,
+//              .data = ">",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "quote",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .quote,
+//              .data = ">",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "quote",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "quote_bar" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "| quote\n| quote\n| quote\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .quote,
-//             .data = "|",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "quote",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//         Token{
-//             .type = .quote,
-//             .data = "|",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "quote",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//         Token{
-//             .type = .quote,
-//             .data = "|",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "quote",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .quote,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "quote",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .quote,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "quote",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .quote,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "quote",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "text_block" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "```\nsome text or code\n```\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .code_block,
-//             .data = "```",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//         Token{
-//             .type = .raw_text,
-//             .data = "some text or code",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//         Token{
-//             .type = .code_block,
-//             .data = "```",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .code_block,
+//              .data = "```",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .raw_text,
+//              .data = "some text or code",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .code_block,
+//              .data = "```",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "code_block" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "```lang_name\nsome text or code\n```\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .code_block,
-//             .data = "```",
-//         },
-//         Token{
-//             .type = .raw_text,
-//             .data = "lang_name",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//         Token{
-//             .type = .raw_text,
-//             .data = "some text or code",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//         Token{
-//             .type = .code_block,
-//             .data = "```",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .code_block,
+//              .data = "```",
+//          },
+//          Token{
+//              .type = .raw_text,
+//              .data = "lang_name",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .raw_text,
+//              .data = "some text or code",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .code_block,
+//              .data = "```",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "passthrough_block" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "```passthrough\nsome text or code\n```\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .code_block,
-//             .data = "```",
-//         },
-//         Token{
-//             .type = .raw_text,
-//             .data = "passthrough",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//         Token{
-//             .type = .raw_text,
-//             .data = "some text or code",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//         Token{
-//             .type = .code_block,
-//             .data = "```",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .code_block,
+//              .data = "```",
+//          },
+//          Token{
+//              .type = .raw_text,
+//              .data = "passthrough",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .raw_text,
+//              .data = "some text or code",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .code_block,
+//              .data = "```",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "comment" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "// this is a comment\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .comment,
-//             .data = "// ",
-//         },
-//         Token{
-//             .type = .raw_text,
-//             .data = "this is a comment",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .comment,
+//              .data = "// ",
+//          },
+//          Token{
+//              .type = .raw_text,
+//              .data = "this is a comment",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "tick_box_empty" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "- [ ] something to check off\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .tickbox,
-//             .data = "- [ ]",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "something to check off",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .tickbox,
+//              .data = "- [ ]",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "something to check off",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "tick_box_checked" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "- [x] something checked off\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .tickbox,
-//             .data = "- [x]",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "something checked off",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .tickbox,
+//              .data = "- [x]",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "something checked off",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "tick_box_ticked" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "- [/] something ticked off\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .tickbox,
-//             .data = "- [/]",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "something ticked off",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .tickbox,
+//              .data = "- [/]",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "something ticked off",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "tick_box_dashed" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "- [~] something dashed off\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .tickbox,
-//             .data = "- [~]",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "something dashed off",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .tickbox,
+//              .data = "- [~]",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "something dashed off",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "horizontal_rule_straight_line" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "---\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .rule,
-//             .data = "---",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .rule,
+//              .data = "---",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "horizontal_rule_double_straight_line" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "===\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .rule,
-//             .data = "===",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .rule,
+//              .data = "===",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "horizontal_rule_big_dotted_straight_line" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "***\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .rule,
-//             .data = "***",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .rule,
+//              .data = "***",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "horizontal_rule_small_dotted_line" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "...\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .rule,
-//             .data = "...",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .rule,
+//              .data = "...",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "horizontal_rule_squiggly_line" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "&&&\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .rule,
-//             .data = "&&&",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .rule,
+//              .data = "&&&",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "horizontal_rule_jagged_line" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "^^^\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .rule,
-//             .data = "^^^",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .rule,
+//              .data = "^^^",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "footnote" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "sometext [^1]\n\n[^1]: footnote\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .text,
-//             .data = "sometext ",
-//         },
-//         Token{
-//             .type = .footnote,
-//             .data = "[^1]",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
-//         Token{
-//             .type = .footnote_def,
-//             .data = "[^1]:",
-//         },
-//         Token{
-//             .type = .text,
-//             .data = "footnote",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .text,
+//              .data = "sometext ",
+//          },
+//          Token{
+//              .type = .footnote,
+//              .data = "[^1]",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .footnote_def,
+//              .data = "[^1]:",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "footnote",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
 
 // test "inbulit" {
 //     std.testing.refAllDecls(@This());
-
-//     const doc = Document.initDefault(std.testing.allocator);
-
+//
+//     var doc = try Document.initDefault(std.testing.allocator);
+//
 //     const input = "@.macro(arg, arg2)\n";
 //     const parsed = [_]Token{
-//         Token{
-//             .type = .inbulit,
-//             .data = "macro",
-//         },
-//         Token{
-//             .type = .bracket_open,
-//             .data = "(",
-//         },
-//         Token{
-//             .type = .macro_arg,
-//             .data = "arg",
-//         },
-//         Token{
-//             .type = .arg_sep,
-//             .data = ",",
-//         },
-//         Token{
-//             .type = .macro_arg,
-//             .data = "arg2",
-//         },
-//         Token{
-//             .type = .bracket_close,
-//             .data = ")",
-//         },
-//         Token{
-//             .type = .newline,
-//             .data = "\n",
-//         },
+//          Token{
+//              .type = .inbulit,
+//              .data = "macro",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "(",
+//          },
+//          Token{
+//              .type = .macro_arg,
+//              .data = "arg",
+//          },
+//          Token{
+//              .type = .arg_sep,
+//              .data = ",",
+//          },
+//          Token{
+//              .type = .macro_arg,
+//              .data = "arg2",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = ")",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
 //     };
-
-//     try doc.parse(input, std.testing.allocator);
-
-//     try expect(doc.tokens.items.len >= parsed.len);
-
+//
+//
+//     try doc.parse(std.testing.allocator, input);
+//
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+//
 //     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-//         try expect(expected_token.type == actual_token.type);
-//         try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
 //     }
-
+//
 //     doc.deinit(std.testing.allocator);
 // }
diff --git a/test.zig b/test.zig
index c664cf3..5a3fe02 100644
--- a/test.zig
+++ b/test.zig
@@ -2,3028 +2,3291 @@
 const Document = @import("attempt_2.zig").Document;
 const std = @import("std");
 const Token = @import("Token.zig");
-const expect = std.testing.expect;    
-
-
-test "heading_1" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "# hello this is a heading\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .heading,
-            .data = "#",
-        },
-        Token{
-            .type = .text,
-            .data = "hello this is a heading",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "heading_2" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "## hello this is a heading\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .heading,
-            .data = "##",
-        },
-        Token{
-            .type = .text,
-            .data = "hello this is a heading",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "heading_3" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "### hello this is a heading\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .heading,
-            .data = "###",
-        },
-        Token{
-            .type = .text,
-            .data = "hello this is a heading",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "heading_4" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "#### hello this is a heading\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .heading,
-            .data = "####",
-        },
-        Token{
-            .type = .text,
-            .data = "hello this is a heading",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "heading_5" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "##### hello this is a heading\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .heading,
-            .data = "#####",
-        },
-        Token{
-            .type = .text,
-            .data = "hello this is a heading",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "heading_6" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "###### hello this is a heading\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .heading,
-            .data = "######",
-        },
-        Token{
-            .type = .text,
-            .data = "hello this is a heading",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "header_no_text" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "######\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .heading,
-            .data = "######",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "text" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "plain test\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .text,
-            .data = "plain test",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "text_style_code" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "`plain test`\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .inline_style,
-            .data = "`",
-        },
-        Token{
-            .type = .text,
-            .data = "plain test",
-        },
-        Token{
-            .type = .inline_style,
-            .data = "`",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "text_style_bold" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "!plain test!\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .inline_style,
-            .data = "!",
-        },
-        Token{
-            .type = .text,
-            .data = "plain test",
-        },
-        Token{
-            .type = .inline_style,
-            .data = "!",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "text_style_italic" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "*plain test*\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .inline_style,
-            .data = "*",
-        },
-        Token{
-            .type = .text,
-            .data = "plain test",
-        },
-        Token{
-            .type = .inline_style,
-            .data = "*",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "text_style_underline" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "_plain test_\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .inline_style,
-            .data = "_",
-        },
-        Token{
-            .type = .text,
-            .data = "plain test",
-        },
-        Token{
-            .type = .inline_style,
-            .data = "_",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "text_style_strikethrough" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "~plain test~\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .inline_style,
-            .data = "~",
-        },
-        Token{
-            .type = .text,
-            .data = "plain test",
-        },
-        Token{
-            .type = .inline_style,
-            .data = "~",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "text_style_highlighted" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "|plain test|\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .inline_style,
-            .data = "|",
-        },
-        Token{
-            .type = .text,
-            .data = "plain test",
-        },
-        Token{
-            .type = .inline_style,
-            .data = "|",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "text_style_&" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "&plain test&\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .inline_style,
-            .data = "&",
-        },
-        Token{
-            .type = .text,
-            .data = "plain test",
-        },
-        Token{
-            .type = .inline_style,
-            .data = "&",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "text_style_%" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "%plain test%\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .inline_style,
-            .data = "%",
-        },
-        Token{
-            .type = .text,
-            .data = "plain test",
-        },
-        Token{
-            .type = .inline_style,
-            .data = "%",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "text_style_$" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "$plain test$\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .inline_style,
-            .data = "$",
-        },
-        Token{
-            .type = .text,
-            .data = "plain test",
-        },
-        Token{
-            .type = .inline_style,
-            .data = "$",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "text_style_#" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "#plain test#\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .inline_style,
-            .data = "#",
-        },
-        Token{
-            .type = .text,
-            .data = "plain test",
-        },
-        Token{
-            .type = .inline_style,
-            .data = "#",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "text_style_-" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "-plain test-\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .inline_style,
-            .data = "-",
-        },
-        Token{
-            .type = .text,
-            .data = "plain test",
-        },
-        Token{
-            .type = .inline_style,
-            .data = "-",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "text_style_+" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "+plain test+\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .inline_style,
-            .data = "+",
-        },
-        Token{
-            .type = .text,
-            .data = "plain test",
-        },
-        Token{
-            .type = .inline_style,
-            .data = "+",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "text_style_=" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "=plain test=\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .inline_style,
-            .data = "=",
-        },
-        Token{
-            .type = .text,
-            .data = "plain test",
-        },
-        Token{
-            .type = .inline_style,
-            .data = "=",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "text_style_espaced" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "\\`plain test`\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .text,
-            .data = "`plain test`",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "text_style_with_style_char_in_string" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "+plain something + something else test+\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .inline_style,
-            .data = "+",
-        },
-        Token{
-            .type = .text,
-            .data = "plain something + something else test",
-        },
-        Token{
-            .type = .inline_style,
-            .data = "+",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "text_style_with_space right after" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "+ plain something + something else test+\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .text,
-            .data = "+ plain something + something else test+",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "text_style_super_script" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "sometext^2\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .text,
-            .data = "sometext",
-        },
-        Token{
-            .type = .sup,
-            .data = "^",
-        },
-        Token{
-            .type = .text,
-            .data = "2",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "text_style_sub_script" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "sometext_2\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .text,
-            .data = "sometext",
-        },
-        Token{
-            .type = .sub,
-            .data = "_",
-        },
-        Token{
-            .type = .text,
-            .data = "2",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "list_ordered_number" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "1. ordered list\n2. ordered list\n3. ordered list\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .ordered_list,
-            .data = "1.",
-        },
-        Token{
-            .type = .text,
-            .data = "ordered list",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-        Token{
-            .type = .ordered_list,
-            .data = "2.",
-        },
-        Token{
-            .type = .text,
-            .data = "ordered list",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-        Token{
-            .type = .ordered_list,
-            .data = "3.",
-        },
-        Token{
-            .type = .text,
-            .data = "ordered list",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "list_ordered_i" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "i. ordered list\nii. ordered list\niii. ordered list\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .ordered_list,
-            .data = "i.",
-        },
-        Token{
-            .type = .text,
-            .data = "ordered list",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-        Token{
-            .type = .ordered_list,
-            .data = "ii.",
-        },
-        Token{
-            .type = .text,
-            .data = "ordered list",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-        Token{
-            .type = .ordered_list,
-            .data = "iii.",
-        },
-        Token{
-            .type = .text,
-            .data = "ordered list",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "list_ordered_letter" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "a. ordered list\nb. ordered list\nc. ordered list\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .ordered_list,
-            .data = "a.",
-        },
-        Token{
-            .type = .text,
-            .data = "ordered list",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-        Token{
-            .type = .ordered_list,
-            .data = "b.",
-        },
-        Token{
-            .type = .text,
-            .data = "ordered list",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-        Token{
-            .type = .ordered_list,
-            .data = "c.",
-        },
-        Token{
-            .type = .text,
-            .data = "ordered list",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "list_unordered_dashed" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "- unordered list\n- unordered list\n- unordered list\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .unordered_list,
-            .data = "-",
-        },
-        Token{
-            .type = .text,
-            .data = "unordered list",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-        Token{
-            .type = .unordered_list,
-            .data = "-",
-        },
-        Token{
-            .type = .text,
-            .data = "unordered list",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-        Token{
-            .type = .unordered_list,
-            .data = "-",
-        },
-        Token{
-            .type = .text,
-            .data = "unordered list",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "list_unordered_eq" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "= unordered list\n= unordered list\n= unordered list\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .unordered_list,
-            .data = "=",
-        },
-        Token{
-            .type = .text,
-            .data = "unordered list",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-        Token{
-            .type = .unordered_list,
-            .data = "=",
-        },
-        Token{
-            .type = .text,
-            .data = "unordered list",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-        Token{
-            .type = .unordered_list,
-            .data = "=",
-        },
-        Token{
-            .type = .text,
-            .data = "unordered list",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "list_unordered_plus" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "+ unordered list\n+ unordered list\n+ unordered list\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .unordered_list,
-            .data = "+",
-        },
-        Token{
-            .type = .text,
-            .data = "unordered list",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-        Token{
-            .type = .unordered_list,
-            .data = "+",
-        },
-        Token{
-            .type = .text,
-            .data = "unordered list",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-        Token{
-            .type = .unordered_list,
-            .data = "+",
-        },
-        Token{
-            .type = .text,
-            .data = "unordered list",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "list_unordered_dot" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "* unordered list\n* unordered list\n* unordered list\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .unordered_list,
-            .data = "*",
-        },
-        Token{
-            .type = .text,
-            .data = "unordered list",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-        Token{
-            .type = .unordered_list,
-            .data = "*",
-        },
-        Token{
-            .type = .text,
-            .data = "unordered list",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-        Token{
-            .type = .unordered_list,
-            .data = "*",
-        },
-        Token{
-            .type = .text,
-            .data = "unordered list",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "embed_image" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "![figure text](relitive path to image)\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .embed,
-            .data = "!",
-        },
-        Token{
-            .type = .bracket_open,
-            .data = "[",
-        },
-        Token{
-            .type = .text,
-            .data = "figure text",
-        },
-        Token{
-            .type = .bracket_close,
-            .data = "]",
-        },
-        Token{
-            .type = .bracket_open,
-            .data = "(",
-        },
-        Token{
-            .type = .raw_text,
-            .data = "relitive path to image",
-        },
-        Token{
-            .type = .bracket_close,
-            .data = ")",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "embed_table" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "#[table text](relitive path to tabulated data)\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .embed,
-            .data = "#",
-        },
-        Token{
-            .type = .bracket_open,
-            .data = "[",
-        },
-        Token{
-            .type = .text,
-            .data = "table text",
-        },
-        Token{
-            .type = .bracket_close,
-            .data = "]",
-        },
-        Token{
-            .type = .bracket_open,
-            .data = "(",
-        },
-        Token{
-            .type = .raw_text,
-            .data = "relitive path to tabulated data",
-        },
-        Token{
-            .type = .bracket_close,
-            .data = ")",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "embed_file" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "$[file text](path to file#starting_line:ending_line)\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .embed,
-            .data = "$",
-        },
-        Token{
-            .type = .bracket_open,
-            .data = "[",
-        },
-        Token{
-            .type = .text,
-            .data = "file text",
-        },
-        Token{
-            .type = .bracket_close,
-            .data = "]",
-        },
-        Token{
-            .type = .bracket_open,
-            .data = "(",
-        },
-        Token{
-            .type = .raw_text,
-            .data = "path to file#starting_line:ending_line",
-        },
-        Token{
-            .type = .bracket_close,
-            .data = ")",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "embed_*" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "*[file text](file_path)\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .embed,
-            .data = "*",
-        },
-        Token{
-            .type = .bracket_open,
-            .data = "[",
-        },
-        Token{
-            .type = .text,
-            .data = "file text",
-        },
-        Token{
-            .type = .bracket_close,
-            .data = "]",
-        },
-        Token{
-            .type = .bracket_open,
-            .data = "(",
-        },
-        Token{
-            .type = .raw_text,
-            .data = "file_path",
-        },
-        Token{
-            .type = .bracket_close,
-            .data = ")",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "embed__" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "_[file text](file_path)\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .embed,
-            .data = "_",
-        },
-        Token{
-            .type = .bracket_open,
-            .data = "[",
-        },
-        Token{
-            .type = .text,
-            .data = "file text",
-        },
-        Token{
-            .type = .bracket_close,
-            .data = "]",
-        },
-        Token{
-            .type = .bracket_open,
-            .data = "(",
-        },
-        Token{
-            .type = .raw_text,
-            .data = "file_path",
-        },
-        Token{
-            .type = .bracket_close,
-            .data = ")",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "embed_~" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "~[file text](file_path)\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .embed,
-            .data = "~",
-        },
-        Token{
-            .type = .bracket_open,
-            .data = "[",
-        },
-        Token{
-            .type = .text,
-            .data = "file text",
-        },
-        Token{
-            .type = .bracket_close,
-            .data = "]",
-        },
-        Token{
-            .type = .bracket_open,
-            .data = "(",
-        },
-        Token{
-            .type = .raw_text,
-            .data = "file_path",
-        },
-        Token{
-            .type = .bracket_close,
-            .data = ")",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "embed_|" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "|[file text](file_path)\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .embed,
-            .data = "|",
-        },
-        Token{
-            .type = .bracket_open,
-            .data = "[",
-        },
-        Token{
-            .type = .text,
-            .data = "file text",
-        },
-        Token{
-            .type = .bracket_close,
-            .data = "]",
-        },
-        Token{
-            .type = .bracket_open,
-            .data = "(",
-        },
-        Token{
-            .type = .raw_text,
-            .data = "file_path",
-        },
-        Token{
-            .type = .bracket_close,
-            .data = ")",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "embed_&" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "&[file text](file_path)\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .embed,
-            .data = "&",
-        },
-        Token{
-            .type = .bracket_open,
-            .data = "[",
-        },
-        Token{
-            .type = .text,
-            .data = "file text",
-        },
-        Token{
-            .type = .bracket_close,
-            .data = "]",
-        },
-        Token{
-            .type = .bracket_open,
-            .data = "(",
-        },
-        Token{
-            .type = .raw_text,
-            .data = "file_path",
-        },
-        Token{
-            .type = .bracket_close,
-            .data = ")",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "embed_%" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "%[file text](file_path)\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .embed,
-            .data = "%",
-        },
-        Token{
-            .type = .bracket_open,
-            .data = "[",
-        },
-        Token{
-            .type = .text,
-            .data = "file text",
-        },
-        Token{
-            .type = .bracket_close,
-            .data = "]",
-        },
-        Token{
-            .type = .bracket_open,
-            .data = "(",
-        },
-        Token{
-            .type = .raw_text,
-            .data = "file_path",
-        },
-        Token{
-            .type = .bracket_close,
-            .data = ")",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "embed_-" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "-[file text](file_path)\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .embed,
-            .data = "-",
-        },
-        Token{
-            .type = .bracket_open,
-            .data = "[",
-        },
-        Token{
-            .type = .text,
-            .data = "file text",
-        },
-        Token{
-            .type = .bracket_close,
-            .data = "]",
-        },
-        Token{
-            .type = .bracket_open,
-            .data = "(",
-        },
-        Token{
-            .type = .raw_text,
-            .data = "file_path",
-        },
-        Token{
-            .type = .bracket_close,
-            .data = ")",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "embed_+" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "+[file text](file_path)\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .embed,
-            .data = "+",
-        },
-        Token{
-            .type = .bracket_open,
-            .data = "[",
-        },
-        Token{
-            .type = .text,
-            .data = "file text",
-        },
-        Token{
-            .type = .bracket_close,
-            .data = "]",
-        },
-        Token{
-            .type = .bracket_open,
-            .data = "(",
-        },
-        Token{
-            .type = .raw_text,
-            .data = "file_path",
-        },
-        Token{
-            .type = .bracket_close,
-            .data = ")",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "embed_=" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "=[file text](file_path)\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .embed,
-            .data = "=",
-        },
-        Token{
-            .type = .bracket_open,
-            .data = "[",
-        },
-        Token{
-            .type = .text,
-            .data = "file text",
-        },
-        Token{
-            .type = .bracket_close,
-            .data = "]",
-        },
-        Token{
-            .type = .bracket_open,
-            .data = "(",
-        },
-        Token{
-            .type = .raw_text,
-            .data = "file_path",
-        },
-        Token{
-            .type = .bracket_close,
-            .data = ")",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "embed_link" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "/[file text](link to something)\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .link,
-            .data = "/",
-        },
-        Token{
-            .type = .bracket_open,
-            .data = "[",
-        },
-        Token{
-            .type = .text,
-            .data = "file text",
-        },
-        Token{
-            .type = .bracket_close,
-            .data = "]",
-        },
-        Token{
-            .type = .bracket_open,
-            .data = "(",
-        },
-        Token{
-            .type = .raw_text,
-            .data = "link to something",
-        },
-        Token{
-            .type = .bracket_close,
-            .data = ")",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "table" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "| col | col | col |\n| --- | --- | --- |\n| row | row | row |\n| row | row | row |\n| row | row | row |\n| row | row | row |\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .table_sep,
-            .data = "|",
-        },
-        Token{
-            .type = .text,
-            .data = " col ",
-        },
-        Token{
-            .type = .table_sep,
-            .data = "|",
-        },
-        Token{
-            .type = .text,
-            .data = " col ",
-        },
-        Token{
-            .type = .table_sep,
-            .data = "|",
-        },
-        Token{
-            .type = .text,
-            .data = " col ",
-        },
-        Token{
-            .type = .table_sep,
-            .data = "|",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-        Token{
-            .type = .table_sep,
-            .data = "|",
-        },
-        Token{
-            .type = .table_row_sep,
-            .data = " --- ",
-        },
-        Token{
-            .type = .table_sep,
-            .data = "|",
-        },
-        Token{
-            .type = .table_row_sep,
-            .data = " --- ",
-        },
-        Token{
-            .type = .table_sep,
-            .data = "|",
-        },
-        Token{
-            .type = .table_row_sep,
-            .data = " --- ",
-        },
-        Token{
-            .type = .table_sep,
-            .data = "|",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-        Token{
-            .type = .table_sep,
-            .data = "|",
-        },
-        Token{
-            .type = .text,
-            .data = " row ",
-        },
-        Token{
-            .type = .table_sep,
-            .data = "|",
-        },
-        Token{
-            .type = .text,
-            .data = " row ",
-        },
-        Token{
-            .type = .table_sep,
-            .data = "|",
-        },
-        Token{
-            .type = .text,
-            .data = " row ",
-        },
-        Token{
-            .type = .table_sep,
-            .data = "|",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-        Token{
-            .type = .table_sep,
-            .data = "|",
-        },
-        Token{
-            .type = .text,
-            .data = " row ",
-        },
-        Token{
-            .type = .table_sep,
-            .data = "|",
-        },
-        Token{
-            .type = .text,
-            .data = " row ",
-        },
-        Token{
-            .type = .table_sep,
-            .data = "|",
-        },
-        Token{
-            .type = .text,
-            .data = " row ",
-        },
-        Token{
-            .type = .table_sep,
-            .data = "|",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-        Token{
-            .type = .table_sep,
-            .data = "|",
-        },
-        Token{
-            .type = .text,
-            .data = " row ",
-        },
-        Token{
-            .type = .table_sep,
-            .data = "|",
-        },
-        Token{
-            .type = .text,
-            .data = " row ",
-        },
-        Token{
-            .type = .table_sep,
-            .data = "|",
-        },
-        Token{
-            .type = .text,
-            .data = " row ",
-        },
-        Token{
-            .type = .table_sep,
-            .data = "|",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-        Token{
-            .type = .table_sep,
-            .data = "|",
-        },
-        Token{
-            .type = .text,
-            .data = " row ",
-        },
-        Token{
-            .type = .table_sep,
-            .data = "|",
-        },
-        Token{
-            .type = .text,
-            .data = " row ",
-        },
-        Token{
-            .type = .table_sep,
-            .data = "|",
-        },
-        Token{
-            .type = .text,
-            .data = " row ",
-        },
-        Token{
-            .type = .table_sep,
-            .data = "|",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "quote_arrow" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "> quote\n> quote\n> quote\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .quote,
-            .data = ">",
-        },
-        Token{
-            .type = .text,
-            .data = "quote",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-        Token{
-            .type = .quote,
-            .data = ">",
-        },
-        Token{
-            .type = .text,
-            .data = "quote",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-        Token{
-            .type = .quote,
-            .data = ">",
-        },
-        Token{
-            .type = .text,
-            .data = "quote",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "quote_bar" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "| quote\n| quote\n| quote\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .quote,
-            .data = "|",
-        },
-        Token{
-            .type = .text,
-            .data = "quote",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-        Token{
-            .type = .quote,
-            .data = "|",
-        },
-        Token{
-            .type = .text,
-            .data = "quote",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-        Token{
-            .type = .quote,
-            .data = "|",
-        },
-        Token{
-            .type = .text,
-            .data = "quote",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "text_block" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "```\nsome text or code\n```\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .code_block,
-            .data = "```",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-        Token{
-            .type = .raw_text,
-            .data = "some text or code",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-        Token{
-            .type = .code_block,
-            .data = "```",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "code_block" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "```lang_name\nsome text or code\n```\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .code_block,
-            .data = "```",
-        },
-        Token{
-            .type = .raw_text,
-            .data = "lang_name",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-        Token{
-            .type = .raw_text,
-            .data = "some text or code",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-        Token{
-            .type = .code_block,
-            .data = "```",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "passthrough_block" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "```passthrough\nsome text or code\n```\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .code_block,
-            .data = "```",
-        },
-        Token{
-            .type = .raw_text,
-            .data = "passthrough",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-        Token{
-            .type = .raw_text,
-            .data = "some text or code",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-        Token{
-            .type = .code_block,
-            .data = "```",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "comment" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "// this is a comment\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .comment,
-            .data = "// ",
-        },
-        Token{
-            .type = .raw_text,
-            .data = "this is a comment",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "tick_box_empty" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "- [ ] something to check off\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .tickbox,
-            .data = "- [ ]",
-        },
-        Token{
-            .type = .text,
-            .data = "something to check off",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "tick_box_checked" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "- [x] something checked off\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .tickbox,
-            .data = "- [x]",
-        },
-        Token{
-            .type = .text,
-            .data = "something checked off",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "tick_box_ticked" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "- [/] something ticked off\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .tickbox,
-            .data = "- [/]",
-        },
-        Token{
-            .type = .text,
-            .data = "something ticked off",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "tick_box_dashed" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "- [~] something dashed off\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .tickbox,
-            .data = "- [~]",
-        },
-        Token{
-            .type = .text,
-            .data = "something dashed off",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "horizontal_rule_straight_line" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "---\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .rule,
-            .data = "---",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "horizontal_rule_double_straight_line" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "===\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .rule,
-            .data = "===",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "horizontal_rule_big_dotted_straight_line" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "***\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .rule,
-            .data = "***",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "horizontal_rule_small_dotted_line" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "...\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .rule,
-            .data = "...",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "horizontal_rule_squiggly_line" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "&&&\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .rule,
-            .data = "&&&",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "horizontal_rule_jagged_line" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "^^^\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .rule,
-            .data = "^^^",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "footnote" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "sometext [^1]\n\n[^1]: footnote\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .text,
-            .data = "sometext ",
-        },
-        Token{
-            .type = .footnote,
-            .data = "[^1]",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-        Token{
-            .type = .footnote_def,
-            .data = "[^1]:",
-        },
-        Token{
-            .type = .text,
-            .data = "footnote",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
-
-
-test "inbulit" {
-    std.testing.refAllDecls(@This());
-
-    const doc = Document.initDefault(std.testing.allocator);
-    
-    const input = "@.macro(arg, arg2)\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .inbulit,
-            .data = "macro",
-        },
-        Token{
-            .type = .bracket_open,
-            .data = "(",
-        },
-        Token{
-            .type = .macro_arg,
-            .data = "arg",
-        },
-        Token{
-            .type = .arg_sep,
-            .data = ",",
-        },
-        Token{
-            .type = .macro_arg,
-            .data = "arg2",
-        },
-        Token{
-            .type = .bracket_close,
-            .data = ")",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
-
-
-    try doc.parse(input, std.testing.allocator);
-
-    try expect(doc.tokens.items.len >= parsed.len);
-
-    for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
-        try expect(expected_token.type == actual_token.type);
-        try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
-    }
-
-    doc.deinit(std.testing.allocator);
-}
+const expect = std.testing.expect;
+
+const print_output: bool = true;
+
+
+
+// test "heading_1" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "# hello this is a heading\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .heading,
+//              .data = "#",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "hello this is a heading",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "heading_2" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "## hello this is a heading\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .heading,
+//              .data = "##",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "hello this is a heading",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "heading_3" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "### hello this is a heading\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .heading,
+//              .data = "###",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "hello this is a heading",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "heading_4" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "#### hello this is a heading\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .heading,
+//              .data = "####",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "hello this is a heading",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "heading_5" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "##### hello this is a heading\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .heading,
+//              .data = "#####",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "hello this is a heading",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "heading_6" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "###### hello this is a heading\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .heading,
+//              .data = "######",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "hello this is a heading",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "header_no_text" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "######\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .heading,
+//              .data = "######",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "text" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "plain test\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .text,
+//              .data = "plain test",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "text_style_code" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "`plain test`\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .inline_style,
+//              .data = "`",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "plain test",
+//          },
+//          Token{
+//              .type = .inline_style,
+//              .data = "`",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "text_style_bold" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "!plain test!\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .inline_style,
+//              .data = "!",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "plain test",
+//          },
+//          Token{
+//              .type = .inline_style,
+//              .data = "!",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "text_style_italic" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "*plain test*\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .inline_style,
+//              .data = "*",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "plain test",
+//          },
+//          Token{
+//              .type = .inline_style,
+//              .data = "*",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "text_style_underline" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "_plain test_\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .inline_style,
+//              .data = "_",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "plain test",
+//          },
+//          Token{
+//              .type = .inline_style,
+//              .data = "_",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "text_style_strikethrough" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "~plain test~\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .inline_style,
+//              .data = "~",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "plain test",
+//          },
+//          Token{
+//              .type = .inline_style,
+//              .data = "~",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "text_style_highlighted" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "|plain test|\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .inline_style,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "plain test",
+//          },
+//          Token{
+//              .type = .inline_style,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "text_style_&" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "&plain test&\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .inline_style,
+//              .data = "&",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "plain test",
+//          },
+//          Token{
+//              .type = .inline_style,
+//              .data = "&",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "text_style_%" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "%plain test%\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .inline_style,
+//              .data = "%",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "plain test",
+//          },
+//          Token{
+//              .type = .inline_style,
+//              .data = "%",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "text_style_$" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "$plain test$\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .inline_style,
+//              .data = "$",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "plain test",
+//          },
+//          Token{
+//              .type = .inline_style,
+//              .data = "$",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "text_style_#" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "#plain test#\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .inline_style,
+//              .data = "#",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "plain test",
+//          },
+//          Token{
+//              .type = .inline_style,
+//              .data = "#",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "text_style_-" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "-plain test-\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .inline_style,
+//              .data = "-",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "plain test",
+//          },
+//          Token{
+//              .type = .inline_style,
+//              .data = "-",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "text_style_+" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "+plain test+\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .inline_style,
+//              .data = "+",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "plain test",
+//          },
+//          Token{
+//              .type = .inline_style,
+//              .data = "+",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "text_style_=" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "=plain test=\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .inline_style,
+//              .data = "=",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "plain test",
+//          },
+//          Token{
+//              .type = .inline_style,
+//              .data = "=",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "text_style_espaced" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "\\`plain test`\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .text,
+//              .data = "`plain test`",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "text_style_with_style_char_in_string" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "+plain something + something else test+\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .inline_style,
+//              .data = "+",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "plain something + something else test",
+//          },
+//          Token{
+//              .type = .inline_style,
+//              .data = "+",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "text_style_with_space right after" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "+ plain something + something else test+\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .text,
+//              .data = "+ plain something + something else test+",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "text_style_super_script" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "sometext^2\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .text,
+//              .data = "sometext",
+//          },
+//          Token{
+//              .type = .sup,
+//              .data = "^",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "2",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "text_style_sub_script" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "sometext_2\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .text,
+//              .data = "sometext",
+//          },
+//          Token{
+//              .type = .sub,
+//              .data = "_",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "2",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "list_ordered_number" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "1. ordered list\n2. ordered list\n3. ordered list\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .ordered_list,
+//              .data = "1.",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "ordered list",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .ordered_list,
+//              .data = "2.",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "ordered list",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .ordered_list,
+//              .data = "3.",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "ordered list",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "list_ordered_i" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "i. ordered list\nii. ordered list\niii. ordered list\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .ordered_list,
+//              .data = "i.",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "ordered list",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .ordered_list,
+//              .data = "ii.",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "ordered list",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .ordered_list,
+//              .data = "iii.",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "ordered list",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "list_ordered_letter" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "a. ordered list\nb. ordered list\nc. ordered list\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .ordered_list,
+//              .data = "a.",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "ordered list",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .ordered_list,
+//              .data = "b.",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "ordered list",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .ordered_list,
+//              .data = "c.",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "ordered list",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "list_unordered_dashed" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "- unordered list\n- unordered list\n- unordered list\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .unordered_list,
+//              .data = "-",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "unordered list",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .unordered_list,
+//              .data = "-",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "unordered list",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .unordered_list,
+//              .data = "-",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "unordered list",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "list_unordered_eq" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "= unordered list\n= unordered list\n= unordered list\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .unordered_list,
+//              .data = "=",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "unordered list",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .unordered_list,
+//              .data = "=",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "unordered list",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .unordered_list,
+//              .data = "=",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "unordered list",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "list_unordered_plus" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "+ unordered list\n+ unordered list\n+ unordered list\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .unordered_list,
+//              .data = "+",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "unordered list",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .unordered_list,
+//              .data = "+",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "unordered list",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .unordered_list,
+//              .data = "+",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "unordered list",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "list_unordered_dot" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "* unordered list\n* unordered list\n* unordered list\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .unordered_list,
+//              .data = "*",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "unordered list",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .unordered_list,
+//              .data = "*",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "unordered list",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .unordered_list,
+//              .data = "*",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "unordered list",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "embed_image" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "![figure text](relitive path to image)\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .embed,
+//              .data = "!",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "[",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "figure text",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = "]",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "(",
+//          },
+//          Token{
+//              .type = .raw_text,
+//              .data = "relitive path to image",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = ")",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "embed_table" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "#[table text](relitive path to tabulated data)\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .embed,
+//              .data = "#",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "[",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "table text",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = "]",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "(",
+//          },
+//          Token{
+//              .type = .raw_text,
+//              .data = "relitive path to tabulated data",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = ")",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "embed_file" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "$[file text](path to file#starting_line:ending_line)\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .embed,
+//              .data = "$",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "[",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "file text",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = "]",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "(",
+//          },
+//          Token{
+//              .type = .raw_text,
+//              .data = "path to file#starting_line:ending_line",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = ")",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "embed_*" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "*[file text](file_path)\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .embed,
+//              .data = "*",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "[",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "file text",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = "]",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "(",
+//          },
+//          Token{
+//              .type = .raw_text,
+//              .data = "file_path",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = ")",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "embed__" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "_[file text](file_path)\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .embed,
+//              .data = "_",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "[",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "file text",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = "]",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "(",
+//          },
+//          Token{
+//              .type = .raw_text,
+//              .data = "file_path",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = ")",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "embed_~" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "~[file text](file_path)\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .embed,
+//              .data = "~",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "[",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "file text",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = "]",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "(",
+//          },
+//          Token{
+//              .type = .raw_text,
+//              .data = "file_path",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = ")",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "embed_|" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "|[file text](file_path)\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .embed,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "[",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "file text",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = "]",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "(",
+//          },
+//          Token{
+//              .type = .raw_text,
+//              .data = "file_path",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = ")",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "embed_&" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "&[file text](file_path)\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .embed,
+//              .data = "&",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "[",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "file text",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = "]",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "(",
+//          },
+//          Token{
+//              .type = .raw_text,
+//              .data = "file_path",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = ")",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "embed_%" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "%[file text](file_path)\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .embed,
+//              .data = "%",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "[",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "file text",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = "]",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "(",
+//          },
+//          Token{
+//              .type = .raw_text,
+//              .data = "file_path",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = ")",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "embed_-" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "-[file text](file_path)\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .embed,
+//              .data = "-",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "[",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "file text",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = "]",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "(",
+//          },
+//          Token{
+//              .type = .raw_text,
+//              .data = "file_path",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = ")",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "embed_+" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "+[file text](file_path)\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .embed,
+//              .data = "+",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "[",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "file text",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = "]",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "(",
+//          },
+//          Token{
+//              .type = .raw_text,
+//              .data = "file_path",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = ")",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "embed_=" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "=[file text](file_path)\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .embed,
+//              .data = "=",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "[",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "file text",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = "]",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "(",
+//          },
+//          Token{
+//              .type = .raw_text,
+//              .data = "file_path",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = ")",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "embed_link" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "/[file text](link to something)\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .link,
+//              .data = "/",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "[",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "file text",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = "]",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "(",
+//          },
+//          Token{
+//              .type = .raw_text,
+//              .data = "link to something",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = ")",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "table" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "| col | col | col |\n| --- | --- | --- |\n| row | row | row |\n| row | row | row |\n| row | row | row |\n| row | row | row |\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = " col ",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = " col ",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = " col ",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .table_row_sep,
+//              .data = " --- ",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .table_row_sep,
+//              .data = " --- ",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .table_row_sep,
+//              .data = " --- ",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = " row ",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = " row ",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = " row ",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = " row ",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = " row ",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = " row ",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = " row ",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = " row ",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = " row ",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = " row ",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = " row ",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = " row ",
+//          },
+//          Token{
+//              .type = .table_sep,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "quote_arrow" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "> quote\n> quote\n> quote\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .quote,
+//              .data = ">",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "quote",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .quote,
+//              .data = ">",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "quote",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .quote,
+//              .data = ">",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "quote",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "quote_bar" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "| quote\n| quote\n| quote\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .quote,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "quote",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .quote,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "quote",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .quote,
+//              .data = "|",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "quote",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "text_block" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "```\nsome text or code\n```\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .code_block,
+//              .data = "```",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .raw_text,
+//              .data = "some text or code",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .code_block,
+//              .data = "```",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "code_block" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "```lang_name\nsome text or code\n```\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .code_block,
+//              .data = "```",
+//          },
+//          Token{
+//              .type = .raw_text,
+//              .data = "lang_name",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .raw_text,
+//              .data = "some text or code",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .code_block,
+//              .data = "```",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "passthrough_block" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "```passthrough\nsome text or code\n```\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .code_block,
+//              .data = "```",
+//          },
+//          Token{
+//              .type = .raw_text,
+//              .data = "passthrough",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .raw_text,
+//              .data = "some text or code",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .code_block,
+//              .data = "```",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "comment" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "// this is a comment\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .comment,
+//              .data = "// ",
+//          },
+//          Token{
+//              .type = .raw_text,
+//              .data = "this is a comment",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "tick_box_empty" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "- [ ] something to check off\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .tickbox,
+//              .data = "- [ ]",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "something to check off",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "tick_box_checked" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "- [x] something checked off\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .tickbox,
+//              .data = "- [x]",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "something checked off",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "tick_box_ticked" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "- [/] something ticked off\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .tickbox,
+//              .data = "- [/]",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "something ticked off",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "tick_box_dashed" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "- [~] something dashed off\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .tickbox,
+//              .data = "- [~]",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "something dashed off",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "horizontal_rule_straight_line" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "---\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .rule,
+//              .data = "---",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "horizontal_rule_double_straight_line" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "===\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .rule,
+//              .data = "===",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "horizontal_rule_big_dotted_straight_line" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "***\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .rule,
+//              .data = "***",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "horizontal_rule_small_dotted_line" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "...\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .rule,
+//              .data = "...",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "horizontal_rule_squiggly_line" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "&&&\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .rule,
+//              .data = "&&&",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "horizontal_rule_jagged_line" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "^^^\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .rule,
+//              .data = "^^^",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "footnote" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "sometext [^1]\n\n[^1]: footnote\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .text,
+//              .data = "sometext ",
+//          },
+//          Token{
+//              .type = .footnote,
+//              .data = "[^1]",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//          Token{
+//              .type = .footnote_def,
+//              .data = "[^1]:",
+//          },
+//          Token{
+//              .type = .text,
+//              .data = "footnote",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }
+
+
+// test "inbulit" {
+//     std.testing.refAllDecls(@This());
+// 
+//     var doc = try Document.initDefault(std.testing.allocator);
+//     
+//     const input = "@.macro(arg, arg2)\n";
+//     const parsed = [_]Token{
+//          Token{
+//              .type = .inbulit,
+//              .data = "macro",
+//          },
+//          Token{
+//              .type = .bracket_open,
+//              .data = "(",
+//          },
+//          Token{
+//              .type = .macro_arg,
+//              .data = "arg",
+//          },
+//          Token{
+//              .type = .arg_sep,
+//              .data = ",",
+//          },
+//          Token{
+//              .type = .macro_arg,
+//              .data = "arg2",
+//          },
+//          Token{
+//              .type = .bracket_close,
+//              .data = ")",
+//          },
+//          Token{
+//              .type = .newline,
+//              .data = "\n",
+//          },
+//     };
+// 
+// 
+//     try doc.parse(std.testing.allocator, input);
+// 
+//     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
+// 
+//     for (parsed, doc.tokens.items[0..parsed.len]) |expected_token, actual_token| {
+//         if (print_output) {
+//             std.debug.print("expected_token : {f} | actual_token : {f}\n", .{ expected_token, actual_token });
+//         } else {
+//             try expect(expected_token.type == actual_token.type);
+//             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
+//         }
+//     }
+// 
+//     doc.deinit(std.testing.allocator);
+// }