diff --git a/src/attempt_2.zig b/src/attempt_2.zig
index 221f3e6..4fa40e7 100644
--- a/src/attempt_2.zig
+++ b/src/attempt_2.zig
@@ -26,12 +26,22 @@ const DocumentStyle = struct {
 
     heading_char: u8 = '#',
     heading_levels: usize = 6,
-    unordered_chars: []const u8 = "-++*",
+    unordered_chars: []const u8 = "-=+*",
+    check_box_chars: []const u8 = " x/~",
+    horizontal_rule_chars: []const u8 = "-=*.&^",
+    comment_id: []const u8 = "//",
+    escape_char: u8 = '\\',
+    code_block_id: []const u8 = "```",
 
     pub const default = Self{
         .heading_char = '#',
         .heading_levels = 6,
-        .unordered_chars = "-++*",
+        .unordered_chars = "-=+*",
+        .check_box_chars = " x/~",
+        .horizontal_rule_chars = "-=*.&^",
+        .comment_id = "// ",
+        .escape_char = '\\',
+        .code_block_id = "```",
     };
 };
 
@@ -55,7 +65,7 @@ pub const Document = struct {
     const StartLineParserFn = *const fn (self: *Self, alloc: std.mem.Allocator, line: *[]const u8) anyerror!FoundToken;
     const InlineParserFn = *const fn (self: *Self, alloc: std.mem.Allocator, line: *[]const u8) anyerror!FoundToken;
     const EndLineParserFn = *const fn (self: *Self, alloc: std.mem.Allocator, line: *[]const u8) anyerror!FoundToken;
-    const MultiLineParserFn = *const fn (self: *Self, alloc: std.mem.Allocator, line_itter: *std.mem.SplitIterator(u8)) anyerror!void;
+    const MultiLineParserFn = *const fn (self: *Self, alloc: std.mem.Allocator, line_itter: *std.mem.SplitIterator(u8, .sequence)) anyerror!FoundToken;
 
     tokens: std.ArrayList(Token) = .empty,
     tab_width: usize = 4,
@@ -64,27 +74,31 @@ pub const Document = struct {
     document_style: DocumentStyle = .default,
 
     // each function will
-    start_line_parsers: std.ArrayList(StartLineParserFn) = .empty,
-    inline_parsers: std.ArrayList(InlineParserFn) = .empty,
-    end_line_parsers: std.ArrayList(EndLineParserFn) = .empty,
+    start_line_parsers: []const StartLineParserFn = &[_]StartLineParserFn{
+        &headingParser,
+        &tickBoxParser,
+        &listOrderedParser,
+        &listUnorderedParser,
+        &horizontalRuleParser,
+    },
+    inline_parsers: []const InlineParserFn = &[_]InlineParserFn{
+        &baseLineParser,
+    },
 
-    pub fn initDefault(alloc: std.mem.Allocator) !Self {
-        var doc = Self{
+    end_line_parsers: []const EndLineParserFn = &[_]EndLineParserFn{
+        &commentParser,
+    },
+
+    multi_line_parsers: []const MultiLineParserFn = &[_]MultiLineParserFn{
+        &codeBlockParser,
+    },
+
+    pub fn initDefault() Self {
+        return Self{
             .tab_width = 4,
             .newline_char = .newline,
             .document_style = .default,
         };
-
-        try doc.appendStartLineParsers(alloc, &[_]StartLineParserFn{
-            &headingParser,
-            &listOrderedParser,
-        });
-
-        try doc.appendInlineParsers(alloc, &[_]InlineParserFn{
-            &baseLineParser,
-        });
-
-        return doc;
     }
 
     pub fn appendStartLineParsers(self: *Self, alloc: std.mem.Allocator, parser_fns: []const StartLineParserFn) !void {
@@ -99,9 +113,9 @@ pub const Document = struct {
 
     pub fn deinit(self: *Self, alloc: std.mem.Allocator) void {
         self.tokens.deinit(alloc);
-        self.start_line_parsers.deinit(alloc);
-        self.end_line_parsers.deinit(alloc);
-        self.inline_parsers.deinit(alloc);
+        // self.start_line_parsers.deinit(alloc);
+        // self.end_line_parsers.deinit(alloc);
+        // self.inline_parsers.deinit(alloc);
     }
 
     fn consumeChars(line: *[]const u8, amount_of_chars_to_consume: usize) error{too_many_chars_to_consume}!void {
@@ -109,6 +123,11 @@ pub const Document = struct {
         line.* = line.*[amount_of_chars_to_consume..];
     }
 
+    fn consumeCharsFromEnd(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.*[0 .. line.len - 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.*),
@@ -122,7 +141,7 @@ pub const Document = struct {
     fn inlineParser(self: *Self, alloc: std.mem.Allocator, line: *[]const u8) !void {
         if (line.len == 0) return;
 
-        for (self.inline_parsers.items) |parser| {
+        for (self.inline_parsers) |parser| {
             _ = try parser(self, alloc, line);
         }
     }
@@ -138,11 +157,30 @@ pub const Document = struct {
     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);
 
-        while (line_iter.next()) |line| {
+        line_iterator: while (line_iter.next()) |line| {
             var current_line = line;
+            std.debug.print("acutal current line : {s}\n", .{line});
+            var end_token: ?Token = null;
 
-            for (self.start_line_parsers.items) |parser| {
-                std.debug.print("line : \"{s}\"\n", .{line});
+            for (self.multi_line_parsers) |parser| {
+                // std.debug.print("line : \"{s}\"\n", .{line});
+                const token_found = try parser(self, alloc, &line_iter);
+
+                if (token_found) continue :line_iterator;
+            }
+
+            for (self.end_line_parsers) |parser| {
+                // std.debug.print("line : \"{s}\"\n", .{line});
+                const token_found = try parser(self, alloc, &current_line);
+
+                if (token_found) {
+                    end_token = self.tokens.pop();
+                    break;
+                }
+            }
+
+            for (self.start_line_parsers) |parser| {
+                // std.debug.print("line : \"{s}\"\n", .{line});
                 const token_found = try parser(self, alloc, &current_line);
 
                 if (token_found) break;
@@ -150,6 +188,9 @@ pub const Document = struct {
 
             try self.inlineParser(alloc, &current_line);
 
+            if (end_token) |t| {
+                try self.tokens.append(alloc, t);
+            }
             try self.appendNewLineToken(alloc);
         }
     }
@@ -184,6 +225,7 @@ pub const Document = struct {
         return true;
     }
 
+    // [TODO] make this generic
     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);
@@ -235,31 +277,191 @@ pub const Document = struct {
             });
 
             try consumeChars(line, whitespace_chars_removed + number.len + 2);
+            return true;
         }
 
         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);
+        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 null;
+        if (clean_line.len < 2) return false;
 
         // check there is a space seperating the char and the text
-        if (clean_line[1] != ' ') return null;
+        if (clean_line[1] != ' ') return false;
 
-        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,
-                },
-            };
+        if (std.mem.containsAtLeastScalar(u8, self.document_style.unordered_chars, 1, clean_line[0])) {
+            try self.tokens.append(alloc, Token{
+                .data = clean_line[0..1],
+                .padding = whitespace_chars_removed,
+                .type = .unordered_list,
+            });
+
+            try consumeChars(line, whitespace_chars_removed + 2);
+
+            return true;
         }
 
-        return null;
+        return false;
+    }
+
+    pub fn tickBoxParser(self: *Self, alloc: std.mem.Allocator, line: *[]const u8) !FoundToken {
+        const clean_line = stripWhiteSpace(line.*);
+        const whitespace_chars_removed = countWhiteSpace(line.*, self.tab_width);
+
+        if (!std.mem.startsWith(u8, clean_line, "- [")) {
+            return false;
+        }
+        // not long enough for a tick box
+        if (clean_line.len < 6) return false;
+
+        // - [
+
+        if (std.mem.containsAtLeastScalar(u8, self.document_style.check_box_chars, 1, clean_line[3]) and
+            clean_line[4] == ']' and clean_line[5] == ' ')
+        {
+            try self.tokens.append(alloc, Token{
+                .data = clean_line[0..5],
+                .padding = whitespace_chars_removed,
+                .type = .tickbox,
+            });
+            try consumeChars(line, 5);
+        }
+        return false;
+    }
+
+    fn parseRuleLength(rule_char: u8, line: []const u8) usize {
+        for (line, 0..) |char, i| {
+            if (char == rule_char or char == ' ' or char == '\t')
+                continue
+            else
+                return i;
+        }
+        return line.len;
+    }
+
+    pub fn horizontalRuleParser(self: *Self, alloc: std.mem.Allocator, line: *[]const u8) !FoundToken {
+        const clean_line = stripWhiteSpace(line.*);
+        const whitespace_chars_removed = countWhiteSpace(line.*, self.tab_width);
+
+        for (self.document_style.horizontal_rule_chars) |char| {
+            const rule_length = parseRuleLength(char, clean_line);
+
+            if (rule_length != 0) {
+                try self.tokens.append(alloc, Token{
+                    .data = clean_line[0..rule_length],
+                    .padding = whitespace_chars_removed,
+                    .type = .rule,
+                });
+                try consumeChars(line, rule_length + whitespace_chars_removed);
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    pub fn commentParser(self: *Self, alloc: std.mem.Allocator, line: *[]const u8) !FoundToken {
+
+        // find the index of the comment
+        const index_of_commnet = blk: {
+            if (std.mem.indexOf(u8, line.*, self.document_style.comment_id)) |index| {
+                if (index == 0)
+                    break :blk index;
+
+                if (line.*[index - 1] != self.document_style.escape_char) {
+                    return false;
+                }
+
+                break :blk index;
+            }
+            return false;
+        };
+
+        try self.tokens.append(alloc, Token{
+            .data = line.*[index_of_commnet .. index_of_commnet + self.document_style.comment_id.len],
+            .padding = 0,
+            .type = .comment,
+        });
+
+        try self.tokens.append(alloc, Token{
+            .data = line.*[index_of_commnet + self.document_style.comment_id.len .. line.len],
+            .padding = 0,
+            .type = .raw_text,
+        });
+
+        line.* = line.*[0..index_of_commnet];
+
+        return true;
+    }
+
+    pub fn codeBlockParser(self: *Self, alloc: std.mem.Allocator, line_itter: *std.mem.SplitIterator(u8, .sequence)) !FoundToken {
+        const current_line = line_itter.peek() orelse return false;
+        const clean_line = stripWhiteSpace(current_line);
+        const whitespace_chars_removed = countWhiteSpace(current_line, self.tab_width);
+        std.debug.print("current_line : {s}\n", .{current_line});
+
+        if (!std.mem.startsWith(u8, clean_line, self.document_style.code_block_id)) {
+            // std.debug.print("line didnt start with ```\n", .{});
+            return false;
+        }
+
+        try self.tokens.append(alloc, Token{
+            .data = clean_line[0..self.document_style.code_block_id.len],
+            .padding = whitespace_chars_removed,
+            .type = .code_block,
+        });
+
+        std.debug.print("clean_line[0..self.document_style.code_block_id.len] : {s}\n", .{clean_line[0..self.document_style.code_block_id.len]});
+
+        const lang_name = current_line[self.document_style.code_block_id.len..]; // may have white space
+        std.debug.print("lang_name : {s}\n", .{current_line});
+
+        // std.debug.print("lang_name = {}\n", .{lang_name.len});
+        if (lang_name.len != 0) {
+            try self.tokens.append(alloc, Token{
+                .data = lang_name,
+                .padding = 0,
+                .type = .raw_text,
+            });
+        }
+
+        try self.appendNewLineToken(alloc);
+
+        // std.debug.print("first values\n", .{});
+        // +1 to remove the newline
+        const raw_text_start_index =
+            @intFromPtr(current_line.ptr) - @intFromPtr(line_itter.buffer.ptr) + lang_name.len + self.document_style.code_block_id.len + 1;
+        std.debug.print("{} - {} + {} + {} + 1;", .{ @intFromPtr(current_line.ptr), @intFromPtr(line_itter.buffer.ptr), lang_name.len, self.document_style.code_block_id.len });
+
+        const ending_line = find_end: {
+            while (line_itter.next()) |line| {
+                if (std.mem.startsWith(u8, stripWhiteSpace(line), self.document_style.code_block_id))
+                    break :find_end line;
+            } else {
+                return error.no_closing_tag;
+            }
+        };
+
+        const raw_text_end_index = @intFromPtr(ending_line.ptr) - @intFromPtr(line_itter.buffer.ptr) - 1;
+        std.debug.print("line_itter.buffer[{}..{}] : {s}\n", .{ raw_text_start_index, raw_text_end_index, line_itter.buffer });
+
+        try self.tokens.append(alloc, Token{
+            .data = line_itter.buffer[raw_text_start_index..raw_text_end_index],
+            .padding = 0,
+            .type = .raw_text,
+        });
+
+        try self.tokens.append(alloc, Token{
+            .data = ending_line[0..self.document_style.code_block_id.len],
+            .padding = countWhiteSpace(ending_line, 4),
+            .type = .code_block,
+        });
+
+        try self.appendNewLineToken(alloc);
+
+        return true;
     }
 };
diff --git a/src/tests.zig b/src/tests.zig
index c78c163..1a475f3 100644
--- a/src/tests.zig
+++ b/src/tests.zig
@@ -5,298 +5,302 @@ const expect = std.testing.expect;
 
 const print_output: bool = false;
 
-test "heading_1" {
-    std.testing.refAllDecls(@This());
+// ==================================================================================================================
 
-    var doc = try Document.initDefault(std.testing.allocator);
+// test "heading_1" {
+//     std.testing.refAllDecls(@This());
 
-    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",
-        },
-    };
+//     var doc = Document.initDefault();
 
-    try doc.parse(std.testing.allocator, input);
+//     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",
+//         },
+//     };
 
-    if (!print_output) 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| {
-        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));
-        }
-    }
+//     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 "heading_2" {
-    std.testing.refAllDecls(@This());
+//     doc.deinit(std.testing.allocator);
+// }
 
-    var doc = try Document.initDefault(std.testing.allocator);
+// test "heading_2" {
+//     std.testing.refAllDecls(@This());
 
-    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",
-        },
-    };
+//     var doc = Document.initDefault();
 
-    try doc.parse(std.testing.allocator, input);
+//     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",
+//         },
+//     };
 
-    if (!print_output) 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| {
-        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));
-        }
-    }
+//     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 "heading_3" {
-    std.testing.refAllDecls(@This());
+//     doc.deinit(std.testing.allocator);
+// }
 
-    var doc = try Document.initDefault(std.testing.allocator);
+// test "heading_3" {
+//     std.testing.refAllDecls(@This());
 
-    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",
-        },
-    };
+//     var doc = Document.initDefault();
 
-    try doc.parse(std.testing.allocator, input);
+//     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",
+//         },
+//     };
 
-    if (!print_output) 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| {
-        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));
-        }
-    }
+//     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 "heading_4" {
-    std.testing.refAllDecls(@This());
+//     doc.deinit(std.testing.allocator);
+// }
 
-    var doc = try Document.initDefault(std.testing.allocator);
+// test "heading_4" {
+//     std.testing.refAllDecls(@This());
 
-    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",
-        },
-    };
+//     var doc = Document.initDefault();
 
-    try doc.parse(std.testing.allocator, input);
+//     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",
+//         },
+//     };
 
-    if (!print_output) 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| {
-        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));
-        }
-    }
+//     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 "heading_5" {
-    std.testing.refAllDecls(@This());
+//     doc.deinit(std.testing.allocator);
+// }
 
-    var doc = try Document.initDefault(std.testing.allocator);
+// test "heading_5" {
+//     std.testing.refAllDecls(@This());
 
-    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",
-        },
-    };
+//     var doc = Document.initDefault();
 
-    try doc.parse(std.testing.allocator, input);
+//     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",
+//         },
+//     };
 
-    if (!print_output) 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| {
-        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));
-        }
-    }
+//     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 "heading_6" {
-    std.testing.refAllDecls(@This());
+//     doc.deinit(std.testing.allocator);
+// }
 
-    var doc = try Document.initDefault(std.testing.allocator);
+// test "heading_6" {
+//     std.testing.refAllDecls(@This());
 
-    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",
-        },
-    };
+//     var doc = Document.initDefault();
 
-    try doc.parse(std.testing.allocator, input);
+//     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",
+//         },
+//     };
 
-    if (!print_output) 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| {
-        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));
-        }
-    }
+//     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 "header_no_text" {
-    std.testing.refAllDecls(@This());
+//     doc.deinit(std.testing.allocator);
+// }
 
-    var doc = try Document.initDefault(std.testing.allocator);
+// test "header_no_text" {
+//     std.testing.refAllDecls(@This());
 
-    const input = "######\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .heading,
-            .data = "######",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
+//     var doc = Document.initDefault();
 
-    try doc.parse(std.testing.allocator, input);
+//     const input = "######\n";
+//     const parsed = [_]Token{
+//         Token{
+//             .type = .heading,
+//             .data = "######",
+//         },
+//         Token{
+//             .type = .newline,
+//             .data = "\n",
+//         },
+//     };
 
-    if (!print_output) 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| {
-        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));
-        }
-    }
+//     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 "text" {
-    std.testing.refAllDecls(@This());
+//     doc.deinit(std.testing.allocator);
+// }
 
-    var doc = try Document.initDefault(std.testing.allocator);
+// test "text" {
+//     std.testing.refAllDecls(@This());
 
-    const input = "plain test\n";
-    const parsed = [_]Token{
-        Token{
-            .type = .text,
-            .data = "plain test",
-        },
-        Token{
-            .type = .newline,
-            .data = "\n",
-        },
-    };
+//     var doc = Document.initDefault();
 
-    try doc.parse(std.testing.allocator, input);
+//     const input = "plain test\n";
+//     const parsed = [_]Token{
+//         Token{
+//             .type = .text,
+//             .data = "plain test",
+//         },
+//         Token{
+//             .type = .newline,
+//             .data = "\n",
+//         },
+//     };
 
-    if (!print_output) 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| {
-        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));
-        }
-    }
+//     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 "text_style_code" {
 //     std.testing.refAllDecls(@This());
 //
-//     var doc = try Document.initDefault(std.testing.allocator);
+//     var doc = Document.initDefault();
 //
 //     const input = "`plain test`\n";
 //     const parsed = [_]Token{
@@ -338,7 +342,7 @@ test "text" {
 // test "text_style_bold" {
 //     std.testing.refAllDecls(@This());
 //
-//     var doc = try Document.initDefault(std.testing.allocator);
+//     var doc = Document.initDefault();
 //
 //     const input = "!plain test!\n";
 //     const parsed = [_]Token{
@@ -380,7 +384,7 @@ test "text" {
 // test "text_style_italic" {
 //     std.testing.refAllDecls(@This());
 //
-//     var doc = try Document.initDefault(std.testing.allocator);
+//     var doc = Document.initDefault();
 //
 //     const input = "*plain test*\n";
 //     const parsed = [_]Token{
@@ -422,7 +426,7 @@ test "text" {
 // test "text_style_underline" {
 //     std.testing.refAllDecls(@This());
 //
-//     var doc = try Document.initDefault(std.testing.allocator);
+//     var doc = Document.initDefault();
 //
 //     const input = "_plain test_\n";
 //     const parsed = [_]Token{
@@ -464,7 +468,7 @@ test "text" {
 // test "text_style_strikethrough" {
 //     std.testing.refAllDecls(@This());
 //
-//     var doc = try Document.initDefault(std.testing.allocator);
+//     var doc = Document.initDefault();
 //
 //     const input = "~plain test~\n";
 //     const parsed = [_]Token{
@@ -506,7 +510,7 @@ test "text" {
 // test "text_style_highlighted" {
 //     std.testing.refAllDecls(@This());
 //
-//     var doc = try Document.initDefault(std.testing.allocator);
+//     var doc = Document.initDefault();
 //
 //     const input = "|plain test|\n";
 //     const parsed = [_]Token{
@@ -548,7 +552,7 @@ test "text" {
 // test "text_style_&" {
 //     std.testing.refAllDecls(@This());
 //
-//     var doc = try Document.initDefault(std.testing.allocator);
+//     var doc = Document.initDefault();
 //
 //     const input = "&plain test&\n";
 //     const parsed = [_]Token{
@@ -590,7 +594,7 @@ test "text" {
 // test "text_style_%" {
 //     std.testing.refAllDecls(@This());
 //
-//     var doc = try Document.initDefault(std.testing.allocator);
+//     var doc = Document.initDefault();
 //
 //     const input = "%plain test%\n";
 //     const parsed = [_]Token{
@@ -632,7 +636,7 @@ test "text" {
 // test "text_style_$" {
 //     std.testing.refAllDecls(@This());
 //
-//     var doc = try Document.initDefault(std.testing.allocator);
+//     var doc = Document.initDefault();
 //
 //     const input = "$plain test$\n";
 //     const parsed = [_]Token{
@@ -674,7 +678,7 @@ test "text" {
 // test "text_style_#" {
 //     std.testing.refAllDecls(@This());
 //
-//     var doc = try Document.initDefault(std.testing.allocator);
+//     var doc = Document.initDefault();
 //
 //     const input = "#plain test#\n";
 //     const parsed = [_]Token{
@@ -716,7 +720,7 @@ test "text" {
 // test "text_style_-" {
 //     std.testing.refAllDecls(@This());
 //
-//     var doc = try Document.initDefault(std.testing.allocator);
+//     var doc = Document.initDefault();
 //
 //     const input = "-plain test-\n";
 //     const parsed = [_]Token{
@@ -758,7 +762,7 @@ test "text" {
 // test "text_style_+" {
 //     std.testing.refAllDecls(@This());
 //
-//     var doc = try Document.initDefault(std.testing.allocator);
+//     var doc = Document.initDefault();
 //
 //     const input = "+plain test+\n";
 //     const parsed = [_]Token{
@@ -800,7 +804,7 @@ test "text" {
 // test "text_style_=" {
 //     std.testing.refAllDecls(@This());
 //
-//     var doc = try Document.initDefault(std.testing.allocator);
+//     var doc = Document.initDefault();
 //
 //     const input = "=plain test=\n";
 //     const parsed = [_]Token{
@@ -842,7 +846,7 @@ test "text" {
 // test "text_style_espaced" {
 //     std.testing.refAllDecls(@This());
 //
-//     var doc = try Document.initDefault(std.testing.allocator);
+//     var doc = Document.initDefault();
 //
 //     const input = "\\`plain test`\n";
 //     const parsed = [_]Token{
@@ -876,7 +880,7 @@ test "text" {
 // test "text_style_with_style_char_in_string" {
 //     std.testing.refAllDecls(@This());
 //
-//     var doc = try Document.initDefault(std.testing.allocator);
+//     var doc = Document.initDefault();
 //
 //     const input = "+plain something + something else test+\n";
 //     const parsed = [_]Token{
@@ -918,7 +922,7 @@ test "text" {
 // test "text_style_with_space right after" {
 //     std.testing.refAllDecls(@This());
 //
-//     var doc = try Document.initDefault(std.testing.allocator);
+//     var doc = Document.initDefault();
 //
 //     const input = "+ plain something + something else test+\n";
 //     const parsed = [_]Token{
@@ -952,7 +956,7 @@ test "text" {
 // test "text_style_super_script" {
 //     std.testing.refAllDecls(@This());
 //
-//     var doc = try Document.initDefault(std.testing.allocator);
+//     var doc = Document.initDefault();
 //
 //     const input = "sometext^2\n";
 //     const parsed = [_]Token{
@@ -990,7 +994,7 @@ test "text" {
 // test "text_style_sub_script" {
 //     std.testing.refAllDecls(@This());
 //
-//     var doc = try Document.initDefault(std.testing.allocator);
+//     var doc = Document.initDefault();
 //
 //     const input = "sometext_2\n";
 //     const parsed = [_]Token{
@@ -1025,243 +1029,57 @@ test "text" {
 //     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));
-    //     }
-    // }
-
-    for (doc.tokens.items) |actual_token| {
-        std.debug.print("actual_token : {f}\n", .{actual_token});
-    }
-
-    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" {
+// test "list_ordered_number" {
 //     std.testing.refAllDecls(@This());
-//
-//     var doc = try Document.initDefault(std.testing.allocator);
-//
-//     const input = "- unordered list\n- unordered list\n- unordered list\n";
+
+//     var doc = Document.initDefault();
+
+//     const input = "1. ordered list\n2. ordered list\n3. ordered 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 = .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 });
@@ -1270,60 +1088,251 @@ test "list_ordered_letter" {
 //             try expect(std.mem.eql(u8, expected_token.data, actual_token.data));
 //         }
 //     }
-//
+
+//     // for (doc.tokens.items) |actual_token| {
+//     //     std.debug.print("actual_token : {f}\n", .{actual_token});
+//     // }
+
+//     doc.deinit(std.testing.allocator);
+// }
+
+// test "list_ordered_i" {
+//     std.testing.refAllDecls(@This());
+
+//     var doc = Document.initDefault();
+
+//     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 = Document.initDefault();
+
+//     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 = Document.initDefault();
+
+//     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);
-//
+
+//     var doc = Document.initDefault();
+
 //     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(std.testing.allocator, input);
-//
+
 //     if (!print_output) try expect(doc.tokens.items.len >= parsed.len);
-//
+
+//     // std.debug.print("doc.tokens.items.len = {}\n", .{doc.tokens.items.len});
+//     // for (doc.tokens.items) |actual_token| {
+//     //     std.debug.print("actual_token : {f}\n", .{actual_token});
+//     // }
+
 //     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 });
@@ -1332,60 +1341,59 @@ test "list_ordered_letter" {
 //             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);
-//
+
+//     var doc = Document.initDefault();
+
 //     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(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 });
@@ -1394,60 +1402,59 @@ test "list_ordered_letter" {
 //             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);
-//
+
+//     var doc = Document.initDefault();
+
 //     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(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 });
@@ -1456,14 +1463,16 @@ test "list_ordered_letter" {
 //             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);
+//     var doc = Document.initDefault();
 //
 //     const input = "![figure text](relitive path to image)\n";
 //     const parsed = [_]Token{
@@ -1521,7 +1530,7 @@ test "list_ordered_letter" {
 // test "embed_table" {
 //     std.testing.refAllDecls(@This());
 //
-//     var doc = try Document.initDefault(std.testing.allocator);
+//     var doc = Document.initDefault();
 //
 //     const input = "#[table text](relitive path to tabulated data)\n";
 //     const parsed = [_]Token{
@@ -1579,7 +1588,7 @@ test "list_ordered_letter" {
 // test "embed_file" {
 //     std.testing.refAllDecls(@This());
 //
-//     var doc = try Document.initDefault(std.testing.allocator);
+//     var doc = Document.initDefault();
 //
 //     const input = "$[file text](path to file#starting_line:ending_line)\n";
 //     const parsed = [_]Token{
@@ -1637,7 +1646,7 @@ test "list_ordered_letter" {
 // test "embed_*" {
 //     std.testing.refAllDecls(@This());
 //
-//     var doc = try Document.initDefault(std.testing.allocator);
+//     var doc = Document.initDefault();
 //
 //     const input = "*[file text](file_path)\n";
 //     const parsed = [_]Token{
@@ -1695,7 +1704,7 @@ test "list_ordered_letter" {
 // test "embed__" {
 //     std.testing.refAllDecls(@This());
 //
-//     var doc = try Document.initDefault(std.testing.allocator);
+//     var doc = Document.initDefault();
 //
 //     const input = "_[file text](file_path)\n";
 //     const parsed = [_]Token{
@@ -1753,7 +1762,7 @@ test "list_ordered_letter" {
 // test "embed_~" {
 //     std.testing.refAllDecls(@This());
 //
-//     var doc = try Document.initDefault(std.testing.allocator);
+//     var doc = Document.initDefault();
 //
 //     const input = "~[file text](file_path)\n";
 //     const parsed = [_]Token{
@@ -1811,7 +1820,7 @@ test "list_ordered_letter" {
 // test "embed_|" {
 //     std.testing.refAllDecls(@This());
 //
-//     var doc = try Document.initDefault(std.testing.allocator);
+//     var doc = Document.initDefault();
 //
 //     const input = "|[file text](file_path)\n";
 //     const parsed = [_]Token{
@@ -1869,7 +1878,7 @@ test "list_ordered_letter" {
 // test "embed_&" {
 //     std.testing.refAllDecls(@This());
 //
-//     var doc = try Document.initDefault(std.testing.allocator);
+//     var doc = Document.initDefault();
 //
 //     const input = "&[file text](file_path)\n";
 //     const parsed = [_]Token{
@@ -1927,7 +1936,7 @@ test "list_ordered_letter" {
 // test "embed_%" {
 //     std.testing.refAllDecls(@This());
 //
-//     var doc = try Document.initDefault(std.testing.allocator);
+//     var doc = Document.initDefault();
 //
 //     const input = "%[file text](file_path)\n";
 //     const parsed = [_]Token{
@@ -1985,7 +1994,7 @@ test "list_ordered_letter" {
 // test "embed_-" {
 //     std.testing.refAllDecls(@This());
 //
-//     var doc = try Document.initDefault(std.testing.allocator);
+//     var doc = Document.initDefault();
 //
 //     const input = "-[file text](file_path)\n";
 //     const parsed = [_]Token{
@@ -2043,7 +2052,7 @@ test "list_ordered_letter" {
 // test "embed_+" {
 //     std.testing.refAllDecls(@This());
 //
-//     var doc = try Document.initDefault(std.testing.allocator);
+//     var doc = Document.initDefault();
 //
 //     const input = "+[file text](file_path)\n";
 //     const parsed = [_]Token{
@@ -2101,7 +2110,7 @@ test "list_ordered_letter" {
 // test "embed_=" {
 //     std.testing.refAllDecls(@This());
 //
-//     var doc = try Document.initDefault(std.testing.allocator);
+//     var doc = Document.initDefault();
 //
 //     const input = "=[file text](file_path)\n";
 //     const parsed = [_]Token{
@@ -2159,7 +2168,7 @@ test "list_ordered_letter" {
 // test "embed_link" {
 //     std.testing.refAllDecls(@This());
 //
-//     var doc = try Document.initDefault(std.testing.allocator);
+//     var doc = Document.initDefault();
 //
 //     const input = "/[file text](link to something)\n";
 //     const parsed = [_]Token{
@@ -2217,7 +2226,7 @@ test "list_ordered_letter" {
 // test "table" {
 //     std.testing.refAllDecls(@This());
 //
-//     var doc = try Document.initDefault(std.testing.allocator);
+//     var doc = Document.initDefault();
 //
 //     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{
@@ -2435,7 +2444,7 @@ test "list_ordered_letter" {
 // test "quote_arrow" {
 //     std.testing.refAllDecls(@This());
 //
-//     var doc = try Document.initDefault(std.testing.allocator);
+//     var doc = Document.initDefault();
 //
 //     const input = "> quote\n> quote\n> quote\n";
 //     const parsed = [_]Token{
@@ -2497,7 +2506,7 @@ test "list_ordered_letter" {
 // test "quote_bar" {
 //     std.testing.refAllDecls(@This());
 //
-//     var doc = try Document.initDefault(std.testing.allocator);
+//     var doc = Document.initDefault();
 //
 //     const input = "| quote\n| quote\n| quote\n";
 //     const parsed = [_]Token{
@@ -2558,42 +2567,41 @@ test "list_ordered_letter" {
 
 // test "text_block" {
 //     std.testing.refAllDecls(@This());
-//
-//     var doc = try Document.initDefault(std.testing.allocator);
-//
+
+//     var doc = Document.initDefault();
+
 //     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(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 });
@@ -2602,68 +2610,67 @@ test "list_ordered_letter" {
 //             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 "code_block" {
+    std.testing.refAllDecls(@This());
+
+    var doc = Document.initDefault();
+
+    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);
+//     var doc = Document.initDefault();
 //
 //     const input = "```passthrough\nsome text or code\n```\n";
 //     const parsed = [_]Token{
@@ -2714,32 +2721,33 @@ test "list_ordered_letter" {
 //     doc.deinit(std.testing.allocator);
 // }
 
+// ==================================================================================================================
+
 // test "comment" {
 //     std.testing.refAllDecls(@This());
-//
-//     var doc = try Document.initDefault(std.testing.allocator);
-//
+
+//     var doc = Document.initDefault();
+
 //     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(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 });
@@ -2748,36 +2756,35 @@ test "list_ordered_letter" {
 //             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);
-//
+
+//     var doc = Document.initDefault();
+
 //     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(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 });
@@ -2786,36 +2793,35 @@ test "list_ordered_letter" {
 //             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);
-//
+
+//     var doc = Document.initDefault();
+
 //     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(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 });
@@ -2824,36 +2830,35 @@ test "list_ordered_letter" {
 //             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);
-//
+
+//     var doc = Document.initDefault();
+
 //     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(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 });
@@ -2862,36 +2867,35 @@ test "list_ordered_letter" {
 //             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);
-//
+
+//     var doc = Document.initDefault();
+
 //     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(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 });
@@ -2900,32 +2904,31 @@ test "list_ordered_letter" {
 //             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);
-//
+
+//     var doc = Document.initDefault();
+
 //     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(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 });
@@ -2934,32 +2937,31 @@ test "list_ordered_letter" {
 //             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);
-//
+
+//     var doc = Document.initDefault();
+
 //     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(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 });
@@ -2968,32 +2970,31 @@ test "list_ordered_letter" {
 //             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);
-//
+
+//     var doc = Document.initDefault();
+
 //     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(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 });
@@ -3002,32 +3003,31 @@ test "list_ordered_letter" {
 //             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);
-//
+
+//     var doc = Document.initDefault();
+
 //     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(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 });
@@ -3036,32 +3036,31 @@ test "list_ordered_letter" {
 //             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);
-//
+
+//     var doc = Document.initDefault();
+
 //     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(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 });
@@ -3070,32 +3069,31 @@ test "list_ordered_letter" {
 //             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);
-//
+
+//     var doc = Document.initDefault();
+
 //     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(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 });
@@ -3104,14 +3102,16 @@ test "list_ordered_letter" {
 //             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);
+//     var doc = Document.initDefault();
 //
 //     const input = "sometext [^1]\n\n[^1]: footnote\n";
 //     const parsed = [_]Token{
@@ -3165,7 +3165,7 @@ test "list_ordered_letter" {
 // test "inbulit" {
 //     std.testing.refAllDecls(@This());
 //
-//     var doc = try Document.initDefault(std.testing.allocator);
+//     var doc = Document.initDefault();
 //
 //     const input = "@.macro(arg, arg2)\n";
 //     const parsed = [_]Token{
diff --git a/tests/test_runner.zig b/tests/test_runner.zig
index e1276d4..25a9127 100644
--- a/tests/test_runner.zig
+++ b/tests/test_runner.zig
@@ -3,6 +3,11 @@ const Io = std.Io;
 
 const builtin = @import("builtin");
 
+pub const colour_set_string_fg_fmt = "\x1B[38;2;{d};{d};{d}m";
+pub const colour_set_string_bg_fmt = "\x1B[48;2;{d};{d};{d}m";
+pub const colour_set_string_fmt = colour_set_string_fg_fmt ++ colour_set_string_bg_fmt;
+pub const colour_end_string_fmt = "\x1B[0m";
+
 pub fn main(init: std.process.Init) !void {
     const io = init.io;
 
@@ -10,12 +15,16 @@ pub fn main(init: std.process.Init) !void {
     var stdout_file_writer: Io.File.Writer = .init(.stdout(), io, &stdout_buffer);
     const stdout = &stdout_file_writer.interface;
 
+    var passed: usize = 0;
     for (builtin.test_functions) |t| {
         t.func() catch |err| {
-            try stdout.print("{s} fail: {}\n", .{ t.name, err });
+            try stdout.print("[\x1B[38;2;255;0;0mfail\x1B[0m] {s} : {}\n", .{ t.name, err });
             continue;
         };
-        try stdout.print("{s} passed\n", .{t.name});
+        passed += 1;
+        try stdout.print("[\x1B[38;2;0;255;0mpassed\x1B[0m] {s} \n", .{t.name});
     }
+
+    try stdout.print("[{}/{}] test passed\n", .{ passed, builtin.test_functions.len });
     try stdout.flush(); // Don't forget to flush!
 }