apex-ruby 1.0.6 → 1.0.8

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

@@ -5,6 +5,8 @@
 #include "test_helpers.h"
 #include "apex/apex.h"
 #include "../src/extensions/advanced_footnotes.h"
+#include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 
 void test_math(void) {
@@ -174,6 +176,44 @@ void test_processor_modes(void) {
     print_suite_title("Processor Modes Tests", had_failures, false);
 }
 
+/**
+ * Test cmark_init callback for custom extension registration
+ */
+static int cmark_init_callback_invoked = 0;
+
+static void test_cmark_init_cb(struct cmark_parser *parser,
+                               const struct apex_options *opts,
+                               int cmark_opts,
+                               __attribute__((unused)) void *user_data) {
+    (void)parser;
+    (void)opts;
+    (void)cmark_opts;
+    cmark_init_callback_invoked = 1;
+}
+
+void test_cmark_init_callback(void) {
+    int suite_failures = suite_start();
+    print_suite_title("cmark_init callback Tests", false, true);
+
+    cmark_init_callback_invoked = 0;
+    apex_options opts = apex_options_default();
+    opts.cmark_init = test_cmark_init_cb;
+    char *html = apex_markdown_to_html("# Hi", 4, &opts);
+    test_result(cmark_init_callback_invoked == 1, "cmark_init callback was invoked");
+    assert_contains(html, "<h1", "Basic parsing still works with callback");
+    assert_contains(html, "Hi</h1>", "Header content preserved");
+    apex_free_string(html);
+
+    /* NULL callback: conversion works normally */
+    opts.cmark_init = NULL;
+    html = apex_markdown_to_html("**bold**", 8, &opts);
+    assert_contains(html, "<strong>bold</strong>", "Parsing works with NULL callback");
+    apex_free_string(html);
+
+    bool had_failures = suite_end(suite_failures);
+    print_suite_title("cmark_init callback Tests", had_failures, false);
+}
+
 /**
  * Test MultiMarkdown-style image attributes (inline and reference)
  */
@@ -327,6 +367,161 @@ void test_multimarkdown_image_attributes(void) {
         apex_free_string(html);
     }
 
+    /* webp attribute: ![alt](url webp) emits <picture> with webp source */
+    {
+        apex_options opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+        const char *webp_md = "![Hero](img/hero.png webp)";
+        char *html = apex_markdown_to_html(webp_md, strlen(webp_md), &opts);
+        assert_contains(html, "<picture>", "webp: picture element");
+        assert_contains(html, "type=\"image/webp\"", "webp: source type");
+        assert_contains(html, "img/hero.webp 1x", "webp: srcset");
+        assert_contains(html, "<img src=\"img/hero.png\"", "webp: img fallback");
+        assert_contains(html, "</picture>", "webp: picture close");
+        apex_free_string(html);
+    }
+
+    /* avif attribute: ![alt](url avif) emits <picture> with avif source */
+    {
+        apex_options opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+        const char *avif_md = "![Hero](img/hero.png avif)";
+        char *html = apex_markdown_to_html(avif_md, strlen(avif_md), &opts);
+        assert_contains(html, "<picture>", "avif: picture element");
+        assert_contains(html, "type=\"image/avif\"", "avif: source type");
+        assert_contains(html, "img/hero.avif 1x", "avif: srcset");
+        assert_contains(html, "<img src=\"img/hero.png\"", "avif: img fallback");
+        apex_free_string(html);
+    }
+
+    /* webp + @2x: srcset includes 1x and 2x for webp */
+    {
+        apex_options opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+        const char *webp_2x_md = "![Hero](img/hero.png webp @2x)";
+        char *html = apex_markdown_to_html(webp_2x_md, strlen(webp_2x_md), &opts);
+        assert_contains(html, "img/hero.webp 1x, img/hero@2x.webp 2x", "webp @2x: srcset");
+        apex_free_string(html);
+    }
+
+    /* Video URL: ![alt](video.mp4) emits <video> */
+    {
+        apex_options opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+        const char *video_md = "![Demo](media/demo.mp4)";
+        char *html = apex_markdown_to_html(video_md, strlen(video_md), &opts);
+        assert_contains(html, "<video", "video: video element");
+        assert_contains(html, "media/demo.mp4", "video: src");
+        assert_contains(html, "</video>", "video: close");
+        assert_not_contains(html, "<img", "video: no img");
+        apex_free_string(html);
+    }
+
+    /* Video with webm attribute: adds webm source */
+    {
+        apex_options opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+        const char *video_webm_md = "![Demo](media/demo.mp4 webm)";
+        char *html = apex_markdown_to_html(video_webm_md, strlen(video_webm_md), &opts);
+        assert_contains(html, "<source src=\"media/demo.webm\" type=\"video/webm\">", "video webm: source");
+        assert_contains(html, "<source src=\"media/demo.mp4\"", "video webm: primary fallback");
+        apex_free_string(html);
+    }
+
+    /* Fixture-based tests: media_formats_test.md */
+    {
+        const char *fixture_path = "tests/fixtures/images/media_formats_test.md";
+        FILE *fp = fopen(fixture_path, "rb");
+        if (fp) {
+            fseek(fp, 0, SEEK_END);
+            long sz = ftell(fp);
+            fseek(fp, 0, SEEK_SET);
+            char *src = malloc(sz + 1);
+            if (src) {
+                size_t len = fread(src, 1, (size_t)sz, fp);
+                src[len] = '\0';
+                fclose(fp);
+
+                apex_options opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+                char *html = apex_markdown_to_html(src, len, &opts);
+
+                /* Images with webp/avif: picture elements */
+                assert_contains(html, "<picture>", "fixture: picture elements");
+                assert_contains(html, "type=\"image/webp\"", "fixture: webp source type");
+                assert_contains(html, "type=\"image/avif\"", "fixture: avif source type");
+                assert_contains(html, "img/hero.webp 1x", "fixture: webp srcset");
+                assert_contains(html, "img/hero.avif 1x", "fixture: avif srcset");
+                assert_contains(html, "img/hero@2x.webp 2x", "fixture: webp @2x");
+                assert_contains(html, "img/hero@2x.avif 2x", "fixture: avif @2x");
+
+                /* Videos: video elements */
+                assert_contains(html, "<video", "fixture: video elements");
+                assert_contains(html, "media/demo.mp4", "fixture: mp4 video");
+                assert_contains(html, "assets/trailer.mov", "fixture: mov video");
+                assert_contains(html, "assets/sample.m4v", "fixture: m4v video");
+
+                /* Video with format alternatives */
+                assert_contains(html, "media/demo.webm", "fixture: video webm source");
+                assert_contains(html, "media/intro.ogg", "fixture: video ogg source");
+                assert_contains(html, "media/clip.mp4", "fixture: webm with mp4 fallback");
+
+                /* Auto attribute (marker present; expansion requires base_directory) */
+                assert_contains(html, "data-apex-replace-auto=1", "fixture: auto marker");
+
+                apex_free_string(html);
+                free(src);
+            } else {
+                fclose(fp);
+                test_result(false, "fixture: malloc failed for media_formats_test.md");
+            }
+        } else {
+            test_result(false, "fixture: could not open media_formats_test.md");
+        }
+    }
+
+    /* auto attribute: emits data-apex-replace-auto (expansion requires base_directory) */
+    {
+        apex_options opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+        const char *auto_md = "![Hero](img/hero.png auto)";
+        char *html = apex_markdown_to_html(auto_md, strlen(auto_md), &opts);
+        assert_contains(html, "data-apex-replace-auto=1", "auto: emits replace marker");
+        apex_free_string(html);
+    }
+
+    /* auto with base_directory: discovers img set (jpg, webp, avif, 2x variants), emits picture */
+    {
+        apex_options opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+        opts.base_directory = "tests/fixtures/images";
+        const char *auto_md = "![Profile menu](img/app-pass-1-profile-menu.jpg auto)";
+        char *html = apex_markdown_to_html(auto_md, strlen(auto_md), &opts);
+        assert_contains(html, "<picture>", "auto+base: picture element");
+        assert_contains(html, "type=\"image/avif\"", "auto+base: avif source");
+        assert_contains(html, "type=\"image/webp\"", "auto+base: webp source");
+        assert_contains(html, "app-pass-1-profile-menu.avif 1x", "auto+base: avif 1x");
+        assert_contains(html, "app-pass-1-profile-menu@2x.avif 2x", "auto+base: avif 2x");
+        assert_contains(html, "app-pass-1-profile-menu.webp 1x", "auto+base: webp 1x");
+        assert_contains(html, "app-pass-1-profile-menu@2x.webp 2x", "auto+base: webp 2x");
+        assert_contains(html, "<img src=\"img/app-pass-1-profile-menu.jpg\"", "auto+base: img fallback");
+        apex_free_string(html);
+    }
+
+    /* * extension: equivalent to auto, discovers formats from base filename */
+    {
+        apex_options opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+        opts.base_directory = "tests/fixtures/images";
+        const char *wildcard_md = "![Profile menu](img/app-pass-1-profile-menu.*)";
+        char *html = apex_markdown_to_html(wildcard_md, strlen(wildcard_md), &opts);
+        assert_contains(html, "<picture>", "wildcard: picture element");
+        assert_contains(html, "type=\"image/avif\"", "wildcard: avif source");
+        assert_contains(html, "type=\"image/webp\"", "wildcard: webp source");
+        assert_contains(html, "app-pass-1-profile-menu.jpg", "wildcard: jpg fallback");
+        apex_free_string(html);
+    }
+
+    /* * extension: emits data-apex-replace-auto marker when no base_directory */
+    {
+        apex_options opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+        const char *wildcard_md = "![Hero](img/hero.*)";
+        char *html = apex_markdown_to_html(wildcard_md, strlen(wildcard_md), &opts);
+        assert_contains(html, "data-apex-replace-auto=1", "wildcard: emits replace marker");
+        apex_free_string(html);
+    }
+
     bool had_failures = suite_end(suite_failures);
     print_suite_title("MultiMarkdown Image Attribute Tests", had_failures, false);
 }
@@ -383,12 +578,49 @@ void test_file_includes(void) {
     assert_contains(html, "New York", "CSV cell content");
     apex_free_string(html);
 
+    /* Test Marked CSV include with embedded shorthand delimiter override */
+    const char *marked_csv_embedded_short = "Data:\n\n<<[data-semi.csv{;}]\n\nEnd";
+    html = apex_markdown_to_html(marked_csv_embedded_short, strlen(marked_csv_embedded_short), &opts);
+    assert_contains(html, "<table>", "Marked CSV include with embedded {;} converts to table");
+    assert_contains(html, "San Francisco", "Marked CSV include with embedded {;} parses semicolon-separated values");
+    assert_not_contains(html, "{;}", "Marked CSV include consumes embedded {;} delimiter token");
+    apex_free_string(html);
+
+    /* Test Marked CSV include with embedded verbose delimiter override */
+    const char *marked_csv_embedded_verbose = "Data:\n\n<<[data-semi.csv{delimiter=;}]\n\nEnd";
+    html = apex_markdown_to_html(marked_csv_embedded_verbose, strlen(marked_csv_embedded_verbose), &opts);
+    assert_contains(html, "<table>", "Marked CSV include with embedded {delimiter=;} converts to table");
+    assert_contains(html, "Alice", "Marked CSV include with embedded {delimiter=;} parses semicolon-separated values");
+    assert_not_contains(html, "{delimiter=;}", "Marked CSV include consumes embedded verbose delimiter token");
+    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 MMD CSV transclusion with embedded shorthand delimiter override */
+    const char *mmd_csv_embedded_short = "{{data-semi.csv{;}}}";
+    html = apex_markdown_to_html(mmd_csv_embedded_short, strlen(mmd_csv_embedded_short), &opts);
+    assert_contains(html, "<table>", "MMD CSV transclusion with embedded {;} converts to table");
+    assert_contains(html, "San Francisco", "MMD CSV transclusion with embedded {;} parses semicolon-separated values");
+    assert_not_contains(html, "{;}", "MMD CSV transclusion consumes embedded {;} delimiter token");
+    apex_free_string(html);
+
+    /* Test MMD CSV transclusion with embedded verbose delimiter override */
+    const char *mmd_csv_embedded_verbose = "{{data-semi.csv{delimiter=;}}}";
+    html = apex_markdown_to_html(mmd_csv_embedded_verbose, strlen(mmd_csv_embedded_verbose), &opts);
+    assert_contains(html, "<table>", "MMD CSV transclusion with embedded {delimiter=;} converts to table");
+    assert_contains(html, "Alice", "MMD CSV transclusion with embedded {delimiter=;} parses semicolon-separated values");
+    assert_not_contains(html, "{delimiter=;}", "MMD CSV transclusion consumes embedded verbose delimiter token");
+    apex_free_string(html);
+
+    /* Test percent-encoded path in include */
+    html = apex_markdown_to_html("<<[with%20space.txt]", 21, &opts);
+    assert_contains(html, "Percent-decoded", "Percent-encoded path (with%20space.txt) resolves to file with space");
+    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");
@@ -401,6 +633,22 @@ void test_file_includes(void) {
     assert_contains(html, "def hello", "Code included");
     apex_free_string(html);
 
+    /* Test iA Writer CSV include with verbose delimiter keyword */
+    const char *ia_csv_delim_override_doc = "/data-semi.csv {delimiter=;}";
+    html = apex_markdown_to_html(ia_csv_delim_override_doc, strlen(ia_csv_delim_override_doc), &opts);
+    assert_contains(html, "<table>", "iA Writer CSV include with {delimiter=;} converts to table");
+    assert_contains(html, "Alice", "iA Writer CSV include parses semicolon-separated values");
+    assert_not_contains(html, "{delimiter=;}", "iA Writer include consumes verbose delimiter token");
+    apex_free_string(html);
+
+    /* Test iA Writer CSV include with embedded shorthand delimiter (no whitespace) */
+    const char *ia_csv_embedded_short = "/data-semi.csv{;}";
+    html = apex_markdown_to_html(ia_csv_embedded_short, strlen(ia_csv_embedded_short), &opts);
+    assert_contains(html, "<table>", "iA Writer CSV include with embedded {;} converts to table");
+    assert_contains(html, "San Francisco", "iA Writer CSV include with embedded {;} parses semicolon-separated values");
+    assert_not_contains(html, "{;}", "iA Writer include consumes embedded shorthand delimiter token");
+    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 ||
@@ -629,6 +877,56 @@ void test_definition_lists(void) {
     assert_contains(html, "<dd>definition 2</dd>", "Second definition");
     apex_free_string(html);
 
+    /* Test all four definition list formats */
+    html = apex_markdown_to_html("term\n: definition", 17, &opts);
+    assert_contains(html, "<dt>term</dt>", "Kramdown format: term + : definition");
+    assert_contains(html, "<dd>definition</dd>", "Kramdown format dd");
+    apex_free_string(html);
+
+    html = apex_markdown_to_html("term\n:: definition", 18, &opts);
+    assert_contains(html, "<dt>term</dt>", "Kramdown format: term + :: definition");
+    assert_contains(html, "<dd>definition</dd>", "Kramdown :: format dd");
+    apex_free_string(html);
+
+    html = apex_markdown_to_html("term::definition", 16, &opts);
+    assert_contains(html, "<dt>term</dt>", "One-line format: term::definition");
+    assert_contains(html, "<dd>definition</dd>", "One-line format dd");
+    apex_free_string(html);
+
+    html = apex_markdown_to_html("term :: definition", 18, &opts);
+    assert_contains(html, "<dt>term</dt>", "One-line format: term :: definition");
+    assert_contains(html, "<dd>definition</dd>", "One-line format with spaces dd");
+    apex_free_string(html);
+
+    /* One-line definition NOT converted inside inline code span */
+    html = apex_markdown_to_html("Use `term::definition` for syntax", 32, &opts);
+    assert_contains(html, "<code>term::definition</code>", "One-line def preserved in inline code");
+    assert_not_contains(html, "<dt>term</dt>", "No definition list from content inside backticks");
+    apex_free_string(html);
+
+    /* One-line definition NOT converted inside fenced code block */
+    const char *fenced_def = "```\nfoo::bar\nterm::definition\n```";
+    html = apex_markdown_to_html(fenced_def, strlen(fenced_def), &opts);
+    assert_contains(html, "foo::bar", "One-line def in fenced block preserved");
+    assert_contains(html, "term::definition", "Second one-line def in fenced block preserved");
+    assert_not_contains(html, "<dt>foo</dt>", "No definition list from fenced code content");
+    apex_free_string(html);
+
+    /* One-line definition NOT converted inside indented code block */
+    const char *indented_def = "    key::value\n    term::definition";
+    html = apex_markdown_to_html(indented_def, strlen(indented_def), &opts);
+    assert_contains(html, "key::value", "One-line def in indented block preserved");
+    assert_contains(html, "term::definition", "Second one-line def in indented block preserved");
+    assert_not_contains(html, "<dt>key</dt>", "No definition list from indented code content");
+    apex_free_string(html);
+
+    /* Kramdown : definition NOT converted inside multi-line inline code span */
+    const char *multiline_code = "`term::works\n :more:`";
+    html = apex_markdown_to_html(multiline_code, strlen(multiline_code), &opts);
+    assert_contains(html, "term::works", "One-line def in multi-line inline code preserved");
+    assert_not_contains(html, "<dt>term</dt>", "No definition list from multi-line inline code");
+    apex_free_string(html);
+
     bool had_failures = suite_end(suite_failures);
     print_suite_title("Definition Lists Tests", had_failures, false);
 }
@@ -1201,6 +1499,13 @@ void test_abbreviations(void) {
     assert_contains(html, "New Style", "New syntax in mixed");
     apex_free_string(html);
 
+    /* Test inline and reference-style in same document (both must be wrapped) */
+    const char *inline_and_ref = "This is HTML. And more [>(ABBR) abbreviation syntax].\n\n[>HTML]: Hypertext Markup Language";
+    html = apex_markdown_to_html(inline_and_ref, strlen(inline_and_ref), &opts);
+    assert_contains(html, "<abbr title=\"Hypertext Markup Language\">HTML</abbr>", "Reference abbr when mixed");
+    assert_contains(html, "<abbr title=\"abbreviation syntax\">ABBR</abbr>", "Inline abbr when mixed");
+    apex_free_string(html);
+
     bool had_failures = suite_end(suite_failures);
     print_suite_title("Abbreviations Tests", had_failures, false);
 }
@@ -1352,6 +1657,26 @@ void test_emoji(void) {
     assert_contains(html, "👍", "Plus one emoji");
     apex_free_string(html);
 
+    /* Emoji NOT converted inside inline code span */
+    html = apex_markdown_to_html("Use `:smile:` for emoji syntax", 30, &opts);
+    assert_contains(html, "<code>:smile:</code>", "Emoji preserved as literal in inline code");
+    assert_not_contains(html, "😄", "Emoji character not in code span output");
+    apex_free_string(html);
+
+    /* Emoji NOT converted inside fenced code block */
+    const char *fenced_emoji = "```\n:smile:\n:rocket:\n```";
+    html = apex_markdown_to_html(fenced_emoji, strlen(fenced_emoji), &opts);
+    assert_contains(html, ":smile:", "Emoji pattern preserved in fenced block");
+    assert_contains(html, ":rocket:", "Second emoji preserved in fenced block");
+    apex_free_string(html);
+
+    /* Emoji NOT converted inside indented code block */
+    const char *indented_emoji = "    :smile:\n    :rocket:";
+    html = apex_markdown_to_html(indented_emoji, strlen(indented_emoji), &opts);
+    assert_contains(html, ":smile:", "Emoji pattern preserved in indented block");
+    assert_contains(html, ":rocket:", "Second emoji preserved in indented block");
+    apex_free_string(html);
+
     bool had_failures = suite_end(suite_failures);
     print_suite_title("Emoji Tests", had_failures, false);
 }
@@ -1802,6 +2127,55 @@ void test_sup_sub(void) {
         test_result(false, "Subscript incorrectly processed in critic markup");
     }
     apex_free_string(html);
+    opts.enable_critic_markup = false;
+
+    /* ===== CODE BLOCKS: extended syntax not processed ===== */
+
+    /* Indented code block: ^ ~ ~~ == must appear literally, not as sup/sub/underline/strikethrough/highlight */
+    const char *indented_with_extended = "Normal text x^2 here.\n\n    code with ~subscript~ and ^caret^\n    and ~~strikethrough~~ and ==highlight==\n\nBack to normal.";
+    html = apex_markdown_to_html(indented_with_extended, strlen(indented_with_extended), &opts);
+    assert_contains(html, "<sup>2</sup>", "Superscript processed in normal text");
+    assert_contains(html, "~subscript~", "Subscript not processed in indented code block");
+    assert_contains(html, "^caret^", "Caret not processed as superscript in indented code block");
+    assert_not_contains(html, "<sub>subscript</sub>", "No subscript tag in indented code block");
+    assert_contains(html, "~~strikethrough~~", "Strikethrough not processed in indented code block");
+    assert_contains(html, "==highlight==", "Highlight not processed in indented code block");
+    assert_not_contains(html, "<mark>highlight</mark>", "No mark tag in indented code block");
+    apex_free_string(html);
+
+    /* Fenced code block: same checks */
+    const char *fenced_with_extended = "Normal x^2.\n\n```\ncode with ~subscript~ and ^caret^\nand ~~strikethrough~~ and ==highlight==\n```\n\nBack.";
+    html = apex_markdown_to_html(fenced_with_extended, strlen(fenced_with_extended), &opts);
+    assert_contains(html, "<sup>2</sup>", "Superscript processed in normal text");
+    assert_contains(html, "~subscript~", "Subscript not processed in fenced code block");
+    assert_contains(html, "^caret^", "Caret not processed in fenced code block");
+    assert_not_contains(html, "<sub>subscript</sub>", "No subscript tag in fenced code block");
+    assert_contains(html, "~~strikethrough~~", "Strikethrough not processed in fenced code block");
+    assert_contains(html, "==highlight==", "Highlight not processed in fenced code block");
+    apex_free_string(html);
+
+    /* Inline code: ^ and ~ must not be processed */
+    html = apex_markdown_to_html("Use `x^2` and `H~2~O` in code.", 32, &opts);
+    assert_contains(html, "x^2", "Caret preserved in inline code");
+    assert_contains(html, "H~2~O", "Tildes preserved in inline code");
+    assert_not_contains(html, "<sup>2</sup>", "No superscript in inline code");
+    assert_not_contains(html, "<sub>2</sub>", "No subscript in inline code");
+    apex_free_string(html);
+
+    /* Nested list with 4+ spaces: sup/sub and highlight should be processed (list line, not code block) */
+    const char *list_with_extended = "- Outer item\n    - Nested with x^2 and H~2~O\n    - And ==highlight== here";
+    html = apex_markdown_to_html(list_with_extended, strlen(list_with_extended), &opts);
+    assert_contains(html, "<sup>2</sup>", "Superscript processed in nested list line");
+    assert_contains(html, "<sub>2</sub>", "Subscript processed in nested list line");
+    assert_contains(html, "<mark>highlight</mark>", "Highlight processed in nested list line");
+    apex_free_string(html);
+
+    /* Indented line that is real code (no list marker): still no processing */
+    const char *real_indented_code = "Paragraph.\n\n    actual code ~subscript~ here\n\nBack.";
+    html = apex_markdown_to_html(real_indented_code, strlen(real_indented_code), &opts);
+    assert_contains(html, "~subscript~", "Subscript not processed in real indented code block");
+    assert_not_contains(html, "<sub>subscript</sub>", "No subscript tag in real indented code block");
+    apex_free_string(html);
 
     bool had_failures = suite_end(suite_failures);
     print_suite_title("Superscript, Subscript, Underline, Delete, and Highlight Tests", had_failures, false);

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

@@ -183,6 +183,34 @@ void test_mmd_metadata_keys(void) {
     assert_contains(html, "</body>", "HTML Footer metadata before </body>");
     apex_free_string(html);
 
+    /* Test generic metadata tags in standalone HTML head */
+    opts.standalone = true;
+    const char *head_meta_doc =
+        "Title: This is the Title\n"
+        "Author: That would be me\n"
+        "Date: March 9, 2026\n\n"
+        "# Test";
+    html = apex_markdown_to_html(head_meta_doc, strlen(head_meta_doc), &opts);
+    assert_contains(html, "<meta name=\"Author\" content=\"That would be me\"/>", "Author metadata emitted as meta tag");
+    assert_contains(html, "<meta name=\"Date\" content=\"March 9, 2026\"/>", "Date metadata emitted as meta tag");
+    apex_free_string(html);
+
+    /* Test generic metadata tags in standalone HTML head (Unified mode) */
+    apex_options unified_head_opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+    unified_head_opts.standalone = true;
+    html = apex_markdown_to_html(head_meta_doc, strlen(head_meta_doc), &unified_head_opts);
+    assert_contains(html, "<meta name=\"Author\" content=\"That would be me\"/>", "Unified: author metadata emitted as meta tag");
+    assert_contains(html, "<meta name=\"Date\" content=\"March 9, 2026\"/>", "Unified: date metadata emitted as meta tag");
+    apex_free_string(html);
+
+    /* Test generic metadata tags in standalone HTML head (Kramdown mode) */
+    apex_options kramdown_head_opts = apex_options_for_mode(APEX_MODE_KRAMDOWN);
+    kramdown_head_opts.standalone = true;
+    html = apex_markdown_to_html(head_meta_doc, strlen(head_meta_doc), &kramdown_head_opts);
+    assert_contains(html, "<meta name=\"Author\" content=\"That would be me\"/>", "Kramdown: author metadata emitted as meta tag");
+    assert_contains(html, "<meta name=\"Date\" content=\"March 9, 2026\"/>", "Kramdown: date metadata emitted as meta tag");
+    apex_free_string(html);
+
     /* Test normalized key matching (spaces removed, case-insensitive) */
     opts.standalone = false;
     opts.enable_smart_typography = true;  /* Ensure smart typography is enabled */
@@ -200,6 +228,20 @@ void test_mmd_metadata_keys(void) {
     assert_contains(html, "&bdquo;", "Case-insensitive: QUOTES LANGUAGE works");
     apex_free_string(html);
 
+    /* MMD delimiter block compatibility: opening/closing with repeated chars */
+    opts.standalone = true;
+    const char *mmd_delimited_doc =
+        "----\n"
+        "Title: Delimited Title\n"
+        "Author: Delimited Author\n"
+        "......\n"
+        "\n"
+        "# Body";
+    html = apex_markdown_to_html(mmd_delimited_doc, strlen(mmd_delimited_doc), &opts);
+    assert_contains(html, "<meta name=\"Author\" content=\"Delimited Author\"/>", "MMD delimiter block: author parsed");
+    assert_not_contains(html, "......", "MMD delimiter block: dot closer not rendered in body");
+    apex_free_string(html);
+
     bool had_failures = suite_end(suite_failures);
     print_suite_title("MultiMarkdown Metadata Keys Tests", had_failures, false);
 }
@@ -747,6 +789,32 @@ void test_syntax_highlight_options(void) {
     apex_free_metadata(metadata);
     metadata = NULL;
 
+    /* Test code-highlight option: shiki (full name) */
+    opts = apex_options_default();
+    item = malloc(sizeof(apex_metadata_item));
+    item->key = strdup("code-highlight");
+    item->value = strdup("shiki");
+    item->next = NULL;
+    metadata = item;
+
+    apex_apply_metadata_to_options(metadata, &opts);
+    assert_option_string(opts.code_highlighter, "shiki", "code-highlight: shiki sets code_highlighter");
+    apex_free_metadata(metadata);
+    metadata = NULL;
+
+    /* Test code-highlight option: sh (abbreviation for shiki) */
+    opts = apex_options_default();
+    item = malloc(sizeof(apex_metadata_item));
+    item->key = strdup("code-highlight");
+    item->value = strdup("sh");
+    item->next = NULL;
+    metadata = item;
+
+    apex_apply_metadata_to_options(metadata, &opts);
+    assert_option_string(opts.code_highlighter, "shiki", "code-highlight: sh (abbreviation) sets shiki");
+    apex_free_metadata(metadata);
+    metadata = NULL;
+
     /* Test code-highlight option: false disables */
     opts = apex_options_default();
     opts.code_highlighter = "pygments";  /* Start with it enabled */