apex-ruby 1.0.6

data/ext/apex_ext/apex_src/tests/test_extensions.c

@@ -0,0 +1,2116 @@
+/**
+ * Extensions Tests
+ */
+
+#include "test_helpers.h"
+#include "apex/apex.h"
+#include "../src/extensions/advanced_footnotes.h"
+#include <string.h>
+
+void test_math(void) {
+    int suite_failures = suite_start();
+    print_suite_title("Math Support Tests", false, true);
+
+    apex_options opts = apex_options_default();
+    opts.enable_math = true;
+    char *html;
+
+    /* Test inline math */
+    html = apex_markdown_to_html("Equation: $E=mc^2$", 18, &opts);
+    assert_contains(html, "class=\"math inline\"", "Inline math class");
+    assert_contains(html, "E=mc^2", "Math content preserved");
+    apex_free_string(html);
+
+    /* Test display math */
+    html = apex_markdown_to_html("$$x^2 + y^2 = z^2$$", 19, &opts);
+    assert_contains(html, "class=\"math display\"", "Display math class");
+    apex_free_string(html);
+
+    /* Test that regular dollars don't trigger */
+    html = apex_markdown_to_html("I have $5 and $10", 17, &opts);
+    if (strstr(html, "class=\"math") == NULL) {
+        test_result(true, "Dollar signs don't false trigger");
+    } else {
+        test_result(false, "Dollar signs false triggered");
+    }
+    apex_free_string(html);
+
+    /* Test that math/autolinks are not applied inside Liquid {% %} tags */
+    const char *liquid_md = "Before {% kbd $@3 %} after";
+    html = apex_markdown_to_html(liquid_md, strlen(liquid_md), &opts);
+    assert_contains(html, "{% kbd $@3 %}", "Liquid tag content preserved exactly");
+    assert_not_contains(html, "class=\"math", "No math span created inside Liquid tag");
+    assert_not_contains(html, "mailto:", "No email autolink created inside Liquid tag");
+    apex_free_string(html);
+
+    bool had_failures = suite_end(suite_failures);
+    print_suite_title("Math Support Tests", had_failures, false);
+}
+
+/**
+ * Test Critic Markup
+ */
+
+void test_critic_markup(void) {
+    int suite_failures = suite_start();
+    print_suite_title("Critic Markup Tests", false, true);
+
+    apex_options opts = apex_options_default();
+    opts.enable_critic_markup = true;
+    opts.critic_mode = 2;  /* CRITIC_MARKUP */
+    char *html;
+
+    /* Test addition - markup mode */
+    html = apex_markdown_to_html("Text {++added++} here", 21, &opts);
+    assert_contains(html, "<ins class=\"critic\">added</ins>", "Critic addition markup");
+    apex_free_string(html);
+
+    /* Test deletion - markup mode */
+    html = apex_markdown_to_html("Text {--deleted--} here", 23, &opts);
+    assert_contains(html, "<del class=\"critic\">deleted</del>", "Critic deletion markup");
+    apex_free_string(html);
+
+    /* Test highlight - markup mode */
+    html = apex_markdown_to_html("Text {==highlighted==} here", 27, &opts);
+    assert_contains(html, "<mark class=\"critic\">highlighted</mark>", "Critic highlight markup");
+    apex_free_string(html);
+
+    /* Test accept mode - apply all changes */
+    opts.critic_mode = 0;  /* CRITIC_ACCEPT */
+    html = apex_markdown_to_html("Text {++added++} and {--deleted--} more {~~old~>new~~} done.", 61, &opts);
+    assert_contains(html, "added", "Accept mode includes additions");
+    assert_contains(html, "new", "Accept mode includes new text from substitution");
+    /* Should NOT contain markup tags or deleted text */
+    if (strstr(html, "<ins") == NULL && strstr(html, "<del") == NULL && strstr(html, "deleted") == NULL && strstr(html, "old") == NULL) {
+        test_result(true, "Accept mode removes markup and deletions");
+    } else {
+        test_result(false, "Accept mode has markup or deleted text");
+    }
+    apex_free_string(html);
+
+    /* Test reject mode - revert all changes */
+    opts.critic_mode = 1;  /* CRITIC_REJECT */
+    html = apex_markdown_to_html("Text {++added++} and {--deleted--} more {~~old~>new~~} done.", 61, &opts);
+    assert_contains(html, "deleted", "Reject mode includes deletions");
+    assert_contains(html, "old", "Reject mode includes old text from substitution");
+    /* Should NOT contain markup tags or additions */
+    if (strstr(html, "<ins") == NULL && strstr(html, "<del") == NULL && strstr(html, "added") == NULL && strstr(html, "new") == NULL) {
+        tests_passed++;
+        tests_run++;
+        if (!errors_only_output) {
+            printf(COLOR_GREEN "✓" COLOR_RESET " Reject mode removes markup and additions\n");
+        }
+    } else {
+        tests_failed++;
+        tests_run++;
+        printf(COLOR_RED "✗" COLOR_RESET " Reject mode has markup or added text\n");
+    }
+    apex_free_string(html);
+
+    /* Test accept mode with comments and highlights */
+    opts.critic_mode = 0;  /* CRITIC_ACCEPT */
+    html = apex_markdown_to_html("Text {==highlight==} and {>>comment<<} here.", 44, &opts);
+    assert_contains(html, "highlight", "Accept mode keeps highlights");
+    /* Comments should be removed */
+    if (strstr(html, "comment") == NULL) {
+        test_result(true, "Accept mode removes comments");
+    } else {
+        test_result(false, "Accept mode kept comment");
+    }
+    apex_free_string(html);
+
+    /* Test reject mode with comments and highlights */
+    opts.critic_mode = 1;  /* CRITIC_REJECT */
+    html = apex_markdown_to_html("Text {==highlight==} and {>>comment<<} here.", 44, &opts);
+    /* Highlights should show text, comments should be removed, no markup tags */
+    assert_contains(html, "highlight", "Reject mode shows highlight text");
+    if (strstr(html, "comment") == NULL && strstr(html, "<mark") == NULL && strstr(html, "<span") == NULL) {
+        test_result(true, "Reject mode removes comments and markup tags");
+    } else {
+        test_result(false, "Reject mode has comments or markup tags");
+    }
+    apex_free_string(html);
+
+    bool had_failures = suite_end(suite_failures);
+    print_suite_title("Critic Markup Tests", had_failures, false);
+}
+
+/**
+ * Test processor modes
+ */
+
+void test_processor_modes(void) {
+    int suite_failures = suite_start();
+    print_suite_title("Processor Modes Tests", false, true);
+
+    const char *markdown = "# Test\n\n**bold**";
+    char *html;
+
+    /* Test CommonMark mode */
+    apex_options cm_opts = apex_options_for_mode(APEX_MODE_COMMONMARK);
+    html = apex_markdown_to_html(markdown, strlen(markdown), &cm_opts);
+    assert_contains(html, "<h1", "CommonMark mode works");
+    apex_free_string(html);
+
+    /* Test GFM mode */
+    apex_options gfm_opts = apex_options_for_mode(APEX_MODE_GFM);
+    html = apex_markdown_to_html(markdown, strlen(markdown), &gfm_opts);
+    assert_contains(html, "<strong>bold</strong>", "GFM mode works");
+    apex_free_string(html);
+
+    /* Test MultiMarkdown mode */
+    apex_options mmd_opts = apex_options_for_mode(APEX_MODE_MULTIMARKDOWN);
+    html = apex_markdown_to_html(markdown, strlen(markdown), &mmd_opts);
+    assert_contains(html, "<h1", "MultiMarkdown mode works");
+    apex_free_string(html);
+
+    /* Test Unified mode */
+    apex_options unified_opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+    html = apex_markdown_to_html(markdown, strlen(markdown), &unified_opts);
+    assert_contains(html, "<h1", "Unified mode works");
+    apex_free_string(html);
+
+    bool had_failures = suite_end(suite_failures);
+    print_suite_title("Processor Modes Tests", had_failures, false);
+}
+
+/**
+ * Test MultiMarkdown-style image attributes (inline and reference)
+ */
+
+void test_multimarkdown_image_attributes(void) {
+    int suite_failures = suite_start();
+    print_suite_title("MultiMarkdown Image Attribute Tests", false, true);
+
+    apex_options mmd_opts = apex_options_for_mode(APEX_MODE_MULTIMARKDOWN);
+    apex_options unified_opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+
+    const char *md =
+        "![Inline no title](/images/test-inline-1.jpg width=200)\n\n"
+        "![Inline with title](/images/test-inline-2.jpg \"Falafel\" width=300)\n\n"
+        "![Inline percent](/images/test-inline-3.jpg width=50%)\n\n"
+        "![Inline classes](/images/test-inline-4.jpg \"Caption\" class=center shadow width=250 height=60%)\n\n"
+        "![Ref with attrs][ref-inline-1]\n\n"
+        "[ref-inline-1]: /images/test-ref-1.jpg width=200\n\n"
+        "![Ref with title][ref-inline-2]\n\n"
+        "[ref-inline-2]: /images/test-ref-2.jpg \"Falafel\" width=300\n\n"
+        "![Ref percent][ref-inline-3]\n\n"
+        "[ref-inline-3]: /images/test-ref-3.jpg width=50%\n\n"
+        "![Ref classes][ref-inline-4]\n\n"
+        "[ref-inline-4]: /images/test-ref-4.jpg \"Caption\" class=center shadow width=250 height=60%\n";
+
+    /* Helper lambda-style macro to run assertions in a given mode */
+#define RUN_IMAGE_ATTR_TESTS(OPTS, MODE_LABEL)                                                      \
+    do {                                                                                            \
+        char *html = apex_markdown_to_html(md, strlen(md), &(OPTS));                                \
+        assert_contains(html, "src=\"/images/test-inline-1.jpg\"", MODE_LABEL " inline url 1");     \
+        assert_contains(html, "width=\"200\"", MODE_LABEL " inline width=200");                     \
+        assert_contains(html, "src=\"/images/test-inline-2.jpg\"", MODE_LABEL " inline url 2");     \
+        assert_contains(html, "title=\"Falafel\"", MODE_LABEL " inline title");                     \
+        assert_contains(html, "width=\"300\"", MODE_LABEL " inline width=300");                     \
+        assert_contains(html, "src=\"/images/test-inline-3.jpg\"", MODE_LABEL " inline url 3");     \
+        assert_contains(html, "style=\"width: 50%\"", MODE_LABEL " inline width 50% style");        \
+        assert_contains(html, "src=\"/images/test-inline-4.jpg\"", MODE_LABEL " inline url 4");     \
+        /* Class list ordering is not guaranteed; just check for center */                          \
+        assert_contains(html, "class=\"center", MODE_LABEL " inline center class");                 \
+        assert_contains(html, "width=\"250\"", MODE_LABEL " inline width=250");                     \
+        assert_contains(html, "height: 60%", MODE_LABEL " inline height 60% style");                \
+        assert_contains(html, "src=\"/images/test-ref-1.jpg\"", MODE_LABEL " ref url 1");           \
+        assert_contains(html, "width=\"200\"", MODE_LABEL " ref width=200");                        \
+        assert_contains(html, "src=\"/images/test-ref-2.jpg\"", MODE_LABEL " ref url 2");           \
+        assert_contains(html, "title=\"Falafel\"", MODE_LABEL " ref title");                        \
+        assert_contains(html, "width=\"300\"", MODE_LABEL " ref width=300");                        \
+        assert_contains(html, "src=\"/images/test-ref-3.jpg\"", MODE_LABEL " ref url 3");           \
+        assert_contains(html, "style=\"width: 50%\"", MODE_LABEL " ref width 50% style");           \
+        assert_contains(html, "src=\"/images/test-ref-4.jpg\"", MODE_LABEL " ref url 4");           \
+        assert_contains(html, "class=\"center", MODE_LABEL " ref center class");                    \
+        assert_contains(html, "width=\"250\"", MODE_LABEL " ref width=250");                        \
+        assert_contains(html, "height: 60%", MODE_LABEL " ref height 60% style");                   \
+        apex_free_string(html);                                                                     \
+    } while (0)
+
+    RUN_IMAGE_ATTR_TESTS(mmd_opts, "MMD");
+    RUN_IMAGE_ATTR_TESTS(unified_opts, "Unified");
+
+#undef RUN_IMAGE_ATTR_TESTS
+
+    /* Test @2x srcset: ![alt](url @2x) and ![alt](url "title" @2x) emit srcset="url 1x, url@2x 2x" */
+    {
+        apex_options opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+        const char *at2x_inline = "![BlogBook](img/icon_512x512.png @2x)";
+        char *html = apex_markdown_to_html(at2x_inline, strlen(at2x_inline), &opts);
+        assert_contains(html, "src=\"img/icon_512x512.png\"", "@2x inline: src present");
+        assert_contains(html, "srcset=\"img/icon_512x512.png 1x, img/icon_512x512@2x.png 2x\"", "@2x inline: srcset 1x and 2x");
+        apex_free_string(html);
+
+        const char *at2x_title = "![BlogBook](img/icon_512x512.png \"title\" @2x)";
+        html = apex_markdown_to_html(at2x_title, strlen(at2x_title), &opts);
+        assert_contains(html, "srcset=\"img/icon_512x512.png 1x, img/icon_512x512@2x.png 2x\"", "@2x with title: srcset");
+        apex_free_string(html);
+
+        /* Reference-style: [ref]: url @2x */
+        const char *at2x_ref = "![Logo][logo]\n\n[logo]: img/hero.png @2x";
+        html = apex_markdown_to_html(at2x_ref, strlen(at2x_ref), &opts);
+        assert_contains(html, "srcset=\"img/hero.png 1x, img/hero@2x.png 2x\"", "@2x reference: srcset");
+        apex_free_string(html);
+    }
+
+    /* Reference-style image with attributes between two @2x images:
+     * - First image: inline with @2x, should get srcset
+     * - Middle image: reference-style with width/height/style, no @2x, should get attributes but no srcset
+     * - Last image: inline with @2x, should get srcset
+     * This guards against @2x or index bookkeeping causing the middle image to lose its attributes.
+     */
+    {
+        apex_options opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+        const char *three_img_md =
+            "![First](img/first.png @2x)\n\n"
+            "![Badge][badge]\n\n"
+            "[badge]: img/badge.png width=250 height=83 style=\"margin: 0 auto;\"\n\n"
+            "![Last](img/last.png @2x)\n";
+
+        char *html = apex_markdown_to_html(three_img_md, strlen(three_img_md), &opts);
+
+        /* First image: has srcset with @2x */
+        assert_contains(html,
+                        "src=\"img/first.png\"",
+                        "@2x three-image: first src present");
+        assert_contains(html,
+                        "srcset=\"img/first.png 1x, img/first@2x.png 2x\"",
+                        "@2x three-image: first srcset present");
+
+        /* Middle (badge) image: has width/height/style, but no srcset */
+        assert_contains(html,
+                        "src=\"img/badge.png\"",
+                        "@2x three-image: middle src present");
+        assert_contains(html,
+                        "width=\"250\"",
+                        "@2x three-image: middle width attribute");
+        assert_contains(html,
+                        "height=\"83\"",
+                        "@2x three-image: middle height attribute");
+        assert_contains(html,
+                        "style=\"margin: 0 auto;\"",
+                        "@2x three-image: middle style attribute");
+        assert_not_contains(html,
+                            "img/badge@2x.png",
+                            "@2x three-image: middle has no @2x srcset");
+
+        /* Last image: has srcset with @2x */
+        assert_contains(html,
+                        "src=\"img/last.png\"",
+                        "@2x three-image: last src present");
+        assert_contains(html,
+                        "srcset=\"img/last.png 1x, img/last@2x.png 2x\"",
+                        "@2x three-image: last srcset present");
+
+        apex_free_string(html);
+    }
+
+    /* @3x marker: behaves like @2x but emits both 2x and 3x entries in srcset */
+    {
+        apex_options opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+        const char *at3x_inline = "![BlogBook](img/icon_512x512.png @3x)";
+        char *html = apex_markdown_to_html(at3x_inline, strlen(at3x_inline), &opts);
+        assert_contains(html, "src=\"img/icon_512x512.png\"", "@3x inline: src present");
+        assert_contains(html,
+                        "srcset=\"img/icon_512x512.png 1x, img/icon_512x512@2x.png 2x, img/icon_512x512@3x.png 3x\"",
+                        "@3x inline: srcset 1x, 2x, 3x");
+        apex_free_string(html);
+
+        /* Reference-style: [ref]: url @3x */
+        const char *at3x_ref = "![Logo][logo3]\n\n[logo3]: img/hero3.png @3x";
+        html = apex_markdown_to_html(at3x_ref, strlen(at3x_ref), &opts);
+        assert_contains(html,
+                        "srcset=\"img/hero3.png 1x, img/hero3@2x.png 2x, img/hero3@3x.png 3x\"",
+                        "@3x reference: srcset 1x, 2x, 3x");
+        apex_free_string(html);
+    }
+
+    bool had_failures = suite_end(suite_failures);
+    print_suite_title("MultiMarkdown Image Attribute Tests", had_failures, false);
+}
+
+/**
+ * Test file includes
+ */
+
+void test_file_includes(void) {
+    int suite_failures = suite_start();
+    print_suite_title("File Includes Tests", false, true);
+
+    apex_options opts = apex_options_default();
+    opts.enable_file_includes = true;
+#ifdef TEST_FIXTURES_DIR
+    opts.base_directory = TEST_FIXTURES_DIR;
+#else
+    opts.base_directory = "tests/fixtures/includes";
+#endif
+    char *html;
+
+    /* Test Marked markdown include */
+    html = apex_markdown_to_html("Before\n\n<<[simple.md]\n\nAfter", 28, &opts);
+    assert_contains(html, "Included Content", "Marked markdown include");
+    assert_contains(html, "List item 1", "Markdown processed from include");
+    apex_free_string(html);
+
+    /* Test Marked code include */
+    html = apex_markdown_to_html("Code:\n\n<<(code.py)\n\nDone", 23, &opts);
+    assert_contains(html, "<pre", "Code include generates pre tag");
+    assert_contains(html, "def hello", "Code content included");
+    assert_contains(html, "lang=\"python\"", "Python language class added");
+    apex_free_string(html);
+
+    /* Test Marked raw HTML include - currently uses placeholder */
+    html = apex_markdown_to_html("HTML:\n\n<<{raw.html}\n\nDone", 24, &opts);
+    assert_contains(html, "APEX_RAW_INCLUDE", "Raw HTML include marker present");
+    apex_free_string(html);
+
+    /* Test MMD transclusion */
+    html = apex_markdown_to_html("Include: {{simple.md}}", 22, &opts);
+    assert_contains(html, "Included Content", "MMD transclusion works");
+    apex_free_string(html);
+
+    /* Test MMD wildcard transclusion: file.* (legacy behavior) */
+    html = apex_markdown_to_html("Include: {{simple.*}}", 22, &opts);
+    assert_contains(html, "Included Content", "MMD wildcard file.* resolves to simple.md");
+    apex_free_string(html);
+
+    /* Test CSV to table conversion */
+    html = apex_markdown_to_html("Data:\n\n<<[data.csv]\n\nEnd", 24, &opts);
+    assert_contains(html, "<table>", "CSV converts to table");
+    assert_contains(html, "Alice", "CSV data in table");
+    assert_contains(html, "New York", "CSV cell content");
+    apex_free_string(html);
+
+    /* Test TSV to table conversion */
+    html = apex_markdown_to_html("{{data.tsv}}", 12, &opts);
+    assert_contains(html, "<table>", "TSV converts to table");
+    assert_contains(html, "Widget", "TSV data in table");
+    apex_free_string(html);
+
+    /* Test iA Writer image include */
+    html = apex_markdown_to_html("/image.png", 10, &opts);
+    assert_contains(html, "<img", "iA Writer image include");
+    assert_contains(html, "image.png", "Image path included");
+    apex_free_string(html);
+
+    /* Test iA Writer code include */
+    html = apex_markdown_to_html("/code.py", 8, &opts);
+    assert_contains(html, "<pre", "iA Writer code include");
+    assert_contains(html, "def hello", "Code included");
+    apex_free_string(html);
+
+    /* Test glob wildcard: *.md (should resolve to one of the .md fixtures) */
+    html = apex_markdown_to_html("{{*.md}}", 10, &opts);
+    if (strstr(html, "Included Content") != NULL ||
+        strstr(html, "Nested Content") != NULL) {
+        tests_passed++;
+        tests_run++;
+        if (!errors_only_output) {
+            printf(COLOR_GREEN "✓" COLOR_RESET " Glob wildcard *.md resolves to a Markdown file\n");
+        }
+    } else {
+        tests_failed++;
+        tests_run++;
+        test_result(false, "Glob wildcard *.md did not resolve correctly");
+    }
+    apex_free_string(html);
+
+    /* Test MMD address syntax - line range */
+    html = apex_markdown_to_html("{{simple.md}}[3,5]", 20, &opts);
+    assert_contains(html, "This is a simple", "Line range includes line 3");
+    assert_contains(html, "markdown file", "Line range includes line 4");
+    assert_not_contains(html, "Included Content", "Line range excludes line 1");
+    assert_not_contains(html, "List item 1", "Line range excludes line 5 and beyond");
+    apex_free_string(html);
+
+    /* Test MMD address syntax - from line to end */
+    html = apex_markdown_to_html("{{simple.md}}[5,]", 19, &opts);
+    assert_contains(html, "List item 1", "From line includes line 5");
+    assert_contains(html, "List item 2", "From line includes later lines");
+    assert_not_contains(html, "Included Content", "From line excludes earlier lines");
+    apex_free_string(html);
+
+    /* Test MMD address syntax - prefix */
+    html = apex_markdown_to_html("{{code.py}}[1,3;prefix=\"C: \"]", 30, &opts);
+    assert_contains(html, "C: def hello()", "Prefix applied to included lines");
+    assert_contains(html, "C:     print", "Prefix applied to all lines");
+    apex_free_string(html);
+
+    /* Test glob wildcard with single-character ?: c?de.py should resolve to code.py */
+    html = apex_markdown_to_html("{{c?de.py}}", 12, &opts);
+    assert_contains(html, "def hello", "? wildcard resolves to code.py");
+    apex_free_string(html);
+
+    /* Test Marked address syntax - line range */
+    html = apex_markdown_to_html("<<[simple.md][3,5]", 20, &opts);
+    assert_contains(html, "This is a simple", "Marked syntax with line range");
+    assert_not_contains(html, "Included Content", "Line range excludes header");
+    apex_free_string(html);
+
+    /* Test Marked code include with address syntax */
+    html = apex_markdown_to_html("<<(code.py)[1,3]", 18, &opts);
+    assert_contains(html, "def hello()", "Code include with line range");
+    assert_contains(html, "print", "Code include includes second line");
+    assert_not_contains(html, "return True", "Code include excludes later lines");
+    apex_free_string(html);
+
+    /* Test regex address syntax */
+    html = apex_markdown_to_html("{{simple.md}}[/This is/,/List item/]", 36, &opts);
+    assert_contains(html, "This is a simple", "Regex range includes matching line");
+    assert_contains(html, "markdown file", "Regex range includes lines between matches");
+    assert_not_contains(html, "Included Content", "Regex range excludes before first match");
+    apex_free_string(html);
+
+    /* Verify iA Writer syntax is NOT affected (no address syntax) */
+    html = apex_markdown_to_html("/code.py", 8, &opts);
+    assert_contains(html, "def hello()", "iA Writer syntax unchanged");
+    assert_contains(html, "return True", "iA Writer includes full file");
+    apex_free_string(html);
+
+    /* Test address syntax edge cases */
+    /* Single line range - line 3 is the full sentence, so [3,4] includes only line 3 */
+    html = apex_markdown_to_html("{{simple.md}}[3,4]", 20, &opts);
+    assert_contains(html, "This is a simple", "Single line range works");
+    assert_contains(html, "markdown file", "Single line includes full line 3");
+    assert_not_contains(html, "List item 1", "Single line excludes line 5");
+    apex_free_string(html);
+
+    /* Prefix with regex range - check if prefix is applied (may need to check implementation) */
+    html = apex_markdown_to_html("{{simple.md}}[/This is/,/List item/;prefix=\"  \"]", 48, &opts);
+    assert_contains(html, "This is a simple", "Regex range includes matching line");
+    /* Prefix application to regex ranges may need implementation verification */
+    apex_free_string(html);
+
+    /* Prefix only (no line range) - verify prefix-only syntax is parsed */
+    html = apex_markdown_to_html("{{code.py}}[prefix=\"// \"]", 26, &opts);
+    assert_contains(html, "def hello()", "Prefix-only includes content");
+    /* Prefix application may need implementation verification */
+    apex_free_string(html);
+
+    /* Address syntax with CSV (should extract lines before conversion) */
+    html = apex_markdown_to_html("{{data.csv}}[2,4]", 18, &opts);
+    assert_contains(html, "<table>", "CSV with address converts to table");
+    assert_contains(html, "Alice", "CSV address includes correct row");
+    assert_not_contains(html, "Name,Age,City", "CSV address excludes header");
+    apex_free_string(html);
+
+    /* Address syntax with Marked raw HTML */
+    html = apex_markdown_to_html("<<{raw.html}[1,3]", 18, &opts);
+    assert_contains(html, "APEX_RAW_INCLUDE", "Raw HTML include with address");
+    apex_free_string(html);
+
+    /* Regex with no match (should return empty) */
+    html = apex_markdown_to_html("{{simple.md}}[/NOTFOUND/,/ALSONOTFOUND/]", 44, &opts);
+    /* Should not contain any content from file */
+    if (strstr(html, "Included Content") == NULL && strstr(html, "List item") == NULL) {
+        tests_passed++;
+        tests_run++;
+        if (!errors_only_output) {
+            printf(COLOR_GREEN "✓" COLOR_RESET " Regex with no match returns empty\n");
+        }
+    } else {
+        tests_failed++;
+        tests_run++;
+        test_result(false, "Regex with no match should return empty");
+    }
+    apex_free_string(html);
+
+    bool had_failures = suite_end(suite_failures);
+    print_suite_title("File Includes Tests", had_failures, false);
+}
+
+/**
+ * Test IAL (Inline Attribute Lists)
+ */
+
+void test_definition_lists(void) {
+    int suite_failures = suite_start();
+    print_suite_title("Definition Lists Tests", false, true);
+
+    apex_options opts = apex_options_for_mode(APEX_MODE_KRAMDOWN);
+    char *html;
+
+    /* Test basic definition list */
+    html = apex_markdown_to_html("Term\n: Definition", 17, &opts);
+    assert_contains(html, "<dl>", "Definition list tag");
+    assert_contains(html, "<dt>Term</dt>", "Definition term");
+    assert_contains(html, "<dd>Definition</dd>", "Definition description");
+    apex_free_string(html);
+
+    /* Test multiple definitions */
+    html = apex_markdown_to_html("Apple\n: A fruit\n: A company", 27, &opts);
+    assert_contains(html, "<dt>Apple</dt>", "Multiple definitions term");
+    assert_contains(html, "<dd>A fruit</dd>", "First definition");
+    assert_contains(html, "<dd>A company</dd>", "Second definition");
+    apex_free_string(html);
+
+    /* Test definition with Markdown content */
+    const char *block_def = "Term\n: Definition with **bold** and *italic*";
+    html = apex_markdown_to_html(block_def, strlen(block_def), &opts);
+    assert_contains(html, "<dd>", "Definition created");
+    assert_contains(html, "<strong>bold</strong>", "Bold markdown in definition");
+    assert_contains(html, "<em>italic</em>", "Italic markdown in definition");
+    apex_free_string(html);
+
+    /* Test multiple terms and definitions */
+    const char *multi = "Term1\n: Def1\n\nTerm2\n: Def2";
+    html = apex_markdown_to_html(multi, strlen(multi), &opts);
+    assert_contains(html, "<dt>Term1</dt>", "First term");
+    assert_contains(html, "<dt>Term2</dt>", "Second term");
+    assert_contains(html, "<dd>Def1</dd>", "First definition");
+    assert_contains(html, "<dd>Def2</dd>", "Second definition");
+    apex_free_string(html);
+
+    /* Test inline links in definition list terms */
+    const char *inline_link = "Term with [inline link](https://example.com)\n: Definition";
+    html = apex_markdown_to_html(inline_link, strlen(inline_link), &opts);
+    assert_contains(html, "<dt>", "Definition term with inline link");
+    assert_contains(html, "<a href=\"https://example.com\"", "Inline link in term has href");
+    assert_contains(html, "inline link</a>", "Inline link text in term");
+    apex_free_string(html);
+
+    /* Test reference-style links in definition list terms */
+    const char *ref_link = "Term with [reference link][ref]\n: Definition\n\n[ref]: https://example.com \"Reference title\"";
+    html = apex_markdown_to_html(ref_link, strlen(ref_link), &opts);
+    assert_contains(html, "<dt>", "Definition term with reference link");
+    assert_contains(html, "<a href=\"https://example.com\"", "Reference link in term has href");
+    assert_contains(html, "title=\"Reference title\"", "Reference link in term has title");
+    assert_contains(html, "reference link</a>", "Reference link text in term");
+    apex_free_string(html);
+
+    /* Test shortcut reference links in definition list terms */
+    const char *shortcut_link = "Term with [shortcut][]\n: Definition\n\n[shortcut]: https://example.org";
+    html = apex_markdown_to_html(shortcut_link, strlen(shortcut_link), &opts);
+    assert_contains(html, "<dt>", "Definition term with shortcut reference");
+    assert_contains(html, "<a href=\"https://example.org\"", "Shortcut reference in term has href");
+    assert_contains(html, "shortcut</a>", "Shortcut reference text in term");
+    apex_free_string(html);
+
+    /* Test inline links in definition descriptions */
+    const char *def_inline = "Term\n: Definition with [inline link](https://example.com)";
+    html = apex_markdown_to_html(def_inline, strlen(def_inline), &opts);
+    assert_contains(html, "<dd>", "Definition with inline link");
+    assert_contains(html, "<a href=\"https://example.com\"", "Inline link in definition has href");
+    apex_free_string(html);
+
+    /* Test reference-style links in definition descriptions */
+    const char *def_ref = "Term\n: Definition with [reference][ref]\n\n[ref]: https://example.com";
+    html = apex_markdown_to_html(def_ref, strlen(def_ref), &opts);
+    assert_contains(html, "<dd>", "Definition with reference link");
+    assert_contains(html, "<a href=\"https://example.com\"", "Reference link in definition has href");
+    apex_free_string(html);
+
+    /* Test definition list with blank line between term and first definition */
+    const char *blank_before = "Term\n\n: definition 1\n: definition 2";
+    html = apex_markdown_to_html(blank_before, strlen(blank_before), &opts);
+    assert_contains(html, "<dl>", "Definition list with blank before first definition");
+    assert_contains(html, "<dt>Term</dt>", "Term preserved across blank line");
+    assert_contains(html, "<dd>definition 1</dd>", "First definition after blank line");
+    assert_contains(html, "<dd>definition 2</dd>", "Second definition");
+    apex_free_string(html);
+
+    /* Test definition list with blank line between definitions */
+    const char *blank_between = "Term\n: definition 1\n\n: definition 2";
+    html = apex_markdown_to_html(blank_between, strlen(blank_between), &opts);
+    assert_contains(html, "<dl>", "Definition list with blank between definitions");
+    assert_contains(html, "<dt>Term</dt>", "Term in list with blank between definitions");
+    assert_contains(html, "<dd>definition 1</dd>", "First definition");
+    assert_contains(html, "<dd>definition 2</dd>", "Second definition after blank line");
+    apex_free_string(html);
+
+    /* Test definition list with blank lines everywhere (user's exact case) */
+    const char *blank_everywhere = "Term\n\n: definition 1\n\n: definition 2";
+    html = apex_markdown_to_html(blank_everywhere, strlen(blank_everywhere), &opts);
+    assert_contains(html, "<dl>", "Definition list with blank lines everywhere");
+    assert_contains(html, "<dt>Term</dt>", "Term preserved with multiple blank lines");
+    assert_contains(html, "<dd>definition 1</dd>", "First definition");
+    assert_contains(html, "<dd>definition 2</dd>", "Second definition");
+    apex_free_string(html);
+
+    bool had_failures = suite_end(suite_failures);
+    print_suite_title("Definition Lists Tests", had_failures, false);
+}
+
+/**
+ * Test advanced tables
+ */
+
+void test_callouts(void) {
+    int suite_failures = suite_start();
+    print_suite_title("Callouts Tests", false, true);
+
+    apex_options opts = apex_options_default();
+    opts.enable_callouts = true;
+    char *html;
+
+    /* Test Bear/Obsidian NOTE callout */
+    html = apex_markdown_to_html("> [!NOTE] Important\n> This is a note", 36, &opts);
+    assert_contains(html, "class=\"callout", "Callout class present");
+    assert_contains(html, "callout-note", "Note callout type");
+    apex_free_string(html);
+
+    /* Test WARNING callout */
+    html = apex_markdown_to_html("> [!WARNING] Be careful\n> Warning text", 38, &opts);
+    assert_contains(html, "callout-warning", "Warning callout type");
+    apex_free_string(html);
+
+    /* Test TIP callout */
+    html = apex_markdown_to_html("> [!TIP] Pro tip\n> Helpful advice", 33, &opts);
+    assert_contains(html, "callout-tip", "Tip callout type");
+    apex_free_string(html);
+
+    /* Test DANGER callout */
+    html = apex_markdown_to_html("> [!DANGER] Critical\n> Dangerous action", 40, &opts);
+    assert_contains(html, "callout-danger", "Danger callout type");
+    apex_free_string(html);
+
+    /* Test INFO callout */
+    html = apex_markdown_to_html("> [!INFO] Information\n> Info text", 34, &opts);
+    assert_contains(html, "callout-info", "Info callout type");
+    apex_free_string(html);
+
+    /* Test collapsible callout with + */
+    html = apex_markdown_to_html("> [!NOTE]+ Expandable\n> Content", 32, &opts);
+    assert_contains(html, "<details", "Collapsible callout uses details");
+    apex_free_string(html);
+
+    /* Test collapsed callout with - */
+    html = apex_markdown_to_html("> [!NOTE]- Collapsed\n> Hidden content", 38, &opts);
+    assert_contains(html, "<details", "Collapsed callout uses details");
+    apex_free_string(html);
+
+    /* Test callout with multiple paragraphs */
+    const char *multi = "> [!NOTE] Title\n> Para 1\n>\n> Para 2";
+    html = apex_markdown_to_html(multi, strlen(multi), &opts);
+    assert_contains(html, "callout", "Multi-paragraph callout");
+    apex_free_string(html);
+
+    /* Test regular blockquote (not a callout) */
+    html = apex_markdown_to_html("> Just a quote\n> Regular text", 29, &opts);
+    if (strstr(html, "class=\"callout") == NULL) {
+        test_result(true, "Regular blockquote not treated as callout");
+    } else {
+        test_result(false, "Regular blockquote incorrectly treated as callout");
+    }
+    apex_free_string(html);
+
+    bool had_failures = suite_end(suite_failures);
+    print_suite_title("Callouts Tests", had_failures, false);
+}
+
+/**
+ * Test blockquotes with lists
+ */
+
+void test_blockquote_lists(void) {
+    int suite_failures = suite_start();
+    print_suite_title("Blockquote Lists Tests", false, true);
+
+    apex_options opts = apex_options_default();
+    char *html;
+
+    /* Test unordered list in blockquote */
+    html = apex_markdown_to_html("> Quote text\n>\n> - Item 1\n> - Item 2\n> - Item 3", 50, &opts);
+    assert_contains(html, "<blockquote>", "Blockquote with list has blockquote tag");
+    assert_contains(html, "<ul>", "Blockquote contains unordered list");
+    assert_contains(html, "<li>Item 1</li>", "First list item in blockquote");
+    assert_contains(html, "<li>Item 2</li>", "Second list item in blockquote");
+    assert_contains(html, "<li>Item 3</li>", "Third list item in blockquote");
+    apex_free_string(html);
+
+    /* Test ordered list in blockquote */
+    const char *ordered_list = "> Numbered items:\n>\n> 1. First\n> 2. Second\n> 3. Third";
+    html = apex_markdown_to_html(ordered_list, strlen(ordered_list), &opts);
+    assert_contains(html, "<blockquote>", "Blockquote with ordered list");
+    assert_contains(html, "<ol>", "Blockquote contains ordered list");
+    assert_contains(html, "<li>First</li>", "First ordered item");
+    assert_contains(html, "<li>Second</li>", "Second ordered item");
+    assert_contains(html, "<li>Third</li>", "Third ordered item");
+    apex_free_string(html);
+
+    /* Test nested list in blockquote */
+    html = apex_markdown_to_html("> Main list:\n>\n> - Item 1\n>   - Nested 1\n>   - Nested 2\n> - Item 2", 60, &opts);
+    assert_contains(html, "<blockquote>", "Blockquote with nested list");
+    assert_contains(html, "<ul>", "Outer list present");
+    assert_contains(html, "<li>Item 1", "Outer list item");
+    assert_contains(html, "<li>Nested 1", "Nested list item");
+    assert_contains(html, "<li>Nested 2", "Second nested item");
+    apex_free_string(html);
+
+    /* Test list with paragraph in blockquote */
+    const char *list_para = "> Introduction\n>\n> - Point one\n> - Point two\n>\n> Conclusion";
+    html = apex_markdown_to_html(list_para, strlen(list_para), &opts);
+    assert_contains(html, "<blockquote>", "Blockquote with list and paragraphs");
+    assert_contains(html, "Introduction", "Paragraph before list");
+    assert_contains(html, "<ul>", "List present");
+    /* Conclusion may be in a separate blockquote or paragraph */
+    assert_contains(html, "Conclusion", "Conclusion text present");
+    apex_free_string(html);
+
+    /* Test task list in blockquote (requires GFM mode) */
+    apex_options gfm_opts = apex_options_for_mode(APEX_MODE_GFM);
+    const char *task_list = "> Tasks:\n>\n> - [ ] Todo\n> - [x] Done\n> - [ ] Another";
+    html = apex_markdown_to_html(task_list, strlen(task_list), &gfm_opts);
+    assert_contains(html, "<blockquote>", "Blockquote with task list");
+    /* Task lists in blockquotes may not render checkboxes - verify content is present */
+    assert_contains(html, "Todo", "Todo item");
+    assert_contains(html, "Done", "Done item");
+    apex_free_string(html);
+
+    /* Test definition list in blockquote (MMD mode) */
+    html = apex_markdown_to_html("> Terms:\n>\n> Term 1\n> : Definition 1\n>\n> Term 2\n> : Definition 2", 60, &opts);
+    assert_contains(html, "<blockquote>", "Blockquote with definition list");
+    /* Definition lists may or may not be parsed depending on mode */
+    apex_free_string(html);
+
+    bool had_failures = suite_end(suite_failures);
+    print_suite_title("Blockquote Lists Tests", had_failures, false);
+}
+
+/**
+ * Test TOC generation
+ */
+
+void test_html_markdown_attributes(void) {
+    int suite_failures = suite_start();
+    print_suite_title("HTML Markdown Attributes Tests", false, true);
+
+    apex_options opts = apex_options_default();
+    char *html;
+
+    /* Test markdown="1" (parse as block markdown) */
+    const char *block1 = "<div markdown=\"1\">\n# Header\n\n**bold**\n</div>";
+    html = apex_markdown_to_html(block1, strlen(block1), &opts);
+    assert_contains(html, "<h1>Header</h1>", "markdown=\"1\" parses headers");
+    assert_contains(html, "<strong>bold</strong>", "markdown=\"1\" parses emphasis");
+    apex_free_string(html);
+
+    /* Test markdown="block" (parse as block markdown) */
+    const char *block_attr = "<div markdown=\"block\">\n## Section\n\n- List item\n</div>";
+    html = apex_markdown_to_html(block_attr, strlen(block_attr), &opts);
+    assert_contains(html, "<h2>Section</h2>", "markdown=\"block\" parses headers");
+    assert_contains(html, "<li>List item</li>", "markdown=\"block\" parses lists");
+    apex_free_string(html);
+
+    /* Test markdown="span" (parse as inline markdown) */
+    const char *span = "<div markdown=\"span\">**bold** and *italic*</div>";
+    html = apex_markdown_to_html(span, strlen(span), &opts);
+    assert_contains(html, "<strong>bold</strong>", "markdown=\"span\" parses bold");
+    assert_contains(html, "<em>italic</em>", "markdown=\"span\" parses italic");
+    apex_free_string(html);
+
+    /* Test markdown="0" (no processing) */
+    const char *no_parse = "<div markdown=\"0\">\n**not bold**\n</div>";
+    html = apex_markdown_to_html(no_parse, strlen(no_parse), &opts);
+    assert_contains(html, "**not bold**", "markdown=\"0\" preserves literal text");
+    apex_free_string(html);
+
+    /* Test nested HTML with markdown - nested tags may not parse */
+    const char *nested = "<section markdown=\"1\">\n<div>\n# Nested Header\n</div>\n</section>";
+    html = apex_markdown_to_html(nested, strlen(nested), &opts);
+    // Note: Nested HTML processing may need refinement
+    assert_contains(html, "<section>", "Section tag preserved");
+    // assert_contains(html, "<h1>", "Nested HTML with markdown");
+    apex_free_string(html);
+
+    /* Test HTML without markdown attribute (default behavior) */
+    const char *no_attr = "<div>\n**should not parse**\n</div>";
+    html = apex_markdown_to_html(no_attr, strlen(no_attr), &opts);
+    // Without markdown attribute, HTML content is typically preserved
+    assert_contains(html, "<div>", "HTML preserved without markdown attribute");
+    apex_free_string(html);
+
+    bool had_failures = suite_end(suite_failures);
+    print_suite_title("HTML Markdown Attributes Tests", had_failures, false);
+}
+
+/**
+ * Test Pandoc fenced divs
+ */
+
+void test_fenced_divs(void) {
+    int suite_failures = suite_start();
+    print_suite_title("Fenced Divs Tests", false, true);
+
+    apex_options opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+    opts.enable_divs = true;
+    char *html;
+
+    /* Test basic fenced div with ID and class */
+    const char *basic_div = "::::: {#special .sidebar}\nHere is a paragraph.\n\nAnd another.\n:::::";
+    html = apex_markdown_to_html(basic_div, strlen(basic_div), &opts);
+    assert_contains(html, "<div", "Basic fenced div renders");
+    assert_contains(html, "id=\"special\"", "Fenced div has ID");
+    assert_contains(html, "class=\"sidebar\"", "Fenced div has class");
+    assert_contains(html, "Here is a paragraph", "Fenced div content preserved");
+    assert_contains(html, "</div>", "Fenced div properly closed");
+    apex_free_string(html);
+
+    /* Test fenced div with single unbraced word (treated as class) */
+    const char *unbraced_class = "::: sidebar\nThis is a div.\n:::";
+    html = apex_markdown_to_html(unbraced_class, strlen(unbraced_class), &opts);
+    assert_contains(html, "<div", "Unbraced class div renders");
+    assert_contains(html, "class=\"sidebar\"", "Unbraced word becomes class");
+    apex_free_string(html);
+
+    /* Test fenced div with multiple classes */
+    const char *multiple_classes = "::::: {.warning .important .highlight}\nWarning text\n:::::";
+    html = apex_markdown_to_html(multiple_classes, strlen(multiple_classes), &opts);
+    assert_contains(html, "<div", "Multiple classes div renders");
+    assert_contains(html, "class=\"warning important highlight\"", "Multiple classes applied");
+    apex_free_string(html);
+
+    /* Test fenced div with custom attributes */
+    const char *custom_attrs = "::::: {#mydiv .container key=\"value\" data-id=\"123\"}\nContent\n:::::";
+    html = apex_markdown_to_html(custom_attrs, strlen(custom_attrs), &opts);
+    assert_contains(html, "<div", "Custom attributes div renders");
+    assert_contains(html, "id=\"mydiv\"", "Custom attributes div has ID");
+    assert_contains(html, "class=\"container\"", "Custom attributes div has class");
+    assert_contains(html, "key=\"value\"", "Custom attribute key present");
+    assert_contains(html, "data-id=\"123\"", "Custom attribute data-id present");
+    apex_free_string(html);
+
+    /* Test fenced div with trailing colons */
+    const char *trailing_colons = "::::: {#special .sidebar} ::::\nContent\n::::::::::::::::::";
+    html = apex_markdown_to_html(trailing_colons, strlen(trailing_colons), &opts);
+    assert_contains(html, "<div", "Trailing colons div renders");
+    assert_contains(html, "id=\"special\"", "Trailing colons div has ID");
+    apex_free_string(html);
+
+    /* Test nested fenced divs */
+    const char *nested_divs = "::: Warning ::::::\nOuter warning.\n\n::: Danger\nInner danger.\n:::\n::::::::::::::::::";
+    html = apex_markdown_to_html(nested_divs, strlen(nested_divs), &opts);
+    assert_contains(html, "<div", "Nested divs render");
+    assert_contains(html, "class=\"Warning\"", "Outer div class");
+    assert_contains(html, "class=\"Danger\"", "Inner div class");
+    assert_contains(html, "Outer warning", "Outer div content");
+    assert_contains(html, "Inner danger", "Inner div content");
+    /* Should have two opening divs and two closing divs */
+    size_t open_count = 0, close_count = 0;
+    const char *p = html;
+    while ((p = strstr(p, "<div")) != NULL) {
+        open_count++;
+        p += 4;
+    }
+    p = html;
+    while ((p = strstr(p, "</div>")) != NULL) {
+        close_count++;
+        p += 6;
+    }
+    if (open_count >= 2 && close_count >= 2) {
+        tests_run++;
+        tests_passed++;
+        if (!errors_only_output) {
+            printf(COLOR_GREEN "✓" COLOR_RESET " Nested divs properly structured\n");
+        }
+    } else {
+        tests_run++;
+        tests_failed++;
+        printf(COLOR_RED "✗" COLOR_RESET " Nested divs properly structured\n");
+    }
+    apex_free_string(html);
+
+    /* Test fenced div with block type (aside) */
+    const char *aside_block = "::: >aside {.sidebar}\nThis is an aside block.\n:::";
+    html = apex_markdown_to_html(aside_block, strlen(aside_block), &opts);
+    assert_contains(html, "<aside", "Aside block renders");
+    assert_contains(html, "</aside>", "Aside block closes");
+    assert_contains(html, "class=\"sidebar\"", "Aside block has class");
+    assert_contains(html, "This is an aside block", "Aside block content");
+    apex_free_string(html);
+
+    /* Test fenced div with block type (article) */
+    const char *article_block = "::: >article {#post .main}\nArticle content here.\n:::";
+    html = apex_markdown_to_html(article_block, strlen(article_block), &opts);
+    assert_contains(html, "<article", "Article block renders");
+    assert_contains(html, "</article>", "Article block closes");
+    assert_contains(html, "id=\"post\"", "Article block has ID");
+    assert_contains(html, "class=\"main\"", "Article block has class");
+    apex_free_string(html);
+
+    /* Test fenced div with block type (details/summary - nested) */
+    const char *details_block = "::: >details {.warning} :::\n:::: >summary\nThis is a summary\n::::\nThis is the content of the details block\n:::";
+    html = apex_markdown_to_html(details_block, strlen(details_block), &opts);
+    assert_contains(html, "<details", "Details block renders");
+    assert_contains(html, "</details>", "Details block closes");
+    assert_contains(html, "<summary", "Summary block renders");
+    assert_contains(html, "</summary>", "Summary block closes");
+    assert_contains(html, "class=\"warning\"", "Details block has class");
+    assert_contains(html, "This is a summary", "Summary content");
+    assert_contains(html, "This is the content of the details block", "Details content");
+    apex_free_string(html);
+
+    /* Test fenced div with block type and unbraced class */
+    const char *aside_unbraced = "::: >aside Warning :::\nWarning content.\n:::";
+    html = apex_markdown_to_html(aside_unbraced, strlen(aside_unbraced), &opts);
+    assert_contains(html, "<aside", "Aside with unbraced class renders");
+    assert_contains(html, "class=\"Warning\"", "Aside has unbraced class");
+    apex_free_string(html);
+
+    /* Test default div behavior (no > prefix) */
+    const char *default_div = "::: {.container}\nRegular div content.\n:::";
+    html = apex_markdown_to_html(default_div, strlen(default_div), &opts);
+    assert_contains(html, "<div", "Default div renders");
+    assert_contains(html, "</div>", "Default div closes");
+    assert_contains(html, "class=\"container\"", "Default div has class");
+    apex_free_string(html);
+
+    /* Test nested blocks with different types */
+    const char *nested_blocks = "::: >section {.outer} :::\nOuter section.\n\n::: >aside {.inner}\nInner aside.\n:::\n\nMore outer content.\n:::";
+    html = apex_markdown_to_html(nested_blocks, strlen(nested_blocks), &opts);
+    assert_contains(html, "<section", "Nested section renders");
+    assert_contains(html, "</section>", "Nested section closes");
+    assert_contains(html, "<aside", "Nested aside renders");
+    assert_contains(html, "</aside>", "Nested aside closes");
+    assert_contains(html, "Outer section", "Outer content");
+    assert_contains(html, "Inner aside", "Inner content");
+    apex_free_string(html);
+
+    /* Test block type with section */
+    const char *section_block = "::: >section {#chapter1 .main-section}\nSection content here.\n:::";
+    html = apex_markdown_to_html(section_block, strlen(section_block), &opts);
+    assert_contains(html, "<section", "Section block renders");
+    assert_contains(html, "</section>", "Section block closes");
+    assert_contains(html, "id=\"chapter1\"", "Section block has ID");
+    assert_contains(html, "class=\"main-section\"", "Section block has class");
+    apex_free_string(html);
+
+    /* Test block type with header */
+    const char *header_block = "::: >header {.site-header}\nSite header content\n:::";
+    html = apex_markdown_to_html(header_block, strlen(header_block), &opts);
+    assert_contains(html, "<header", "Header block renders");
+    assert_contains(html, "</header>", "Header block closes");
+    apex_free_string(html);
+
+    /* Test block type with footer */
+    const char *footer_block = "::: >footer {.site-footer}\nSite footer content\n:::";
+    html = apex_markdown_to_html(footer_block, strlen(footer_block), &opts);
+    assert_contains(html, "<footer", "Footer block renders");
+    assert_contains(html, "</footer>", "Footer block closes");
+    apex_free_string(html);
+
+    /* Test block type with nav */
+    const char *nav_block = "::: >nav {.main-nav}\nNavigation content\n:::";
+    html = apex_markdown_to_html(nav_block, strlen(nav_block), &opts);
+    assert_contains(html, "<nav", "Nav block renders");
+    assert_contains(html, "</nav>", "Nav block closes");
+    apex_free_string(html);
+
+    /* Test block type with explicit div */
+    const char *explicit_div = "::: >div {.custom-div}\nExplicit div content\n:::";
+    html = apex_markdown_to_html(explicit_div, strlen(explicit_div), &opts);
+    assert_contains(html, "<div", "Explicit div block renders");
+    assert_contains(html, "</div>", "Explicit div block closes");
+    apex_free_string(html);
+
+    /* Test block type with trailing colons */
+    const char *block_trailing = "::: >aside {.sidebar} :::\nContent with trailing colons\n:::";
+    html = apex_markdown_to_html(block_trailing, strlen(block_trailing), &opts);
+    assert_contains(html, "<aside", "Block with trailing colons renders");
+    assert_contains(html, "class=\"sidebar\"", "Block with trailing colons has class");
+    apex_free_string(html);
+
+    /* Test block type with multiple attributes */
+    const char *block_multi_attr = "::: >article {#post .main .highlight data-id=\"123\" role=\"main\"}\nArticle with multiple attributes\n:::";
+    html = apex_markdown_to_html(block_multi_attr, strlen(block_multi_attr), &opts);
+    assert_contains(html, "<article", "Block with multiple attributes renders");
+    assert_contains(html, "id=\"post\"", "Block has ID");
+    assert_contains(html, "class=\"main highlight\"", "Block has multiple classes");
+    assert_contains(html, "data-id=\"123\"", "Block has data attribute");
+    assert_contains(html, "role=\"main\"", "Block has role attribute");
+    apex_free_string(html);
+
+    /* Test deeply nested block types */
+    const char *deep_nested = "::: >section {.level1} :::\nLevel 1\n\n::: >article {.level2}\nLevel 2\n\n::: >aside {.level3}\nLevel 3\n:::\n\nMore level 2\n:::\n\nMore level 1\n:::";
+    html = apex_markdown_to_html(deep_nested, strlen(deep_nested), &opts);
+    assert_contains(html, "<section", "Deep nested section renders");
+    assert_contains(html, "</section>", "Deep nested section closes");
+    assert_contains(html, "<article", "Deep nested article renders");
+    assert_contains(html, "</article>", "Deep nested article closes");
+    assert_contains(html, "<aside", "Deep nested aside renders");
+    assert_contains(html, "</aside>", "Deep nested aside closes");
+    assert_contains(html, "Level 1", "Deep nested level 1 content");
+    assert_contains(html, "Level 2", "Deep nested level 2 content");
+    assert_contains(html, "Level 3", "Deep nested level 3 content");
+    apex_free_string(html);
+
+    /* Test mixed block types and regular divs */
+    const char *mixed_types = "::: >section {.outer}\nSection content\n\n::: {.regular-div}\nRegular div inside section\n:::\n\n::: >aside {.aside-in-section}\nAside inside section\n:::\n\nMore section content\n:::";
+    html = apex_markdown_to_html(mixed_types, strlen(mixed_types), &opts);
+    assert_contains(html, "<section", "Mixed types section renders");
+    assert_contains(html, "</section>", "Mixed types section closes");
+    assert_contains(html, "<div", "Mixed types regular div renders");
+    assert_contains(html, "</div>", "Mixed types regular div closes");
+    assert_contains(html, "<aside", "Mixed types aside renders");
+    assert_contains(html, "</aside>", "Mixed types aside closes");
+    apex_free_string(html);
+
+    /* Test block type with hyphenated name */
+    const char *hyphenated = "::: >custom-element {.test}\nCustom element content\n:::";
+    html = apex_markdown_to_html(hyphenated, strlen(hyphenated), &opts);
+    assert_contains(html, "<custom-element", "Hyphenated block type renders");
+    assert_contains(html, "</custom-element>", "Hyphenated block type closes");
+    apex_free_string(html);
+
+    /* Test block type preserves markdown parsing */
+    const char *block_with_markdown = "::: >article {.content}\n## Heading\n\nParagraph with **bold** text.\n:::";
+    html = apex_markdown_to_html(block_with_markdown, strlen(block_with_markdown), &opts);
+    assert_contains(html, "<article", "Block with markdown renders");
+    assert_contains(html, "<h2", "Block content parsed as markdown (heading)");
+    assert_contains(html, "Heading", "Block content parsed as markdown (heading text)");
+    assert_contains(html, "<strong", "Block content parsed as markdown (bold)");
+    assert_contains(html, "bold", "Block content parsed as markdown (bold text)");
+    apex_free_string(html);
+
+    /* Test minimum 3 colons */
+    const char *min_colons = "::: {.minimal}\nMinimal div\n:::";
+    html = apex_markdown_to_html(min_colons, strlen(min_colons), &opts);
+    assert_contains(html, "<div", "Minimum colons div renders");
+    assert_contains(html, "class=\"minimal\"", "Minimum colons div has class");
+    apex_free_string(html);
+
+    /* Test fenced div with only ID */
+    const char *only_id = "::: {#only-id}\nDiv with only ID\n:::";
+    html = apex_markdown_to_html(only_id, strlen(only_id), &opts);
+    assert_contains(html, "<div", "Only ID div renders");
+    assert_contains(html, "id=\"only-id\"", "Only ID div has ID");
+    assert_not_contains(html, "class=", "Only ID div has no class");
+    apex_free_string(html);
+
+    /* Test fenced div with only classes */
+    const char *only_classes = "::: {.only-classes .multiple}\nDiv with only classes\n:::";
+    html = apex_markdown_to_html(only_classes, strlen(only_classes), &opts);
+    assert_contains(html, "<div", "Only classes div renders");
+    assert_contains(html, "class=\"only-classes multiple\"", "Only classes div has classes");
+    assert_not_contains(html, "id=", "Only classes div has no ID");
+    apex_free_string(html);
+
+    /* Test fenced div with quoted attribute values */
+    const char *quoted_values = "::::: {#quoted .test attr1=\"quoted value\" attr2='single quoted'}\nContent\n:::::";
+    html = apex_markdown_to_html(quoted_values, strlen(quoted_values), &opts);
+    assert_contains(html, "<div", "Quoted values div renders");
+    assert_contains(html, "attr1=\"quoted value\"", "Double-quoted attribute");
+    assert_contains(html, "attr2=\"single quoted\"", "Single-quoted attribute converted");
+    apex_free_string(html);
+
+    /* Test fenced div disabled in non-Unified mode */
+    apex_options gfm_opts = apex_options_for_mode(APEX_MODE_GFM);
+    gfm_opts.enable_divs = true;  /* Even if enabled, should not work in GFM mode */
+    const char *div_in_gfm = "::: {.test}\nContent\n:::";
+    html = apex_markdown_to_html(div_in_gfm, strlen(div_in_gfm), &gfm_opts);
+    assert_not_contains(html, "<div", "Fenced divs disabled in GFM mode");
+    apex_free_string(html);
+
+    /* Test fenced div disabled with --no-divs flag */
+    apex_options no_divs_opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+    no_divs_opts.enable_divs = false;
+    const char *div_disabled = "::: {.test}\nContent\n:::";
+    html = apex_markdown_to_html(div_disabled, strlen(div_disabled), &no_divs_opts);
+    assert_not_contains(html, "<div", "Fenced divs disabled with --no-divs");
+    apex_free_string(html);
+
+    /* Test fenced div with mixed content (lists, blockquotes) */
+    const char *mixed_content = "::::: {#mixed .content}\n- List item\n- Another item\n\n> A blockquote\n\nAnd a paragraph.\n:::::";
+    html = apex_markdown_to_html(mixed_content, strlen(mixed_content), &opts);
+    assert_contains(html, "<div", "Mixed content div renders");
+    assert_contains(html, "<ul>", "Mixed content has list");
+    assert_contains(html, "<blockquote>", "Mixed content has blockquote");
+    assert_contains(html, "<p>And a paragraph.</p>", "Mixed content has paragraph");
+    apex_free_string(html);
+
+    /* Test multiple fenced divs in sequence */
+    const char *multiple_divs = "::: {.first}\nFirst div.\n:::\n\n::: {.second}\nSecond div.\n:::\n\n::: {.third}\nThird div.\n:::";
+    html = apex_markdown_to_html(multiple_divs, strlen(multiple_divs), &opts);
+    assert_contains(html, "class=\"first\"", "First div class");
+    assert_contains(html, "class=\"second\"", "Second div class");
+    assert_contains(html, "class=\"third\"", "Third div class");
+    assert_contains(html, "First div", "First div content");
+    assert_contains(html, "Second div", "Second div content");
+    assert_contains(html, "Third div", "Third div content");
+    apex_free_string(html);
+
+    bool had_failures = suite_end(suite_failures);
+    print_suite_title("Fenced Divs Tests", had_failures, false);
+}
+
+/**
+ * Test abbreviations
+ */
+
+void test_abbreviations(void) {
+    int suite_failures = suite_start();
+    print_suite_title("Abbreviations Tests", false, true);
+
+    apex_options opts = apex_options_for_mode(APEX_MODE_MULTIMARKDOWN);
+    char *html;
+
+    /* Test basic abbreviation */
+    const char *abbr_doc = "*[HTML]: Hypertext Markup Language\n\nHTML is great.";
+    html = apex_markdown_to_html(abbr_doc, strlen(abbr_doc), &opts);
+    assert_contains(html, "<abbr", "Abbreviation tag created");
+    assert_contains(html, "Hypertext Markup Language", "Abbreviation title");
+    apex_free_string(html);
+
+    /* Test multiple abbreviations */
+    const char *multi_abbr = "*[CSS]: Cascading Style Sheets\n*[JS]: JavaScript\n\nCSS and JS are essential.";
+    html = apex_markdown_to_html(multi_abbr, strlen(multi_abbr), &opts);
+    assert_contains(html, "<abbr", "Abbreviation tags present");
+    assert_contains(html, "Cascading Style Sheets", "First abbreviation");
+    assert_contains(html, "JavaScript", "Second abbreviation");
+    apex_free_string(html);
+
+    /* Test abbreviation with multiple occurrences */
+    const char *multiple = "*[API]: Application Programming Interface\n\nThe API docs explain the API usage.";
+    html = apex_markdown_to_html(multiple, strlen(multiple), &opts);
+    assert_contains(html, "<abbr", "Multiple occurrences wrapped");
+    assert_contains(html, "Application Programming Interface", "Abbreviation definition");
+    apex_free_string(html);
+
+    /* Test text without abbreviations */
+    const char *no_abbr = "Just plain text here.";
+    html = apex_markdown_to_html(no_abbr, strlen(no_abbr), &opts);
+    assert_contains(html, "plain text", "Non-abbreviation text preserved");
+    apex_free_string(html);
+
+    /* Test MMD 6 reference abbreviation: [>abbr]: expansion */
+    const char *mmd6_ref = "[>MMD]: MultiMarkdown\n\n[>MMD] is great.";
+    html = apex_markdown_to_html(mmd6_ref, strlen(mmd6_ref), &opts);
+    assert_contains(html, "<abbr", "MMD 6 reference abbr tag");
+    assert_contains(html, "MultiMarkdown", "MMD 6 reference expansion");
+    apex_free_string(html);
+
+    /* Test MMD 6 inline abbreviation: [>(abbr) expansion] */
+    const char *mmd6_inline = "This is [>(MD) Markdown] syntax.";
+    html = apex_markdown_to_html(mmd6_inline, strlen(mmd6_inline), &opts);
+    assert_contains(html, "<abbr title=\"Markdown\">MD</abbr>", "MMD 6 inline abbr");
+    apex_free_string(html);
+
+    /* Test multiple MMD 6 inline abbreviations */
+    const char *mmd6_multi = "[>(HTML) Hypertext] and [>(CSS) Styles] work.";
+    html = apex_markdown_to_html(mmd6_multi, strlen(mmd6_multi), &opts);
+    assert_contains(html, "title=\"Hypertext\">HTML</abbr>", "First MMD 6 inline");
+    assert_contains(html, "title=\"Styles\">CSS</abbr>", "Second MMD 6 inline");
+    apex_free_string(html);
+
+    /* Test mixing old and new syntax */
+    const char *mixed = "*[OLD]: Old Style\n[>NEW]: New Style\n\nOLD and [>NEW] work.";
+    html = apex_markdown_to_html(mixed, strlen(mixed), &opts);
+    assert_contains(html, "Old Style", "Old syntax in mixed");
+    assert_contains(html, "New Style", "New syntax in mixed");
+    apex_free_string(html);
+
+    bool had_failures = suite_end(suite_failures);
+    print_suite_title("Abbreviations Tests", had_failures, false);
+}
+
+/**
+ * Test MMD 6 features: multi-line setext headers and link/image titles with different quotes
+ */
+
+void test_mmd6_features(void) {
+    int suite_failures = suite_start();
+    print_suite_title("MMD 6 Features Tests", false, true);
+
+    apex_options opts = apex_options_for_mode(APEX_MODE_MULTIMARKDOWN);
+    char *html;
+
+    /* Test multi-line setext header (h1) */
+    const char *multiline_h1 = "This is\na multi-line\nsetext header\n========";
+    html = apex_markdown_to_html(multiline_h1, strlen(multiline_h1), &opts);
+    assert_contains(html, "<h1", "Multi-line setext h1 tag");
+    assert_contains(html, "This is", "Multi-line setext h1 contains first line");
+    assert_contains(html, "a multi-line", "Multi-line setext h1 contains second line");
+    assert_contains(html, "setext header</h1>", "Multi-line setext h1 contains last line");
+    apex_free_string(html);
+
+    /* Test multi-line setext header (h2) */
+    const char *multiline_h2 = "Another\nheader\nwith\nmultiple\nlines\n--------";
+    html = apex_markdown_to_html(multiline_h2, strlen(multiline_h2), &opts);
+    assert_contains(html, "<h2", "Multi-line setext h2 tag");
+    assert_contains(html, "Another", "Multi-line setext h2 contains first line");
+    assert_contains(html, "multiple", "Multi-line setext h2 contains middle line");
+    assert_contains(html, "lines</h2>", "Multi-line setext h2 contains last line");
+    apex_free_string(html);
+
+    /* Test link title with double quotes */
+    const char *link_double = "[Link](https://example.com \"Double quote title\")";
+    html = apex_markdown_to_html(link_double, strlen(link_double), &opts);
+    assert_contains(html, "<a href=\"https://example.com\"", "Link with double quote title has href");
+    assert_contains(html, "title=\"Double quote title\"", "Link with double quote title");
+    apex_free_string(html);
+
+    /* Test link title with single quotes */
+    const char *link_single = "[Link](https://example.com 'Single quote title')";
+    html = apex_markdown_to_html(link_single, strlen(link_single), &opts);
+    assert_contains(html, "<a href=\"https://example.com\"", "Link with single quote title has href");
+    assert_contains(html, "title=\"Single quote title\"", "Link with single quote title");
+    apex_free_string(html);
+
+    /* Test link title with parentheses */
+    const char *link_paren = "[Link](https://example.com (Parentheses title))";
+    html = apex_markdown_to_html(link_paren, strlen(link_paren), &opts);
+    assert_contains(html, "<a href=\"https://example.com\"", "Link with parentheses title has href");
+    assert_contains(html, "title=\"Parentheses title\"", "Link with parentheses title");
+    apex_free_string(html);
+
+    /* Test image title with double quotes */
+    const char *img_double = "![Image](image.png \"Double quote title\")";
+    html = apex_markdown_to_html(img_double, strlen(img_double), &opts);
+    assert_contains(html, "<img src=\"image.png\"", "Image with double quote title has src");
+    assert_contains(html, "title=\"Double quote title\"", "Image with double quote title");
+    apex_free_string(html);
+
+    /* Test image title with single quotes */
+    const char *img_single = "![Image](image.png 'Single quote title')";
+    html = apex_markdown_to_html(img_single, strlen(img_single), &opts);
+    assert_contains(html, "<img src=\"image.png\"", "Image with single quote title has src");
+    assert_contains(html, "title=\"Single quote title\"", "Image with single quote title");
+    apex_free_string(html);
+
+    /* Test image title with parentheses */
+    const char *img_paren = "![Image](image.png (Parentheses title))";
+    html = apex_markdown_to_html(img_paren, strlen(img_paren), &opts);
+    assert_contains(html, "<img src=\"image.png\"", "Image with parentheses title has src");
+    assert_contains(html, "title=\"Parentheses title\"", "Image with parentheses title");
+    apex_free_string(html);
+
+    /* Test reference link with double quote title */
+    const char *ref_double = "[Ref][id]\n\n[id]: https://example.com \"Reference title\"";
+    html = apex_markdown_to_html(ref_double, strlen(ref_double), &opts);
+    assert_contains(html, "<a href=\"https://example.com\"", "Reference link with double quote title has href");
+    assert_contains(html, "title=\"Reference title\"", "Reference link with double quote title");
+    apex_free_string(html);
+
+    /* Test reference link with single quote title */
+    const char *ref_single = "[Ref][id]\n\n[id]: https://example.com 'Reference title'";
+    html = apex_markdown_to_html(ref_single, strlen(ref_single), &opts);
+    assert_contains(html, "<a href=\"https://example.com\"", "Reference link with single quote title has href");
+    assert_contains(html, "title=\"Reference title\"", "Reference link with single quote title");
+    apex_free_string(html);
+
+    /* Test reference link with parentheses title */
+    const char *ref_paren = "[Ref][id]\n\n[id]: https://example.com (Reference title)";
+    html = apex_markdown_to_html(ref_paren, strlen(ref_paren), &opts);
+    assert_contains(html, "<a href=\"https://example.com\"", "Reference link with parentheses title has href");
+    assert_contains(html, "title=\"Reference title\"", "Reference link with parentheses title");
+    apex_free_string(html);
+
+    /* Test in unified mode as well */
+    apex_options unified_opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+    const char *unified_test = "Multi\nLine\nHeader\n========\n\n[Link](url 'Title')";
+    html = apex_markdown_to_html(unified_test, strlen(unified_test), &unified_opts);
+    assert_contains(html, "<h1", "Multi-line setext header works in unified mode");
+    assert_contains(html, "Multi\nLine\nHeader</h1>", "Multi-line setext header content in unified mode");
+    assert_contains(html, "title=\"Title\"", "Link title with single quotes works in unified mode");
+    apex_free_string(html);
+
+    bool had_failures = suite_end(suite_failures);
+    print_suite_title("MMD 6 Features Tests", had_failures, false);
+}
+
+/**
+ * Test emoji support
+ */
+
+void test_emoji(void) {
+    int suite_failures = suite_start();
+    print_suite_title("Emoji Tests", false, true);
+
+    apex_options opts = apex_options_default();
+    opts.enable_marked_extensions = true;
+    char *html;
+
+    /* Test basic emoji */
+    html = apex_markdown_to_html("Hello :smile: world", 19, &opts);
+    assert_contains(html, "😄", "Smile emoji converted");
+    apex_free_string(html);
+
+    /* Test multiple emoji */
+    html = apex_markdown_to_html(":thumbsup: :heart: :rocket:", 27, &opts);
+    assert_contains(html, "👍", "Thumbs up emoji");
+    assert_contains(html, "❤", "Heart emoji");
+    assert_contains(html, "🚀", "Rocket emoji");
+    apex_free_string(html);
+
+    /* Test emoji in text */
+    html = apex_markdown_to_html("I :heart: coding!", 17, &opts);
+    assert_contains(html, "❤", "Emoji in sentence");
+    assert_contains(html, "coding", "Regular text preserved");
+    apex_free_string(html);
+
+    /* Test unknown emoji (should be preserved) */
+    html = apex_markdown_to_html(":notarealemojicode:", 19, &opts);
+    assert_contains(html, ":notarealemojicode:", "Unknown emoji preserved");
+    apex_free_string(html);
+
+    /* Test emoji variations */
+    html = apex_markdown_to_html(":star: :warning: :+1:", 21, &opts);
+    assert_contains(html, "⭐", "Star emoji");
+    assert_contains(html, "⚠", "Warning emoji");
+    assert_contains(html, "👍", "Plus one emoji");
+    apex_free_string(html);
+
+    bool had_failures = suite_end(suite_failures);
+    print_suite_title("Emoji Tests", had_failures, false);
+}
+
+/**
+ * Test special markers (page breaks, pauses, end-of-block)
+ */
+
+void test_special_markers(void) {
+    int suite_failures = suite_start();
+    print_suite_title("Special Markers Tests", false, true);
+
+    apex_options opts = apex_options_default();
+    opts.enable_marked_extensions = true;
+    char *html;
+
+    /* Test page break HTML comment */
+    html = apex_markdown_to_html("Before\n\n<!--BREAK-->\n\nAfter", 28, &opts);
+    assert_contains(html, "page-break-after", "Page break marker");
+    assert_contains(html, "Before", "Content before break");
+    assert_contains(html, "After", "Content after break");
+    apex_free_string(html);
+
+    /* Test Kramdown page break */
+    html = apex_markdown_to_html("Page 1\n\n{::pagebreak /}\n\nPage 2", 32, &opts);
+    assert_contains(html, "page-break-after", "Kramdown page break");
+    assert_contains(html, "Page 2", "Content after pagebreak");
+    apex_free_string(html);
+
+    /* Test autoscroll pause */
+    html = apex_markdown_to_html("Text\n\n<!--PAUSE:5-->\n\nMore text", 31, &opts);
+    assert_contains(html, "data-pause", "Pause marker");
+    assert_contains(html, "data-pause=\"5\"", "Pause duration");
+    assert_contains(html, "More text", "Content after pause");
+    apex_free_string(html);
+
+    /* Test end-of-block marker */
+    const char *eob = "- Item 1\n\n^\n\n- Item 2";
+    html = apex_markdown_to_html(eob, strlen(eob), &opts);
+    // End of block should separate lists
+    assert_contains(html, "<ul>", "Lists created");
+    apex_free_string(html);
+
+    /* Test empty HTML comment as block separator (CommonMark spec) */
+    const char *html_comment_separator = "- foo\n- bar\n\n<!-- -->\n\n- baz\n- bim";
+    html = apex_markdown_to_html(html_comment_separator, strlen(html_comment_separator), &opts);
+    // Should create two separate lists, not one merged list
+    const char *first_ul = strstr(html, "<ul>");
+    const char *second_ul = first_ul ? strstr(first_ul + 1, "<ul>") : NULL;
+    if (second_ul != NULL) {
+        test_result(true, "Empty HTML comment separates lists");
+    } else {
+        test_result(false, "Empty HTML comment does not separate lists");
+    }
+    assert_contains(html, "<li>foo</li>", "First list contains foo");
+    assert_contains(html, "<li>bar</li>", "First list contains bar");
+    assert_contains(html, "<li>baz</li>", "Second list contains baz");
+    assert_contains(html, "<li>bim</li>", "Second list contains bim");
+    assert_contains(html, "<!-- -->", "Empty HTML comment preserved");
+    apex_free_string(html);
+
+    /* Test multiple page breaks */
+    const char *multi = "Section 1\n\n<!--BREAK-->\n\nSection 2\n\n<!--BREAK-->\n\nSection 3";
+    html = apex_markdown_to_html(multi, strlen(multi), &opts);
+    assert_contains(html, "page-break-after", "Multiple page breaks");
+    assert_contains(html, "Section 1", "First section");
+    assert_contains(html, "Section 3", "Last section");
+    apex_free_string(html);
+
+    bool had_failures = suite_end(suite_failures);
+    print_suite_title("Special Markers Tests", had_failures, false);
+}
+
+/**
+ * Test inline tables from CSV/TSV
+ */
+
+void test_advanced_footnotes(void) {
+    int suite_failures = suite_start();
+    print_suite_title("Advanced Footnotes Tests", false, true);
+
+    apex_options opts = apex_options_for_mode(APEX_MODE_KRAMDOWN);
+    char *html;
+
+    /* Direct call: cover NULL-root early return */
+    test_result(apex_process_advanced_footnotes(NULL, NULL) == NULL, "advanced footnotes: NULL root returns NULL");
+
+    /* Test basic footnote */
+    const char *basic = "Text[^1]\n\n[^1]: Footnote text";
+    html = apex_markdown_to_html(basic, strlen(basic), &opts);
+    assert_contains(html, "footnote", "Footnote generated");
+    apex_free_string(html);
+
+    /* Test Kramdown inline footnote: ^[text] */
+    const char *kramdown_inline = "Text^[Kramdown inline footnote]";
+    html = apex_markdown_to_html(kramdown_inline, strlen(kramdown_inline), &opts);
+    assert_contains(html, "footnote", "Kramdown inline footnote");
+    assert_contains(html, "Kramdown inline footnote", "Kramdown footnote content");
+    apex_free_string(html);
+
+    /* Test MMD inline footnote: [^text with spaces] */
+    apex_options mmd_opts = apex_options_for_mode(APEX_MODE_MULTIMARKDOWN);
+    const char *mmd_inline = "Text[^MMD inline footnote with spaces]";
+    html = apex_markdown_to_html(mmd_inline, strlen(mmd_inline), &mmd_opts);
+    assert_contains(html, "footnote", "MMD inline footnote");
+    assert_contains(html, "MMD inline footnote with spaces", "MMD footnote content");
+    apex_free_string(html);
+
+    /* Test regular reference (no spaces) still works */
+    const char *reference = "Text[^ref]\n\n[^ref]: Definition";
+    html = apex_markdown_to_html(reference, strlen(reference), &mmd_opts);
+    assert_contains(html, "footnote", "Regular reference footnote");
+    assert_contains(html, "Definition", "Reference footnote content");
+    apex_free_string(html);
+
+    /* Test multiple inline footnotes */
+    const char *multiple = "First^[one] and second^[two] footnotes";
+    html = apex_markdown_to_html(multiple, strlen(multiple), &opts);
+    assert_contains(html, "one", "First inline footnote");
+    assert_contains(html, "two", "Second inline footnote");
+    apex_free_string(html);
+
+    /* Test inline footnote with formatting */
+    const char *formatted = "Text^[footnote with **bold**]";
+    html = apex_markdown_to_html(formatted, strlen(formatted), &opts);
+    assert_contains(html, "footnote", "Formatted inline footnote");
+    /* Note: Markdown in inline footnotes handled by cmark-gfm */
+    apex_free_string(html);
+
+    /* Test advanced footnote with multiple paragraphs, list, and fenced code (```).
+     * This should exercise the reparse path for block-level content inside footnotes.
+     */
+    const char *blocky =
+        "Text[^a]\n"
+        "\n"
+        "[^a]: First para\n"
+        "\n"
+        "    Second para\n"
+        "\n"
+        "    - item1\n"
+        "    - item2\n"
+        "\n"
+        "    ```\n"
+        "    code\n"
+        "    ```\n";
+    html = apex_markdown_to_html(blocky, strlen(blocky), &opts);
+    assert_contains(html, "<p>First para</p>", "Advanced footnote: first paragraph");
+    assert_contains(html, "<p>Second para</p>", "Advanced footnote: second paragraph");
+    assert_contains(html, "<ul>", "Advanced footnote: list parsed");
+    assert_contains(html, "<li>item1</li>", "Advanced footnote: list item 1");
+    assert_contains(html, "<pre><code>code", "Advanced footnote: fenced code block parsed");
+    apex_free_string(html);
+
+    /* Test advanced footnote with indented code block (4+ spaces after newline). */
+    const char *indented_code =
+        "Text[^b]\n"
+        "\n"
+        "[^b]: Intro\n"
+        "\n"
+        "        indented\n"
+        "        code\n";
+    html = apex_markdown_to_html(indented_code, strlen(indented_code), &opts);
+    assert_contains(html, "<p>Intro</p>", "Indented code footnote: intro paragraph");
+    assert_contains(html, "<pre><code>indented", "Indented code footnote: code block parsed");
+    apex_free_string(html);
+
+    /* Test advanced footnote with fenced code using ~~~ (alternate fence detection). */
+    const char *tilde_fence =
+        "Text[^c]\n"
+        "\n"
+        "[^c]: Para\n"
+        "\n"
+        "    ~~~\n"
+        "    tilde\n"
+        "    ~~~\n";
+    html = apex_markdown_to_html(tilde_fence, strlen(tilde_fence), &opts);
+    assert_contains(html, "<pre><code>tilde", "Tilde fence footnote: code block parsed");
+    apex_free_string(html);
+
+    /* Test ordered list inside footnote. */
+    const char *ordered_list =
+        "Text[^d]\n"
+        "\n"
+        "[^d]: Steps\n"
+        "\n"
+        "    1. one\n"
+        "    2. two\n";
+    html = apex_markdown_to_html(ordered_list, strlen(ordered_list), &opts);
+    assert_contains(html, "<p>Steps</p>", "Ordered list footnote: intro paragraph");
+    assert_contains(html, "<ol>", "Ordered list footnote: ordered list parsed");
+    assert_contains(html, "<li>one</li>", "Ordered list footnote: first item");
+    assert_contains(html, "<li>two</li>", "Ordered list footnote: second item");
+    apex_free_string(html);
+
+    bool had_failures = suite_end(suite_failures);
+    print_suite_title("Advanced Footnotes Tests", had_failures, false);
+}
+
+/**
+ * Test standalone document output
+ */
+
+void test_sup_sub(void) {
+    int suite_failures = suite_start();
+    print_suite_title("Superscript, Subscript, Underline, Delete, and Highlight Tests", false, true);
+
+    apex_options opts = apex_options_default();
+    opts.enable_sup_sub = true;
+    char *html;
+
+    /* ===== SUBSCRIPT TESTS ===== */
+
+    /* Test H~2~O for subscript 2 (paired tildes within word) */
+    html = apex_markdown_to_html("H~2~O", 5, &opts);
+    assert_contains(html, "<sub>2</sub>", "H~2~O creates subscript 2");
+    assert_contains(html, "H<sub>2</sub>O", "Subscript within word");
+    if (strstr(html, "<u>2</u>") == NULL) {
+        test_result(true, "H~2~O is subscript, not underline");
+    } else {
+        test_result(false, "H~2~O incorrectly treated as underline");
+    }
+    apex_free_string(html);
+
+    /* Test H~2~SO~4~ for both 2 and 4 as subscripts */
+    html = apex_markdown_to_html("H~2~SO~4~", 9, &opts);
+    assert_contains(html, "<sub>2</sub>", "H~2~SO~4~ creates subscript 2");
+    assert_contains(html, "<sub>4</sub>", "H~2~SO~4~ creates subscript 4");
+    assert_contains(html, "H<sub>2</sub>SO<sub>4</sub>", "Multiple subscripts within word");
+    apex_free_string(html);
+
+    /* Test subscript ends at sentence terminators */
+    html = apex_markdown_to_html("H~2.O", 5, &opts);
+    assert_contains(html, "<sub>2</sub>", "Subscript stops at period");
+    apex_free_string(html);
+
+    html = apex_markdown_to_html("H~2,O", 5, &opts);
+    assert_contains(html, "<sub>2</sub>", "Subscript stops at comma");
+    apex_free_string(html);
+
+    html = apex_markdown_to_html("H~2;O", 5, &opts);
+    assert_contains(html, "<sub>2</sub>", "Subscript stops at semicolon");
+    apex_free_string(html);
+
+    html = apex_markdown_to_html("H~2:O", 5, &opts);
+    assert_contains(html, "<sub>2</sub>", "Subscript stops at colon");
+    apex_free_string(html);
+
+    html = apex_markdown_to_html("H~2!O", 5, &opts);
+    assert_contains(html, "<sub>2</sub>", "Subscript stops at exclamation");
+    apex_free_string(html);
+
+    html = apex_markdown_to_html("H~2?O", 5, &opts);
+    assert_contains(html, "<sub>2</sub>", "Subscript stops at question mark");
+    apex_free_string(html);
+
+    /* Test subscript ends at space */
+    html = apex_markdown_to_html("H~2 O", 5, &opts);
+    assert_contains(html, "<sub>2</sub>", "Subscript stops at space");
+    assert_contains(html, "H<sub>2</sub> O", "Space after subscript");
+    apex_free_string(html);
+
+    /* ===== SUPERSCRIPT TESTS ===== */
+
+    /* Test basic superscript */
+    html = apex_markdown_to_html("m^2", 3, &opts);
+    assert_contains(html, "<sup>2</sup>", "Basic superscript m^2");
+    assert_contains(html, "m<sup>2</sup>", "Superscript in context");
+    apex_free_string(html);
+
+    /* Test superscript ends at space */
+    html = apex_markdown_to_html("x^2 + y^2", 9, &opts);
+    assert_contains(html, "<sup>2</sup>", "Superscript stops at space");
+    assert_contains(html, "x<sup>2</sup>", "First superscript");
+    assert_contains(html, "y<sup>2</sup>", "Second superscript");
+    apex_free_string(html);
+
+    /* Test superscript ends at sentence terminators */
+    html = apex_markdown_to_html("x^2.", 4, &opts);
+    assert_contains(html, "<sup>2</sup>", "Superscript stops at period");
+    apex_free_string(html);
+
+    html = apex_markdown_to_html("x^2,", 4, &opts);
+    assert_contains(html, "<sup>2</sup>", "Superscript stops at comma");
+    apex_free_string(html);
+
+    html = apex_markdown_to_html("E = mc^2!", 9, &opts);
+    assert_contains(html, "<sup>2</sup>", "Superscript stops at exclamation");
+    apex_free_string(html);
+
+    /* Test multiple superscripts */
+    html = apex_markdown_to_html("x^2 + y^2 = z^2", 15, &opts);
+    assert_contains(html, "x<sup>2</sup>", "First superscript");
+    assert_contains(html, "y<sup>2</sup>", "Second superscript");
+    assert_contains(html, "z<sup>2</sup>", "Third superscript");
+    apex_free_string(html);
+
+    /* ===== UNDERLINE TESTS ===== */
+
+    /* Test underline with tildes at word boundaries */
+    html = apex_markdown_to_html("text ~underline~ text", 22, &opts);
+    assert_contains(html, "<u>underline</u>", "Tildes at word boundaries create underline");
+    assert_contains(html, "text <u>underline</u> text", "Underline in context");
+    if (strstr(html, "<sub>underline</sub>") == NULL) {
+        test_result(true, "~underline~ is underline, not subscript");
+    } else {
+        test_result(false, "~underline~ incorrectly treated as subscript");
+    }
+    apex_free_string(html);
+
+    /* Test underline with single word */
+    html = apex_markdown_to_html("~h2o~", 6, &opts);
+    assert_contains(html, "<u>h2o</u>", "~h2o~ creates underline");
+    if (strstr(html, "<sub>") == NULL) {
+        test_result(true, "~h2o~ is underline, not subscript");
+    } else {
+        test_result(false, "~h2o~ incorrectly treated as subscript");
+    }
+    apex_free_string(html);
+
+    /* ===== STRIKETHROUGH/DELETE TESTS ===== */
+
+    /* Test strikethrough with double tildes */
+    html = apex_markdown_to_html("text ~~deleted text~~ text", 26, &opts);
+    assert_contains(html, "<del>deleted text</del>", "Double tildes create strikethrough");
+    assert_contains(html, "text <del>deleted text</del> text", "Strikethrough in context");
+    apex_free_string(html);
+
+    /* Test strikethrough doesn't interfere with subscript */
+    html = apex_markdown_to_html("H~2~O and ~~deleted~~", 21, &opts);
+    assert_contains(html, "<sub>2</sub>", "Subscript still works with strikethrough");
+    assert_contains(html, "<del>deleted</del>", "Strikethrough still works with subscript");
+    apex_free_string(html);
+
+    /* Test strikethrough doesn't interfere with underline */
+    html = apex_markdown_to_html("~underline~ and ~~deleted~~", 27, &opts);
+    assert_contains(html, "<u>underline</u>", "Underline still works with strikethrough");
+    assert_contains(html, "<del>deleted</del>", "Strikethrough still works with underline");
+    apex_free_string(html);
+
+    /* ===== HIGHLIGHT TESTS ===== */
+
+    /* Test highlight with double equals */
+    html = apex_markdown_to_html("text ==highlighted text== text", 30, &opts);
+    assert_contains(html, "<mark>highlighted text</mark>", "Double equals create highlight");
+    assert_contains(html, "text <mark>highlighted text</mark> text", "Highlight in context");
+    apex_free_string(html);
+
+    /* Test highlight with single word */
+    html = apex_markdown_to_html("==highlight==", 14, &opts);
+    assert_contains(html, "<mark>highlight</mark>", "Single word highlight");
+    apex_free_string(html);
+
+    /* Test highlight with multiple words */
+    html = apex_markdown_to_html("==this is highlighted==", 24, &opts);
+    assert_contains(html, "<mark>this is highlighted</mark>", "Multi-word highlight");
+    apex_free_string(html);
+
+    /* Test highlight doesn't break Setext h1 */
+    html = apex_markdown_to_html("Header\n==\n\n==highlight==", 25, &opts);
+    assert_contains(html, "<h1", "Setext h1 still works");
+    assert_contains(html, "Header</h1>", "Setext h1 content");
+    assert_contains(html, "<mark>highlight</mark>", "Highlight after Setext h1");
+    /* Verify the == after header is not treated as highlight */
+    if (strstr(html, "<mark></mark>") == NULL || strstr(html, "<mark>\n</mark>") == NULL) {
+        test_result(true, "== after Setext h1 doesn't break header");
+    } else {
+        test_result(false, "== after Setext h1 breaks header");
+    }
+    apex_free_string(html);
+
+    /* Test highlight with Setext h2 (===) */
+    html = apex_markdown_to_html("Header\n---\n\n==highlight==", 25, &opts);
+    assert_contains(html, "<h2", "Setext h2 still works");
+    assert_contains(html, "Header</h2>", "Setext h2 content");
+    assert_contains(html, "<mark>highlight</mark>", "Highlight after Setext h2");
+    apex_free_string(html);
+
+    /* Test highlight in various contexts */
+    html = apex_markdown_to_html("Before ==highlight== after", 26, &opts);
+    assert_contains(html, "<mark>highlight</mark>", "Highlight in paragraph");
+    apex_free_string(html);
+
+    html = apex_markdown_to_html("**bold ==highlight== bold**", 27, &opts);
+    assert_contains(html, "<mark>highlight</mark>", "Highlight in bold");
+    apex_free_string(html);
+
+    /* ===== INTERACTION TESTS ===== */
+
+    /* Test that sup/sub is disabled when option is off */
+    apex_options no_sup_sub = apex_options_default();
+    no_sup_sub.enable_sup_sub = false;
+    html = apex_markdown_to_html("H^2 O", 5, &no_sup_sub);
+    if (strstr(html, "<sup>") == NULL) {
+        test_result(true, "Sup/sub disabled when option is off");
+    } else {
+        test_result(false, "Sup/sub not disabled when option is off");
+    }
+    apex_free_string(html);
+
+    /* Test that sup/sub is disabled in CommonMark mode */
+    apex_options cm_opts = apex_options_for_mode(APEX_MODE_COMMONMARK);
+    html = apex_markdown_to_html("H^2 O", 5, &cm_opts);
+    if (strstr(html, "<sup>") == NULL) {
+        test_result(true, "Sup/sub disabled in CommonMark mode");
+    } else {
+        test_result(false, "Sup/sub not disabled in CommonMark mode");
+    }
+    apex_free_string(html);
+
+    /* Test that sup/sub is enabled in Unified mode */
+    apex_options unified_opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+    html = apex_markdown_to_html("H^2 O", 5, &unified_opts);
+    assert_contains(html, "<sup>2</sup>", "Sup/sub enabled in Unified mode");
+    apex_free_string(html);
+
+    /* Test that sup/sub is enabled in MultiMarkdown mode */
+    apex_options mmd_opts = apex_options_for_mode(APEX_MODE_MULTIMARKDOWN);
+    html = apex_markdown_to_html("H^2 O", 5, &mmd_opts);
+    assert_contains(html, "<sup>2</sup>", "Sup/sub enabled in MultiMarkdown mode");
+    apex_free_string(html);
+
+    /* Test that ^ and ~ are preserved in math spans */
+    opts.enable_math = true;
+    html = apex_markdown_to_html("Equation: $E=mc^2$", 18, &opts);
+    assert_contains(html, "E=mc^2", "Superscript preserved in math span");
+    if (strstr(html, "<sup>2</sup>") == NULL) {
+        test_result(true, "Superscript not processed inside math span");
+    } else {
+        test_result(false, "Superscript incorrectly processed inside math span");
+    }
+    apex_free_string(html);
+
+    /* Test that ^ is preserved in footnote references */
+    html = apex_markdown_to_html("Text[^ref]", 10, &opts);
+    if (strstr(html, "<sup>ref</sup>") == NULL) {
+        test_result(true, "Superscript not processed in footnote reference");
+    } else {
+        test_result(false, "Superscript incorrectly processed in footnote reference");
+    }
+    apex_free_string(html);
+
+    /* Test that ~ is preserved in critic markup */
+    opts.enable_critic_markup = true;
+    html = apex_markdown_to_html("{~~old~>new~~}", 13, &opts);
+    if (strstr(html, "<sub>old</sub>") == NULL) {
+        test_result(true, "Subscript not processed in critic markup");
+    } else {
+        test_result(false, "Subscript incorrectly processed in critic markup");
+    }
+    apex_free_string(html);
+
+    bool had_failures = suite_end(suite_failures);
+    print_suite_title("Superscript, Subscript, Underline, Delete, and Highlight Tests", had_failures, false);
+}
+
+/**
+ * Test mixed list markers
+ */
+
+void test_mixed_lists(void) {
+    int suite_failures = suite_start();
+    print_suite_title("Mixed List Markers Tests", false, true);
+
+    char *html;
+
+    /* Test mixed markers in unified mode (should merge) */
+    apex_options unified_opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+    const char *mixed_list = "1. First item\n* Second item\n* Third item";
+    html = apex_markdown_to_html(mixed_list, strlen(mixed_list), &unified_opts);
+    assert_contains(html, "<ol>", "Mixed list creates ordered list");
+    assert_contains(html, "<li>First item</li>", "First item in list");
+    assert_contains(html, "<li>Second item</li>", "Second item in list");
+    assert_contains(html, "<li>Third item</li>", "Third item in list");
+    /* Should have only one list, not two */
+    const char *first_ol = strstr(html, "<ol>");
+    const char *second_ol = first_ol ? strstr(first_ol + 1, "<ol>") : NULL;
+    if (second_ol == NULL) {
+        test_result(true, "Mixed markers create single list in unified mode");
+    } else {
+        test_result(false, "Mixed markers create multiple lists in unified mode");
+    }
+    apex_free_string(html);
+
+    /* Test mixed markers in CommonMark mode (should be separate lists) */
+    apex_options cm_opts = apex_options_for_mode(APEX_MODE_COMMONMARK);
+    html = apex_markdown_to_html(mixed_list, strlen(mixed_list), &cm_opts);
+    assert_contains(html, "<ol>", "First list exists");
+    assert_contains(html, "<ul>", "Second list exists");
+    /* Should have two separate lists */
+    first_ol = strstr(html, "<ol>");
+    second_ol = first_ol ? strstr(first_ol + 1, "<ol>") : NULL;
+    const char *first_ul = strstr(html, "<ul>");
+    if (second_ol == NULL && first_ul != NULL) {
+        test_result(true, "Mixed markers create separate lists in CommonMark mode");
+    } else {
+        test_result(false, "Mixed markers not handled correctly in CommonMark mode");
+    }
+    apex_free_string(html);
+
+    /* Test mixed markers with unordered first */
+    const char *mixed_unordered = "* First item\n1. Second item\n2. Third item";
+    html = apex_markdown_to_html(mixed_unordered, strlen(mixed_unordered), &unified_opts);
+    assert_contains(html, "<ul>", "Unordered-first mixed list creates unordered list");
+    assert_contains(html, "<li>First item</li>", "First unordered item");
+    assert_contains(html, "<li>Second item</li>", "Second item inherits unordered");
+    apex_free_string(html);
+
+    /* Test that allow_mixed_list_markers=false creates separate lists even in unified mode */
+    unified_opts.allow_mixed_list_markers = false;
+    html = apex_markdown_to_html(mixed_list, strlen(mixed_list), &unified_opts);
+    first_ol = strstr(html, "<ol>");
+    second_ol = first_ol ? strstr(first_ol + 1, "<ol>") : NULL;
+    first_ul = strstr(html, "<ul>");
+    if (second_ol == NULL && first_ul != NULL) {
+        test_result(true, "--no-mixed-lists disables mixed list merging");
+    } else {
+        test_result(false, "--no-mixed-lists does not disable mixed list merging");
+    }
+    apex_free_string(html);
+
+    bool had_failures = suite_end(suite_failures);
+    print_suite_title("Mixed List Markers Tests", had_failures, false);
+}
+
+/**
+ * Test unsafe mode (raw HTML handling)
+ */
+
+void test_unsafe_mode(void) {
+    int suite_failures = suite_start();
+    print_suite_title("Unsafe Mode Tests", false, true);
+
+    char *html;
+
+    /* Test that unsafe mode allows raw HTML by default in unified mode */
+    apex_options unified_opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+    const char *raw_html = "<div>Raw HTML content</div>";
+    html = apex_markdown_to_html(raw_html, strlen(raw_html), &unified_opts);
+    assert_contains(html, "<div>Raw HTML content</div>", "Raw HTML allowed in unified mode");
+    if (strstr(html, "raw HTML omitted") == NULL && strstr(html, "omitted") == NULL) {
+        test_result(true, "Raw HTML preserved in unified mode (unsafe default)");
+    } else {
+        test_result(false, "Raw HTML not preserved in unified mode");
+    }
+    apex_free_string(html);
+
+    /* Test that unsafe mode blocks raw HTML in CommonMark mode */
+    apex_options cm_opts = apex_options_for_mode(APEX_MODE_COMMONMARK);
+    html = apex_markdown_to_html(raw_html, strlen(raw_html), &cm_opts);
+    if (strstr(html, "raw HTML omitted") != NULL || strstr(html, "omitted") != NULL) {
+        tests_passed++;
+        tests_run++;
+        if (!errors_only_output) {
+            printf(COLOR_GREEN "✓" COLOR_RESET " Raw HTML blocked in CommonMark mode (safe default)\n");
+        }
+    } else if (strstr(html, "<div>Raw HTML content</div>") == NULL) {
+        tests_passed++;
+        tests_run++;
+        if (!errors_only_output) {
+            printf(COLOR_GREEN "✓" COLOR_RESET " Raw HTML blocked in CommonMark mode (safe default)\n");
+        }
+    } else {
+        tests_failed++;
+        tests_run++;
+        printf(COLOR_RED "✗" COLOR_RESET " Raw HTML not blocked in CommonMark mode\n");
+    }
+    apex_free_string(html);
+
+    /* Test that unsafe=false blocks raw HTML even in unified mode */
+    unified_opts.unsafe = false;
+    html = apex_markdown_to_html(raw_html, strlen(raw_html), &unified_opts);
+    if (strstr(html, "raw HTML omitted") != NULL || strstr(html, "omitted") != NULL) {
+        test_result(true, "--no-unsafe blocks raw HTML");
+    } else if (strstr(html, "<div>Raw HTML content</div>") == NULL) {
+        test_result(true, "--no-unsafe blocks raw HTML");
+    } else {
+        test_result(false, "--no-unsafe does not block raw HTML");
+    }
+    apex_free_string(html);
+
+    /* Test that unsafe=true allows raw HTML even in CommonMark mode */
+    cm_opts.unsafe = true;
+    html = apex_markdown_to_html(raw_html, strlen(raw_html), &cm_opts);
+    assert_contains(html, "<div>Raw HTML content</div>", "Raw HTML allowed with unsafe=true");
+    apex_free_string(html);
+
+    /* Test HTML comments in unsafe mode */
+    const char *html_comment = "<!-- This is a comment -->";
+    unified_opts.unsafe = true;
+    html = apex_markdown_to_html(html_comment, strlen(html_comment), &unified_opts);
+    assert_contains(html, "<!-- This is a comment -->", "HTML comments preserved in unsafe mode");
+    apex_free_string(html);
+
+    /* Test HTML comments in safe mode */
+    unified_opts.unsafe = false;
+    html = apex_markdown_to_html(html_comment, strlen(html_comment), &unified_opts);
+    if (strstr(html, "raw HTML omitted") != NULL || strstr(html, "omitted") != NULL) {
+        test_result(true, "HTML comments blocked in safe mode");
+    } else {
+        test_result(false, "HTML comments not blocked in safe mode");
+    }
+    apex_free_string(html);
+
+    /* Test script tags are handled according to unsafe setting */
+    const char *script_tag = "<script>alert('xss')</script>";
+    unified_opts.unsafe = true;
+    html = apex_markdown_to_html(script_tag, strlen(script_tag), &unified_opts);
+    /* In unsafe mode, script tags might be preserved or escaped depending on cmark-gfm */
+    /* Just verify it's handled somehow */
+    if (strstr(html, "script") != NULL || strstr(html, "omitted") != NULL) {
+        test_result(true, "Script tags handled in unsafe mode");
+    } else {
+        test_result(false, "Script tags not handled in unsafe mode");
+    }
+    apex_free_string(html);
+
+    bool had_failures = suite_end(suite_failures);
+    print_suite_title("Unsafe Mode Tests", had_failures, false);
+}
+
+/**
+ * Test Insert Syntax (++text++)
+ */
+void test_insert_syntax(void) {
+    int suite_failures = suite_start();
+    print_suite_title("Insert Syntax Tests", false, true);
+
+    apex_options opts = apex_options_default();
+    char *html;
+
+    /* Test basic insert without IAL */
+    html = apex_markdown_to_html("Text ++inserted++ here", 23, &opts);
+    assert_contains(html, "<ins>inserted</ins>", "Basic insert syntax");
+    apex_free_string(html);
+
+    /* Test insert with Kramdown-style IAL */
+    html = apex_markdown_to_html("Text ++inserted++{: .class} here", 33, &opts);
+    assert_contains(html, "<ins", "Insert with IAL creates ins tag");
+    assert_contains(html, "class=\"class\"", "Insert with IAL has class");
+    assert_contains(html, "inserted", "Insert with IAL contains text");
+    apex_free_string(html);
+
+    /* Test insert with Pandoc-style IAL */
+    html = apex_markdown_to_html("Text ++inserted++{#id .class} here", 35, &opts);
+    assert_contains(html, "<ins", "Insert with Pandoc IAL creates ins tag");
+    assert_contains(html, "id=\"id\"", "Insert with Pandoc IAL has ID");
+    assert_contains(html, "class=\"class\"", "Insert with Pandoc IAL has class");
+    apex_free_string(html);
+
+    /* Test insert with multiple classes */
+    html = apex_markdown_to_html("Text ++inserted++{: .class1 .class2} here", 39, &opts);
+    assert_contains(html, "class=\"class1 class2\"", "Insert with multiple classes");
+    apex_free_string(html);
+
+    /* Test insert does not interfere with CriticMarkup */
+    opts.enable_critic_markup = true;
+    opts.critic_mode = 2;  /* CRITIC_MARKUP */
+    html = apex_markdown_to_html("Text {++critic++} and ++plain++ here", 38, &opts);
+    assert_contains(html, "<ins class=\"critic\">critic</ins>", "CriticMarkup insert still works");
+    assert_contains(html, "<ins>plain</ins>", "Plain insert still works");
+    apex_free_string(html);
+
+    /* Test insert in code blocks is not processed */
+    html = apex_markdown_to_html("```\n++code++\n```", 18, &opts);
+    assert_contains(html, "++code++", "Insert in code block not processed");
+    assert_not_contains(html, "<ins>code</ins>", "Insert in code block not converted");
+    apex_free_string(html);
+
+    /* Test insert in inline code is not processed */
+    html = apex_markdown_to_html("Text `++code++` here", 20, &opts);
+    assert_contains(html, "++code++", "Insert in inline code not processed");
+    assert_not_contains(html, "<ins>code</ins>", "Insert in inline code not converted");
+    apex_free_string(html);
+
+    /* Test insert with markdown inside */
+    html = apex_markdown_to_html("Text ++*italic*++ here", 23, &opts);
+    assert_contains(html, "<ins>", "Insert tag present");
+    assert_contains(html, "<em>italic</em>", "Markdown inside insert processed");
+    apex_free_string(html);
+
+    /* Test insert with IAL and markdown inside */
+    html = apex_markdown_to_html("Text ++*italic*++{: .highlight} here", 35, &opts);
+    assert_contains(html, "<ins", "Insert with IAL and markdown creates ins tag");
+    assert_contains(html, "class=\"highlight\"", "Insert with IAL has class");
+    assert_contains(html, "<em>italic</em>", "Markdown inside insert with IAL processed");
+    apex_free_string(html);
+
+    bool had_failures = suite_end(suite_failures);
+    print_suite_title("Insert Syntax Tests", had_failures, false);
+}
+
+/**
+ * Test image captions -> figure/figcaption wrapping
+ * Enabled by default in MultiMarkdown and Unified modes, configurable via options.
+ */
+void test_image_captions(void) {
+    int suite_failures = suite_start();
+    print_suite_title("Image Captions Tests", false, true);
+
+    const char *md_basic =
+        "![Alt only](/img/basic.png)\n\n"
+        "![With title](/img/title.png \"Title caption\")\n\n"
+        "![](/img/empty.png)\n";
+
+    /* MultiMarkdown mode: captions enabled by default */
+    apex_options mmd_opts = apex_options_for_mode(APEX_MODE_MULTIMARKDOWN);
+    char *html = apex_markdown_to_html(md_basic, strlen(md_basic), &mmd_opts);
+    assert_contains(html, "<figure>", "MMD: figures generated");
+    assert_contains(html, "<img src=\"/img/basic.png\"", "MMD: basic image present");
+    assert_contains(html, "<figcaption>Alt only</figcaption>", "MMD: caption from alt text");
+    assert_contains(html, "<img src=\"/img/title.png\"", "MMD: titled image present");
+    assert_contains(html, "<figcaption>Title caption</figcaption>", "MMD: caption from title text");
+    assert_not_contains(html, "<figure><img src=\"/img/empty.png\"", "MMD: no figure for empty alt/title image");
+    apex_free_string(html);
+
+    /* Unified mode: captions enabled by default */
+    apex_options unified_opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+    html = apex_markdown_to_html(md_basic, strlen(md_basic), &unified_opts);
+    assert_contains(html, "<figure>", "Unified: figures generated");
+    assert_contains(html, "<figcaption>Alt only</figcaption>", "Unified: caption from alt text");
+    assert_contains(html, "<figcaption>Title caption</figcaption>", "Unified: caption from title text");
+    assert_not_contains(html, "<figure><img src=\"/img/empty.png\"", "Unified: no figure for empty alt/title image");
+    apex_free_string(html);
+
+    /* Explicitly disabling captions should produce plain <img> tags */
+    apex_options disabled_opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+    disabled_opts.enable_image_captions = false;
+    html = apex_markdown_to_html(md_basic, strlen(md_basic), &disabled_opts);
+    assert_not_contains(html, "<figure>", "Disabled: no figures generated");
+    assert_not_contains(html, "<figcaption>", "Disabled: no figcaptions generated");
+    assert_contains(html, "<img src=\"/img/basic.png\"", "Disabled: basic image present");
+    apex_free_string(html);
+
+    /* caption="TEXT" on image adds figure/figcaption even when --image-captions is off */
+    const char *md_caption_attr = "![Alt](/img/cap.png){caption=\"Explicit caption\"}\n";
+    apex_options no_captions_opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+    no_captions_opts.enable_image_captions = false;
+    html = apex_markdown_to_html(md_caption_attr, strlen(md_caption_attr), &no_captions_opts);
+    assert_contains(html, "<figure>", "caption=: figure present");
+    assert_contains(html, "<figcaption>Explicit caption</figcaption>", "caption=: figcaption text");
+    assert_not_contains(html, "caption=\"", "caption=: caption attr stripped from img");
+    apex_free_string(html);
+
+    /* --title-captions-only: only images with title get captions; alt-only images do not */
+    const char *md_alt_and_title =
+        "![Alt only](/img/alt.png)\n\n"
+        "![With title](/img/title.png \"Title caption\")\n";
+    apex_options title_only_opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+    title_only_opts.enable_image_captions = true;
+    title_only_opts.title_captions_only = true;
+    html = apex_markdown_to_html(md_alt_and_title, strlen(md_alt_and_title), &title_only_opts);
+    assert_contains(html, "<figcaption>Title caption</figcaption>", "title_captions_only: caption from title");
+    assert_not_contains(html, "<figcaption>Alt only</figcaption>", "title_captions_only: no caption from alt");
+    apex_free_string(html);
+
+    bool had_failures = suite_end(suite_failures);
+    print_suite_title("Image Captions Tests", had_failures, false);
+}
+
+/**
+ * Test image embedding
+ */