apex-ruby 1.0.18 → 1.0.20

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

@@ -18,6 +18,105 @@ void test_toc(void) {
     opts.enable_marked_extensions = true;
     char *html;
 
+    /* -t toc: Markdown list, default depth 1-3 */
+    apex_options toc_opts = apex_options_default();
+    toc_opts.output_format = APEX_OUTPUT_TOC;
+    const char *doc =
+        "# Introduction\n\n"
+        "## Getting Started\n\n"
+        "### Installation\n\n"
+        "#### Too Deep\n\n"
+        "## Configuration\n\n"
+        "# API\n"
+        "{: .no_toc}\n";
+    char *md = apex_markdown_to_html(doc, strlen(doc), &toc_opts);
+    assert_contains(md, "- [Introduction](#introduction)\n", "TOC md has H1");
+    assert_contains(md, "  - [Getting Started](#getting-started)\n", "TOC md indents H2");
+    assert_contains(md, "    - [Installation](#installation)\n", "TOC md indents H3");
+    assert_not_contains(md, "Too Deep", "TOC md excludes H4 by default");
+    assert_not_contains(md, "API", "TOC md excludes no_toc heading");
+    assert_not_contains(md, "<nav", "TOC md is not HTML");
+    apex_free_string(md);
+
+    toc_opts.toc_min = 2;
+    toc_opts.toc_max = 4;
+    md = apex_markdown_to_html(doc, strlen(doc), &toc_opts);
+    assert_not_contains(md, "Introduction", "toc-min-max excludes H1");
+    assert_contains(md, "Too Deep", "toc-min-max includes H4");
+    apex_free_string(md);
+
+    /* id-format mmd */
+    toc_opts = apex_options_default();
+    toc_opts.output_format = APEX_OUTPUT_TOC;
+    toc_opts.id_format = 1; /* MMD */
+    md = apex_markdown_to_html("# Hello World\n", 14, &toc_opts);
+    assert_contains(md, "- [Hello World](#helloworld)\n", "TOC md respects MMD id-format");
+    apex_free_string(md);
+
+    /* manual ID */
+    toc_opts = apex_options_default();
+    toc_opts.output_format = APEX_OUTPUT_TOC;
+    md = apex_markdown_to_html("# Custom {#my-custom}\n", 22, &toc_opts);
+    assert_contains(md, "- [Custom](#my-custom)\n", "TOC md uses manual heading ID");
+    apex_free_string(md);
+
+    /* id-format kramdown */
+    toc_opts = apex_options_default();
+    toc_opts.output_format = APEX_OUTPUT_TOC;
+    toc_opts.id_format = 2; /* Kramdown */
+    md = apex_markdown_to_html("# Trailing Dash-\n", 17, &toc_opts);
+    assert_contains(md, "- [Trailing Dash-](#trailing-dash-)\n", "TOC md respects Kramdown id-format");
+    apex_free_string(md);
+
+    /* empty */
+    toc_opts = apex_options_default();
+    toc_opts.output_format = APEX_OUTPUT_TOC;
+    md = apex_markdown_to_html("No headings here.\n", 18, &toc_opts);
+    if (md && (md[0] == '\0' || strcmp(md, "\n") == 0)) {
+        test_result(true, "TOC md empty when no headings");
+    } else {
+        test_result(false, "TOC md empty when no headings");
+    }
+    apex_free_string(md);
+
+    /* Bare {{TOC}} should use option defaults (1-3): exclude H4 */
+    const char *bare_default_depth =
+        "# H1\n\n{{TOC}}\n\n## H2\n\n### H3\n\n#### H4";
+    html = apex_markdown_to_html(bare_default_depth, strlen(bare_default_depth), &opts);
+    assert_contains(html, "href=\"#h1\"", "Bare TOC includes H1 by default");
+    assert_contains(html, "href=\"#h3\"", "Bare TOC includes H3 by default");
+    assert_not_contains(html, "href=\"#h4\"", "Bare TOC excludes H4 by default (max 3)");
+    apex_free_string(html);
+
+    /* --toc-min-max via options: 2,4 */
+    apex_options depth_opts = opts;
+    depth_opts.toc_min = 2;
+    depth_opts.toc_max = 4;
+    html = apex_markdown_to_html(bare_default_depth, strlen(bare_default_depth), &depth_opts);
+    assert_not_contains(html, "href=\"#h1\"", "toc_min=2 excludes H1");
+    assert_contains(html, "href=\"#h4\"", "toc_max=4 includes H4");
+    apex_free_string(html);
+
+    /* Marker override wins over options */
+    const char *override_toc =
+        "# H1\n\n{{TOC:1-6}}\n\n## H2\n\n### H3\n\n#### H4\n\n##### H5";
+    html = apex_markdown_to_html(override_toc, strlen(override_toc), &depth_opts);
+    assert_contains(html, "href=\"#h1\"", "Marker range overrides toc_min");
+    assert_contains(html, "href=\"#h5\"", "Marker range overrides toc_max");
+    apex_free_string(html);
+
+    /* Partial marker max under custom toc_min/toc_max: unspecified min is 1, not option min */
+    apex_options partial_opts = opts;
+    partial_opts.toc_min = 2;
+    partial_opts.toc_max = 4;
+    const char *partial_max =
+        "# H1\n\n<!--TOC max5-->\n\n## H2\n\n### H3\n\n#### H4\n\n##### H5\n\n###### H6";
+    html = apex_markdown_to_html(partial_max, strlen(partial_max), &partial_opts);
+    assert_contains(html, "href=\"#h1\"", "Partial max marker uses min=1 not option toc_min");
+    assert_contains(html, "href=\"#h5\"", "Partial max marker includes H5");
+    assert_not_contains(html, "href=\"#h6\"", "Partial max marker excludes H6");
+    apex_free_string(html);
+
     /* Test basic TOC marker */
     const char *doc_with_toc = "# Header 1\n\n<!--TOC-->\n\n## Header 2\n\n### Header 3";
     html = apex_markdown_to_html(doc_with_toc, strlen(doc_with_toc), &opts);
@@ -56,6 +155,36 @@ void test_toc(void) {
     }
     apex_free_string(html);
 
+    /* Regression: {{TOC:2}} must not parse beyond marker into later IDs */
+    const char *single_depth_toc =
+        "# Table of Contents Test\n\n{{TOC:2}}\n\nLorem ipsum\n\n## Section 1\n\n## Section 2\n\n## Section 3";
+    html = apex_markdown_to_html(single_depth_toc, strlen(single_depth_toc), &opts);
+    assert_contains(html, "<nav class=\"toc\">", "Single depth TOC nav rendered");
+    assert_contains(html, "href=\"#section-1\"", "Single depth TOC includes Section 1");
+    assert_contains(html, "href=\"#section-2\"", "Single depth TOC includes Section 2");
+    assert_contains(html, "href=\"#section-3\"", "Single depth TOC includes Section 3");
+    apex_free_string(html);
+
+    /* Regression: same-level headings in {{TOC:2-6}} should remain siblings */
+    const char *same_level_range_toc =
+        "# Table of Contents Test\n\n{{TOC:2-6}}\n\nLorem ipsum\n\n## Section 1\n\n## Section 2\n\n## Section 3";
+    html = apex_markdown_to_html(same_level_range_toc, strlen(same_level_range_toc), &opts);
+    assert_contains(html, "href=\"#section-1\"", "Range TOC includes Section 1");
+    assert_contains(html, "href=\"#section-2\"", "Range TOC includes Section 2");
+    assert_contains(html, "href=\"#section-3\"", "Range TOC includes Section 3");
+    assert_not_contains(html, "href=\"#section-1\">Section 1</a>\n        <ul>",
+                        "Range TOC does not nest same-level headings");
+    apex_free_string(html);
+
+    /* Regression: TOC labels should not include source indentation/newline whitespace */
+    const char *toc_whitespace =
+        "# Top\n\n{{TOC:2}}\n\n##   Section 1\n\n##\tSection 2\n\n## Section   3";
+    html = apex_markdown_to_html(toc_whitespace, strlen(toc_whitespace), &opts);
+    assert_contains(html, "href=\"#section-1\">Section 1</a>", "TOC trims label whitespace");
+    assert_contains(html, "href=\"#section-2\">Section 2</a>", "TOC normalizes tab/newline whitespace");
+    assert_contains(html, "href=\"#section-3\">Section 3</a>", "TOC collapses internal whitespace runs");
+    apex_free_string(html);
+
     /* Test TOC with max depth only */
     const char *max_toc = "# H1\n\n<!--TOC max2-->\n\n## H2\n\n### H3";
     html = apex_markdown_to_html(max_toc, strlen(max_toc), &opts);
@@ -86,6 +215,52 @@ void test_toc(void) {
     assert_contains(html, "Section", "TOC includes section");
     apex_free_string(html);
 
+    /* Escaped MMD TOC markers must not be expanded */
+    const char *escaped_toc =
+        "# Title\n\nMarked also recognizes MultiMarkdown-style \\{\\{TOC\\}\\}, "
+        "and Pandoc-style `{{TOC:2-6}}`.\n\n## Section";
+    html = apex_markdown_to_html(escaped_toc, strlen(escaped_toc), &opts);
+    assert_contains(html, "{{TOC}}", "Escaped MMD TOC marker preserved as literal text");
+    assert_not_contains(html, "<nav class=\"toc\">", "Escaped MMD TOC marker not expanded");
+    assert_contains(html, "<code>{{TOC:2-6}}</code>", "Pandoc-style TOC marker preserved in inline code");
+    apex_free_string(html);
+
+    /* Kramdown {:toc} inside indented code must not be converted */
+    apex_options kram_opts2 = apex_options_for_mode(APEX_MODE_KRAMDOWN);
+    kram_opts2.enable_marked_extensions = true;
+    const char *kramdown_toc_code = "# Title\n\n    {:toc}\n\n## Section";
+    html = apex_markdown_to_html(kramdown_toc_code, strlen(kramdown_toc_code), &kram_opts2);
+    assert_contains(html, "{:toc}", "Kramdown {:toc} preserved in indented code");
+    assert_not_contains(html, "<nav class=\"toc\">", "Kramdown {:toc} not expanded in indented code");
+    apex_free_string(html);
+
+    /* Pandoc-style {{TOC:2-6}} inside fenced code must not be rendered */
+    const char *toc_range_fenced = "# Title\n\n```\n{{TOC:2-6}}\n```\n\n## Section\n\n### Sub";
+    html = apex_markdown_to_html(toc_range_fenced, strlen(toc_range_fenced), &opts);
+    assert_contains(html, "{{TOC:2-6}}", "Pandoc-style TOC marker preserved in fenced code");
+    assert_not_contains(html, "<nav class=\"toc\">", "Pandoc-style TOC marker not expanded in fenced code");
+    apex_free_string(html);
+
+    /* Pandoc-style {{TOC:2-6}} inside indented code must not be rendered */
+    const char *toc_range_indented = "# Title\n\n    {{TOC:2-6}}\n\n## Section\n\n### Sub";
+    html = apex_markdown_to_html(toc_range_indented, strlen(toc_range_indented), &opts);
+    assert_contains(html, "{{TOC:2-6}}", "Pandoc-style TOC marker preserved in indented code");
+    assert_not_contains(html, "<nav class=\"toc\">", "Pandoc-style TOC marker not expanded in indented code");
+    apex_free_string(html);
+
+    /* HTML <!--TOC--> inside inline code must not be rendered */
+    html = apex_markdown_to_html("# Title\n\nUse `<!--TOC-->` here.\n\n## Section", 44, &opts);
+    assert_contains(html, "<code>&lt;!--TOC--&gt;</code>", "HTML TOC marker preserved in inline code");
+    assert_not_contains(html, "<nav class=\"toc\">", "HTML TOC marker not expanded in inline code");
+    apex_free_string(html);
+
+    /* Kramdown {:toc} inside fenced code must not be converted */
+    const char *kramdown_toc_fenced = "# Title\n\n```\n{:toc}\n```\n\n## Section";
+    html = apex_markdown_to_html(kramdown_toc_fenced, strlen(kramdown_toc_fenced), &kram_opts2);
+    assert_contains(html, "{:toc}", "Kramdown {:toc} preserved in fenced code");
+    assert_not_contains(html, "<nav class=\"toc\">", "Kramdown {:toc} not expanded in fenced code");
+    apex_free_string(html);
+
     /* Test document without TOC marker */
     const char *no_toc = "# Header\n\nContent";
     html = apex_markdown_to_html(no_toc, strlen(no_toc), &opts);
@@ -165,6 +340,58 @@ void test_toc(void) {
     }
     apex_free_string(html);
 
+    /* Manual {#id} must appear in TOC hrefs */
+    const char *manual_id_toc =
+        "# Custom {#my-custom}\n\n{{TOC}}\n\n## Other";
+    html = apex_markdown_to_html(manual_id_toc, strlen(manual_id_toc), &opts);
+    assert_contains(html, "href=\"#my-custom\"", "TOC uses manual heading ID");
+    apex_free_string(html);
+
+    /* Structured TOC entries API for library / Swift consumers */
+    {
+        const char *entries_doc =
+            "# Introduction\n\n"
+            "## Getting Started\n\n"
+            "### Installation\n\n"
+            "#### Too Deep\n\n"
+            "# Skip Me\n"
+            "{: .no_toc}\n";
+        size_t count = 0;
+        apex_toc_entry *entries = apex_markdown_to_toc_entries(
+            entries_doc, strlen(entries_doc), NULL, &count);
+        assert_option_bool(count == 3, true, "toc entries default depth count is 3");
+        if (entries && count >= 3) {
+            assert_option_bool(entries[0].level == 1, true, "toc entries[0] level is 1");
+            assert_option_string(entries[0].text, "Introduction", "toc entries[0] text");
+            assert_option_string(entries[0].id, "introduction", "toc entries[0] id");
+            assert_option_bool(entries[1].level == 2, true, "toc entries[1] level is 2");
+            assert_option_string(entries[1].id, "getting-started", "toc entries[1] id");
+            assert_option_bool(entries[2].level == 3, true, "toc entries[2] level is 3");
+            assert_option_string(entries[2].id, "installation", "toc entries[2] id");
+        } else {
+            test_result(false, "toc entries array populated");
+        }
+        apex_toc_entries_free(entries, count);
+
+        apex_options depth_opts = apex_options_default();
+        depth_opts.toc_min = 2;
+        depth_opts.toc_max = 4;
+        entries = apex_markdown_to_toc_entries(entries_doc, strlen(entries_doc),
+                                              &depth_opts, &count);
+        assert_option_bool(count == 3, true, "toc entries toc_min/max count");
+        if (entries && count >= 1) {
+            assert_option_bool(entries[0].level == 2, true, "toc entries respects toc_min");
+            assert_option_string(entries[count - 1].text, "Too Deep",
+                                 "toc entries includes H4 when toc_max=4");
+        }
+        apex_toc_entries_free(entries, count);
+
+        entries = apex_markdown_to_toc_entries("No headings.\n", 12, NULL, &count);
+        assert_option_bool(count == 0, true, "toc entries empty when no headings");
+        assert_option_bool(entries == NULL, true, "toc entries NULL when empty");
+        apex_toc_entries_free(entries, count);
+    }
+
     bool had_failures = suite_end(suite_failures);
     print_suite_title("TOC Generation Tests", had_failures, false);
 }
@@ -273,6 +500,13 @@ void test_pretty_html(void) {
     assert_contains(html, "<strong>bold</strong>", "Inline elements not split");
     apex_free_string(html);
 
+    /* TOC links should not get indentation whitespace inside anchor text */
+    html = apex_markdown_to_html("# Top\n\n{{TOC:2}}\n\n## Section 1", 31, &opts);
+    assert_contains(html, "<a href=\"#section-1\">Section 1</a>", "Pretty mode keeps TOC link text clean");
+    assert_not_contains(html, "<a href=\"#section-1\">        Section 1</a>",
+                        "Pretty mode does not pad TOC link text");
+    apex_free_string(html);
+
     /* Test table formatting */
     const char *table = "| A | B |\n|---|---|\n| C | D |";
     html = apex_markdown_to_html(table, strlen(table), &opts);
@@ -473,10 +707,118 @@ void test_terminal_output(void) {
     test_result(strstr(out, "![") == NULL, "Missing local image uses link style not markdown image");
     apex_free_string(out);
 
+    /* paginate_symbols: must not crash; non-TTY uses link-style images */
+    opts = apex_options_default();
+    opts.output_format = APEX_OUTPUT_TERMINAL256;
+    opts.paginate = true;
+    opts.paginate_symbols = true;
+    out = apex_markdown_to_html("![z](local.png)", 17, &opts);
+    test_result(out != NULL, "paginate_symbols terminal256 produces output");
+    apex_free_string(out);
+
     bool had_failures = suite_end(suite_failures);
     print_suite_title("Terminal Output Tests", had_failures, false);
 }
 
+/**
+ * Test RTF output
+ */
+void test_rtf_output(void) {
+    int suite_failures = suite_start();
+    print_suite_title("RTF Output Tests", false, true);
+
+    apex_options opts = apex_options_default();
+    opts.output_format = APEX_OUTPUT_RTF;
+    char *out;
+
+    const char *md =
+        "# Title\n\n"
+        "A paragraph with **bold**, *italic*, ~~strike~~, and `code`.\n\n"
+        "Visit [Example](https://example.com).\n\n"
+        "- Item one\n"
+        "- Item two\n\n"
+        "> A quote\n\n"
+        "```\ncode block\n```\n\n"
+        "| A | B |\n| --- | --- |\n| 1 | 2 |\n\n"
+        "H~2~O and E=mc^2^.\n\n"
+        "---\n";
+
+    out = apex_markdown_to_html(md, strlen(md), &opts);
+    assert_contains(out, "{\\rtf1", "RTF has document header");
+    assert_contains(out, "\\fonttbl", "RTF has font table");
+    assert_contains(out, "Title", "RTF includes heading text");
+    assert_contains(out, "\\b ", "RTF has bold");
+    assert_contains(out, "\\i ", "RTF has italic");
+    assert_contains(out, "\\strike", "RTF has strikethrough");
+    assert_contains(out, "\\f1", "RTF uses mono font for code");
+    assert_contains(out, "HYPERLINK", "RTF has hyperlink field");
+    assert_contains(out, "example.com", "RTF link URL present");
+    assert_contains(out, "\\bullet", "RTF has bullet list");
+    assert_contains(out, "\\trowd", "RTF has table row");
+    assert_contains(out, "code block", "RTF has code block text");
+    assert_contains(out, "\\super", "RTF has superscript");
+    assert_contains(out, "\\sub", "RTF has subscript");
+    test_result(out != NULL && strstr(out, "}") != NULL, "RTF document contains closing brace");
+    apex_free_string(out);
+
+    /* Ordered list alone so mixed-list merging cannot absorb it into a ul */
+    out = apex_markdown_to_html("1. First\n2. Second\n", 20, &opts);
+    assert_contains(out, "1. ", "RTF has ordered list marker");
+    assert_contains(out, "First", "RTF ordered list item text");
+    apex_free_string(out);
+
+    /* Footnotes endnotes */
+    const char *fn = "Note.[^1]\n\n[^1]: Footnote body.\n";
+    out = apex_markdown_to_html(fn, strlen(fn), &opts);
+    assert_contains(out, "{\\rtf1", "Footnote doc is RTF");
+    assert_contains(out, "Footnotes", "RTF endnotes section");
+    assert_contains(out, "Footnote body", "RTF footnote body");
+    apex_free_string(out);
+
+    /* Direct serializer */
+    out = apex_markdown_to_html("Hi", 2, &opts);
+    test_result(out != NULL && strncmp(out, "{\\rtf1", 6) == 0, "apex_markdown_to_html RTF path");
+    apex_free_string(out);
+
+    /* Remote images: alt becomes a hyperlink; no raw URL dump in body */
+    {
+        const char *remote =
+            "![Version: 1.1.12](https://img.shields.io/badge/Version-1.1.12-528c9e)\n";
+        out = apex_markdown_to_html(remote, strlen(remote), &opts);
+        assert_contains(out, "HYPERLINK", "Remote image uses HYPERLINK fallback");
+        assert_contains(out, "Version: 1.1.12", "Remote image shows alt text");
+        assert_contains(out, "img.shields.io", "Remote image URL in HYPERLINK field");
+        test_result(out != NULL && strstr(out, "] (") == NULL, "Remote image does not dump ] (url)");
+        test_result(out != NULL && strstr(out, "\\pict") == NULL, "Remote image is not embedded as pict");
+        apex_free_string(out);
+    }
+
+    {
+        const char *empty_alt = "![](https://example.com/x.png)\n";
+        out = apex_markdown_to_html(empty_alt, strlen(empty_alt), &opts);
+        assert_contains(out, "HYPERLINK", "Empty-alt remote image is still a link");
+        assert_contains(out, "image", "Empty-alt remote image uses image label");
+        apex_free_string(out);
+    }
+
+    /* Local JPEG embeds without embed_images */
+    opts.embed_images = false;
+    opts.base_directory = "tests/fixtures/images";
+    {
+        const char *local = "![Local](img/app-pass-1-profile-menu.jpg)\n";
+        out = apex_markdown_to_html(local, strlen(local), &opts);
+        assert_contains(out, "\\pict", "Local JPEG embeds as RTF pict");
+        assert_contains(out, "jpegblip", "Local JPEG uses jpegblip");
+        test_result(out != NULL && strstr(out, "HYPERLINK") == NULL,
+                    "Embedded local image is not a hyperlink fallback");
+        apex_free_string(out);
+    }
+    opts.base_directory = NULL;
+
+    bool had_failures = suite_end(suite_failures);
+    print_suite_title("RTF Output Tests", had_failures, false);
+}
+
 /**
  * Test header ID generation
  */
@@ -817,6 +1159,186 @@ void test_indices(void) {
     const char *textindex_explicit = "This uses [key combinations]{^}.";
     html = apex_markdown_to_html(textindex_explicit, strlen(textindex_explicit), &opts);
     assert_contains(html, "class=\"index\"", "TextIndex explicit term generates marker");
+    assert_contains(html, "key combinations", "TextIndex explicit term keeps visible text");
+    assert_not_contains(html, "[key combinations]", "TextIndex explicit term strips square brackets");
+    assert_contains(html, "key combinations <a class=\"index-return\"", "TextIndex index lists explicit term");
+    apex_free_string(html);
+
+    /* Bare {^} indexes only the preceding word; [phrase]{^} is for multi-word terms */
+    const char *textindex_word =
+        "Most mechanical keyboard firmware{^} supports the use of [key combinations]{^}.";
+    html = apex_markdown_to_html(textindex_word, strlen(textindex_word), &opts);
+    assert_contains(html, "firmware<span class=\"index\"", "TextIndex bare {^} leaves preceding word");
+    assert_not_contains(html, "Most mechanical keyboard firmware <a", "TextIndex bare {^} indexes word only, not whole phrase");
+    assert_contains(html, "firmware <a class=\"index-return\"", "TextIndex bare {^} index entry is firmware");
+    assert_not_contains(html, "[key combinations]", "TextIndex phrase form strips brackets in sentence");
+    assert_contains(html, "of key combinations<span class=\"index\"", "TextIndex phrase form keeps unbracketed text");
+    apex_free_string(html);
+
+    /* Quoted heading override / standalone mark (TextIndex Fig. 2) */
+    const char *textindex_quoted =
+        "This is a standalone mark: {^\"foo bar\"} and this one has an overridden [heading]{^\"foo baz\"}.";
+    html = apex_markdown_to_html(textindex_quoted, strlen(textindex_quoted), &opts);
+    assert_not_contains(html, "{^", "TextIndex quoted marks are consumed (not left for superscript)");
+    assert_not_contains(html, "{<sup>", "TextIndex quoted marks are not turned into superscript");
+    assert_contains(html, "standalone mark: <span class=\"index\"", "TextIndex standalone quoted mark leaves only index span");
+    assert_contains(html, "overridden heading<span class=\"index\"", "TextIndex override keeps visible heading without brackets");
+    assert_not_contains(html, "[heading]", "TextIndex override strips square brackets");
+    assert_contains(html, "foo bar <a class=\"index-return\"", "TextIndex standalone quoted mark indexes foo bar");
+    assert_contains(html, "foo baz <a class=\"index-return\"", "TextIndex override indexes quoted term not visible heading");
+    assert_not_contains(html, "heading <a class=\"index-return\"", "TextIndex override does not index visible heading text");
+    apex_free_string(html);
+
+    /* TextIndex Fig. 4-5: underscore emphasis and * / ** wildcards */
+    const char *textindex_emph =
+        "This entry will be _emphasised_{^} in the index. "
+        "This expanded entry won't be _emphasised_{^\"* (nope)\"}.";
+    html = apex_markdown_to_html(textindex_emph, strlen(textindex_emph), &opts);
+    assert_contains(html, "<em>emphasised</em><span class=\"index\"",
+                    "TextIndex emphasised heading keeps emphasis in body");
+    assert_contains(html, "<em>emphasised</em> <a class=\"index-return\"",
+                    "TextIndex emphasised heading is emphasised in index");
+    assert_not_contains(html, "_emphasised_",
+                        "TextIndex emphasised heading does not keep raw underscores in index");
+    assert_contains(html, "emphasised (nope) <a class=\"index-return\"",
+                    "TextIndex * wildcard expands preceding without emphasis");
+    assert_not_contains(html, "* (nope)",
+                        "TextIndex * wildcard is not left literal in index");
+    apex_free_string(html);
+
+    const char *textindex_emph_strip = "This entry won't be _emphasised_{^*}.";
+    html = apex_markdown_to_html(textindex_emph_strip, strlen(textindex_emph_strip), &opts);
+    assert_contains(html, "emphasised <a class=\"index-return\"",
+                    "TextIndex {^*} strips emphasis via wildcard");
+    assert_not_contains(html, "<em>emphasised</em> <a class=\"index-return\"",
+                        "TextIndex {^*} index entry is not emphasised");
+    assert_not_contains(html, "_emphasised_",
+                        "TextIndex {^*} does not keep raw underscores in index");
+    apex_free_string(html);
+
+    const char *textindex_emph_lower = "Introducing _Widget_{^\"**\"}.";
+    html = apex_markdown_to_html(textindex_emph_lower, strlen(textindex_emph_lower), &opts);
+    assert_contains(html, "widget <a class=\"index-return\"",
+                    "TextIndex ** wildcard lowercases stripped preceding");
+    apex_free_string(html);
+
+    /* TextIndex Fig. 6: prefix wildcards — same heading merges locators */
+    const char *textindex_prefix =
+        "Sir Winston Leonard Spencer Churchill{^\"*, Sir Winston Leonard Spencer\"} "
+        "was Prime Minister from 1940 to 1945.\n\n"
+        "Churchill{^*^} was born on 30 November 1874.";
+    html = apex_markdown_to_html(textindex_prefix, strlen(textindex_prefix), &opts);
+    assert_not_contains(html, "Churchill^",
+                        "TextIndex *^ is not expanded as a plain * wildcard");
+    assert_contains(html, "href=\"#idxref-0\"", "TextIndex merged entry includes first locator");
+    assert_contains(html, "href=\"#idxref-1\"", "TextIndex merged entry includes second locator");
+    {
+        int heading_hits = 0;
+        for (const char *p = html; (p = strstr(p, "Churchill, Sir Winston Leonard Spencer <a class=\"index-return\"")) != NULL; p++) {
+            heading_hits++;
+        }
+        test_result(heading_hits == 1, "TextIndex *^ merges into one index entry with both locators");
+    }
+    apex_free_string(html);
+
+    /* Duplicate mmark marks also merge locators */
+    const char *mmark_dup = "Alpha (!Alpha) here.\n\nMore about Alpha (!Alpha) there.";
+    html = apex_markdown_to_html(mmark_dup, strlen(mmark_dup), &opts);
+    assert_contains(html, "href=\"#idxref-0\"", "mmark merged entry has first locator");
+    assert_contains(html, "href=\"#idxref-1\"", "mmark merged entry has second locator");
+    {
+        int hits = 0;
+        for (const char *p = html; (p = strstr(p, "Alpha <a class=\"index-return\"")) != NULL; p++) {
+            hits++;
+        }
+        test_result(hits == 1, "mmark duplicate marks merge into one entry");
+    }
+    apex_free_string(html);
+
+    /* TextIndex Fig. 11-12: see / see-also cross-references */
+    const char *textindex_see =
+        "This function can be [dangerous]{^\"destructive operation\"|safety>\"of functions\"}.";
+    html = apex_markdown_to_html(textindex_see, strlen(textindex_see), &opts);
+    assert_contains(html, "be dangerous", "TextIndex see-type keeps visible bracketed text");
+    assert_not_contains(html, "[dangerous]", "TextIndex see-type strips brackets");
+    assert_contains(html, "destructive operation", "TextIndex see-type indexes overridden heading");
+    assert_contains(html, "<em>See</em>", "TextIndex see-type renders See in italics");
+    assert_contains(html, "safety: of functions", "TextIndex see-type shows hierarchical path with colon");
+    assert_not_contains(html, "href=\"#idxref-", "TextIndex see-type does not record a locator");
+    apex_free_string(html);
+
+    const char *textindex_see_also =
+        "Even typing on a keyboard can be surprisingly risky{^\"risk\"|ergonomics;+safety}.";
+    html = apex_markdown_to_html(textindex_see_also, strlen(textindex_see_also), &opts);
+    assert_contains(html, "<em>See</em>", "TextIndex mixed xref renders See");
+    assert_contains(html, "ergonomics", "TextIndex mixed xref includes see target");
+    assert_contains(html, "<em>See also</em>", "TextIndex mixed xref renders See also");
+    assert_contains(html, "safety", "TextIndex mixed xref includes also target");
+    assert_not_contains(html, "href=\"#idxref-", "TextIndex see-type in mark suppresses locator");
+    apex_free_string(html);
+
+    const char *textindex_also_only =
+        "A mention of risk{^\"risk\"|+safety} alone.";
+    html = apex_markdown_to_html(textindex_also_only, strlen(textindex_also_only), &opts);
+    assert_contains(html, "<em>See also</em>", "TextIndex also-only renders See also");
+    assert_contains(html, "href=\"#idxref-", "TextIndex also-only keeps locator");
+    assert_not_contains(html, "<em>See</em> safety", "TextIndex also-only is not a see-type");
+    apex_free_string(html);
+
+    /* TextIndex Fig. 13: aliases */
+    const char *textindex_alias =
+        "The various [operating systems]{^\"Apple (company)\">\"OS platforms\"#apple} "
+        "on Apple devices share a common heritage.\n\n"
+        "The majority of Apple devices are iPhones{^\"iPhone\"|+#apple}, by a large margin.";
+    html = apex_markdown_to_html(textindex_alias, strlen(textindex_alias), &opts);
+    assert_contains(html, "operating systems<span class=\"index\"",
+                    "TextIndex alias definition keeps visible text");
+    assert_contains(html, "Apple (company)", "TextIndex alias definition indexes parent heading");
+    assert_contains(html, "OS platforms", "TextIndex alias definition indexes nested heading");
+    assert_contains(html, "iPhone", "TextIndex alias use indexes iPhone");
+    assert_contains(html, "<em>See also</em>", "TextIndex alias use expands as see-also");
+    assert_contains(html, "Apple (company): OS platforms",
+                    "TextIndex #apple expands to full path in see-also");
+    assert_not_contains(html, "#apple", "TextIndex alias name is not left literal");
+    apex_free_string(html);
+
+    /* TextIndex Fig. 14: unreferenced aliases */
+    const char *textindex_unref_alias =
+        "{^\"indeterminacy principle (Heisenberg, Werner Karl)\"##q-uncert} "
+        "A key component of the Enterprise's transporter system is the "
+        "Heisenberg compensator{^|#q-uncert}.";
+    html = apex_markdown_to_html(textindex_unref_alias, strlen(textindex_unref_alias), &opts);
+    assert_contains(html, "compensator", "TextIndex unref alias use keeps preceding word");
+    assert_contains(html, "<em>See</em>", "TextIndex unref alias used as see-reference");
+    assert_contains(html, "indeterminacy principle (Heisenberg, Werner Karl)",
+                    "TextIndex ## alias expands in see target");
+    assert_not_contains(html, "#q-uncert", "TextIndex ## alias name is not left literal");
+    assert_not_contains(html, "indeterminacy principle (Heisenberg, Werner Karl) <a class=\"index-return\"",
+                        "TextIndex ## alias does not create a locator for the definition");
+    apex_free_string(html);
+
+    /* TextIndex Fig. 16: disable/enable processing with {^-} / {^+} */
+    const char *textindex_toggle =
+        "{^-} This index mark won't be processed: foo{^} {^+} after{^}.";
+    html = apex_markdown_to_html(textindex_toggle, strlen(textindex_toggle), &opts);
+    assert_contains(html, "foo{^}", "TextIndex {^-} leaves marks untouched while disabled");
+    assert_contains(html, "after<span class=\"index\"", "TextIndex {^+} re-enables processing");
+    assert_contains(html, "after <a class=\"index-return\"", "TextIndex mark after {^+} is indexed");
+    assert_not_contains(html, "foo <a class=\"index-return\"", "TextIndex mark inside {^-} region is not indexed");
+    assert_not_contains(html, "{^-}", "TextIndex {^-} toggle mark is consumed when it disables");
+    assert_not_contains(html, "{^+}", "TextIndex {^+} toggle mark is consumed when it enables");
+    assert_not_contains(html, "> - <a class=\"index-return\"", "TextIndex {^-} is not indexed as a heading");
+    assert_not_contains(html, "> + <a class=\"index-return\"", "TextIndex {^+} is not indexed as a heading");
+    apex_free_string(html);
+
+    const char *textindex_toggle_redundant =
+        "{^-} hidden{^} {^-} still{^} {^+} shown{^} {^+} trailing.";
+    html = apex_markdown_to_html(textindex_toggle_redundant, strlen(textindex_toggle_redundant), &opts);
+    assert_contains(html, "hidden{^}", "TextIndex redundant region keeps first disabled mark literal");
+    assert_contains(html, "{^-}", "TextIndex redundant {^-} stays when already disabled");
+    assert_contains(html, "still{^}", "TextIndex marks stay literal until {^+}");
+    assert_contains(html, "shown<span class=\"index\"", "TextIndex processing resumes after effective {^+}");
+    assert_contains(html, "{^+}", "TextIndex redundant {^+} stays when already enabled");
     apex_free_string(html);
 
     /* Test Leanpub index syntax */
@@ -963,6 +1485,36 @@ void test_indices(void) {
     assert_contains(html, "href=\"#idxref-", "Index entries link to anchors");
     apex_free_string(html);
 
+    /* Concordance files: auto-mark terms from TSV before TextIndex processing */
+    {
+        apex_options opts_conc = apex_options_default();
+        opts_conc.mode = APEX_MODE_UNIFIED;
+        opts_conc.enable_indices = true;
+        opts_conc.enable_textindex_syntax = true;
+        opts_conc.base_directory = "tests";
+        const char *conc_files[] = {"test_concordance.tsv", NULL};
+        opts_conc.concordance_files = (char **)conc_files;
+
+        const char *conc_doc =
+            "A widget and another Widget appear. The MacBook is nice. Configuration helps.";
+        html = apex_markdown_to_html(conc_doc, strlen(conc_doc), &opts_conc);
+        assert_contains(html, "gadget <a class=\"index-return\"",
+                        "Concordance maps widget to gadget heading");
+        assert_contains(html, "Apple laptop <a class=\"index-return\"",
+                        "Concordance case-sensitive MacBook uses quoted heading");
+        assert_contains(html, "See", "Concordance see-ref from column 2 is rendered");
+        assert_contains(html, "firmware", "Concordance see target firmware appears");
+        /* Existing marks must not be rematched */
+        const char *conc_existing = "Already marked widget{^custom}.";
+        apex_free_string(html);
+        html = apex_markdown_to_html(conc_existing, strlen(conc_existing), &opts_conc);
+        assert_contains(html, "custom <a class=\"index-return\"",
+                        "Concordance skips text already inside an index mark");
+        assert_not_contains(html, "gadget <a class=\"index-return\"",
+                            "Concordance does not rematch marked widget as gadget");
+        apex_free_string(html);
+    }
+
     bool had_failures = suite_end(suite_failures);
     print_suite_title("Index Tests", had_failures, false);
 }
@@ -1054,6 +1606,20 @@ void test_citations(void) {
     assert_contains(html, "mailto:", "Email autolinking still works");
     apex_free_string(html);
 
+    /* Test markdown mailto links with @ and query params are not re-autolinked */
+    const char *mailto_markdown =
+        "If you have purchased a permanent unlock or lifetime license through the Mac App Store, please "
+        "[email the developer](mailto:marked@brettterpstra.com?subject=Marked%20License%20Crossgrade&body=Please%20include%20your%20UUID%20%28Help-%3ECopy%20UUID%20in%20Marked%29%20in%20this%20email%20for%20receipt%20verification.) "
+        "to request a free lifetime Paddle license.";
+    html = apex_markdown_to_html(mailto_markdown, strlen(mailto_markdown), &opts_autolink);
+    assert_contains(
+        html,
+        "<a href=\"mailto:marked@brettterpstra.com?subject=Marked%20License%20Crossgrade&amp;body=Please%20include%20your%20UUID%20%28Help-%3ECopy%20UUID%20in%20Marked%29%20in%20this%20email%20for%20receipt%20verification.\">email the developer</a>",
+        "Markdown mailto link with query params renders as a single clean anchor");
+    assert_not_contains(html, "[email the", "Markdown link syntax is not leaked into output");
+    assert_not_contains(html, "mailto:developer](", "No nested autolink corruption in mailto link");
+    apex_free_string(html);
+
     /* Test that autolink does not run inside indented code blocks */
     const char *indented_code =
         "    x-marked://extract?url=https://example.com\n";
@@ -1309,7 +1875,7 @@ void test_combine_gitbook_like(void) {
     }
 
     /* Process intro with includes (none here, just sanity) */
-    char *intro_md = apex_process_includes(intro_src, base_dir, NULL, 0);
+    char *intro_md = apex_process_includes(intro_src, base_dir, NULL, 0, NULL, NULL, NULL);
     char *intro_html = apex_markdown_to_html(intro_md ? intro_md : intro_src,
                                              strlen(intro_md ? intro_md : intro_src),
                                              &opts);
@@ -1342,7 +1908,7 @@ void test_combine_gitbook_like(void) {
         return;
     }
 
-    char *chapter_md = apex_process_includes(chapter_src, base_dir, NULL, 0);
+    char *chapter_md = apex_process_includes(chapter_src, base_dir, NULL, 0, NULL, NULL, NULL);
     const char *chapter_final = chapter_md ? chapter_md : chapter_src;
 
     /* Combined Markdown should contain both Chapter 1 and Section 1.1 headings */