apex-ruby 1.0.18 → 1.0.20

data/ext/apex_ext/apex_src/src/apex.c

@@ -19,6 +19,12 @@
 #include "extensions/math.h"
 #include "extensions/critic.h"
 #include "extensions/callouts.h"
+#include "extensions/raw_content.h"
+#include "extensions/code_fence_attrs.h"
+#include "extensions/quarto_diagrams.h"
+#include "extensions/quarto_shortcodes.h"
+#include "extensions/quarto_polish.h"
+#include "extensions/quarto_lists.h"
 #include "extensions/includes.h"
 #include "extensions/toc.h"
 #include "extensions/abbreviations.h"
@@ -36,6 +42,7 @@
 #include "extensions/sup_sub.h"
 #include "extensions/header_ids.h"
 #include "extensions/relaxed_tables.h"
+#include "extensions/grid_tables.h"
 #include "extensions/citations.h"
 #include "extensions/index.h"
 #include "extensions/fenced_divs.h"
@@ -45,6 +52,7 @@
 #include "apex/ast_markdown.h"
 #include "apex/ast_terminal.h"
 #include "apex/ast_man.h"
+#include "apex/ast_rtf.h"
 #include "filters_ast.h"
 
 /* Custom renderer */
@@ -663,6 +671,49 @@ static char *apex_embed_images(const char *html, const apex_options *options, co
     return output;
 }
 
+/**
+ * Track HTML tag / quoted-attribute state while scanning source text.
+ * State reflects characters already consumed, matching the previous
+ * "rescan from document start" semantics without the O(n^2) cost.
+ */
+static void apex_autolink_html_consume(char c, bool *in_html_tag,
+                                       bool *html_quote_active,
+                                       char *html_quote_char) {
+    if (!*in_html_tag) {
+        if (c == '<') {
+            *in_html_tag = true;
+            *html_quote_active = false;
+            *html_quote_char = '\0';
+        }
+        return;
+    }
+
+    if (*html_quote_active) {
+        if (c == *html_quote_char) {
+            *html_quote_active = false;
+            *html_quote_char = '\0';
+        }
+        return;
+    }
+
+    if (c == '"' || c == '\'') {
+        *html_quote_active = true;
+        *html_quote_char = c;
+    } else if (c == '>') {
+        *in_html_tag = false;
+    }
+}
+
+static void apex_autolink_html_consume_range(const char *s, size_t n,
+                                            bool *in_html_tag,
+                                            bool *html_quote_active,
+                                            char *html_quote_char) {
+    for (size_t i = 0; i < n; i++) {
+        apex_autolink_html_consume(s[i], in_html_tag, html_quote_active,
+                                   html_quote_char);
+    }
+}
+
 /**
  * Preprocess angle-bracket autolinks (<http://...>) into explicit links
  * and convert bare URLs/emails to explicit links so they survive
@@ -687,6 +738,9 @@ static char *apex_preprocess_autolinks(const char *text, const apex_options *opt
     bool in_markdown_link_url = false;  /* Track if we're inside [text](url) URL part */
     int bracket_count = 0;  /* Count unmatched [ for markdown links */
     int paren_count = 0;  /* Count unmatched ( inside markdown link URLs */
+    bool in_html_tag = false;
+    bool html_quote_active = false;
+    char html_quote_char = '\0';
 
     while (*r) {
         const char *loop_start = r;
@@ -694,16 +748,26 @@ static char *apex_preprocess_autolinks(const char *text, const apex_options *opt
         /* Handle Liquid tags: copy {% ... %} without processing */
         if (!in_liquid && *r == '{' && r[1] == '%') {
             in_liquid = true;
+            apex_autolink_html_consume(*r, &in_html_tag, &html_quote_active,
+                                       &html_quote_char);
             *w++ = *r++;
+            apex_autolink_html_consume(*r, &in_html_tag, &html_quote_active,
+                                       &html_quote_char);
             *w++ = *r++;
             continue;
         }
         if (in_liquid) {
             if (*r == '%' && r[1] == '}') {
+                apex_autolink_html_consume(*r, &in_html_tag, &html_quote_active,
+                                           &html_quote_char);
                 *w++ = *r++;
+                apex_autolink_html_consume(*r, &in_html_tag, &html_quote_active,
+                                           &html_quote_char);
                 *w++ = *r++;
                 in_liquid = false;
             } else {
+                apex_autolink_html_consume(*r, &in_html_tag, &html_quote_active,
+                                           &html_quote_char);
                 *w++ = *r++;
             }
             continue;
@@ -733,6 +797,9 @@ static char *apex_preprocess_autolinks(const char *text, const apex_options *opt
                 }
                 memcpy(w, r, line_len);
                 w += line_len;
+                apex_autolink_html_consume_range(r, line_len, &in_html_tag,
+                                                &html_quote_active,
+                                                &html_quote_char);
                 r = line_end;
                 continue;
             }
@@ -762,6 +829,9 @@ static char *apex_preprocess_autolinks(const char *text, const apex_options *opt
                     }
                     memcpy(w, r, line_len);
                     w += line_len;
+                    apex_autolink_html_consume_range(r, line_len, &in_html_tag,
+                                                    &html_quote_active,
+                                                    &html_quote_char);
                     r = line_end;
                     continue;
                 }
@@ -788,17 +858,23 @@ static char *apex_preprocess_autolinks(const char *text, const apex_options *opt
                 }
                 /* Copy the backticks */
                 for (int i = 0; i < backtick_count; i++) {
+                    apex_autolink_html_consume(*r, &in_html_tag, &html_quote_active,
+                                               &html_quote_char);
                     *w++ = *r++;
                 }
                 continue;
             } else if (backtick_count == 1) {
                 /* Inline code span - toggle state and copy the backtick */
                 in_inline_code = !in_inline_code;
+                apex_autolink_html_consume(*r, &in_html_tag, &html_quote_active,
+                                           &html_quote_char);
                 *w++ = *r++;
                 continue;
             } else {
                 /* Multiple backticks but less than 3 - copy them as-is (shouldn't happen in valid markdown) */
                 for (int i = 0; i < backtick_count; i++) {
+                    apex_autolink_html_consume(*r, &in_html_tag, &html_quote_active,
+                                               &html_quote_char);
                     *w++ = *r++;
                 }
                 continue;
@@ -807,6 +883,17 @@ static char *apex_preprocess_autolinks(const char *text, const apex_options *opt
 
         /* Skip processing inside code blocks or inline code */
         if (in_code_block || in_inline_code) {
+            apex_autolink_html_consume(*r, &in_html_tag, &html_quote_active,
+                                       &html_quote_char);
+            *w++ = *r++;
+            continue;
+        }
+
+        /* Skip any autolink processing while inside an HTML tag (<...>),
+         * including quoted attributes. */
+        if (in_html_tag) {
+            apex_autolink_html_consume(*r, &in_html_tag, &html_quote_active,
+                                       &html_quote_char);
             *w++ = *r++;
             continue;
         }
@@ -820,7 +907,11 @@ static char *apex_preprocess_autolinks(const char *text, const apex_options *opt
                 in_markdown_link_url = true;
                 paren_count = 1;  /* Count the opening '(' */
                 /* Copy ']' and '(' */
+                apex_autolink_html_consume(*r, &in_html_tag, &html_quote_active,
+                                           &html_quote_char);
                 *w++ = *r++; /* ']' */
+                apex_autolink_html_consume(*r, &in_html_tag, &html_quote_active,
+                                           &html_quote_char);
                 *w++ = *r++; /* '(' */
                 continue;
             }
@@ -837,95 +928,18 @@ static char *apex_preprocess_autolinks(const char *text, const apex_options *opt
             }
         }
 
-        /* Skip autolinking if we're inside a markdown link URL */
-        if (in_markdown_link_url) {
+        /* Skip autolinking while inside markdown link text [ ... ] */
+        if (bracket_count > 0 && !in_markdown_link_url) {
+            apex_autolink_html_consume(*r, &in_html_tag, &html_quote_active,
+                                       &html_quote_char);
             *w++ = *r++;
             continue;
         }
 
-        /* Check if we're inside an HTML tag attribute - if so, skip autolinking */
-        /* Look backwards for < to see if we're inside a tag */
-        bool in_html_attribute = false;
-        if (*r == 'h' || *r == 'm') {  /* Quick check: URLs start with http or mailto */
-            const char *p = r - 1;
-            const char *tag_start = NULL;
-            const char *tag_end = NULL;
-
-            /* Find nearest < or > before r */
-            while (p >= text) {
-                if (*p == '>') {
-                    tag_end = p;
-                    break;
-                } else if (*p == '<') {
-                    tag_start = p;
-                    break;
-                }
-                p--;
-            }
-
-            /* If we're inside a tag (between < and >), check if we're in an attribute */
-            if (tag_start && (!tag_end || tag_start > tag_end)) {
-                /* Look backwards from r to find the nearest = sign within this tag */
-                p = r - 1;
-                const char *equals_pos = NULL;
-                while (p > tag_start) {
-                    if (*p == '=') {
-                        equals_pos = p;
-                        break;
-                    } else if (*p == '>') {
-                        break;
-                    }
-                    p--;
-                }
-
-                if (equals_pos) {
-                    /* Check what comes after the = */
-                    const char *after_equals = equals_pos + 1;
-                    /* Skip whitespace */
-                    while (after_equals < r && isspace((unsigned char)*after_equals)) {
-                        after_equals++;
-                    }
-
-                    if (after_equals < r) {
-                        /* Check if it's a quoted attribute */
-                        if (*after_equals == '"' || *after_equals == '\'') {
-                            char quote = *after_equals;
-                            const char *value_start = after_equals + 1;
-
-                            /* If r is after the opening quote, check if we're inside */
-                            if (r >= value_start) {
-                                /* Look for the closing quote - scan forward from value_start */
-                                const char *quote_end = value_start;
-                                while (quote_end < r && *quote_end != quote && *quote_end != '\0') {
-                                    quote_end++;
-                                }
-
-                                /* If we haven't found the closing quote by the time we reach r, we're inside */
-                                if (quote_end >= r || *quote_end != quote) {
-                                    in_html_attribute = true;
-                                }
-                            }
-                        } else {
-                            /* Unquoted attribute - value is between = and next space or > */
-                            const char *value_start = after_equals;
-                            if (r > value_start) {
-                                const char *value_end = value_start;
-                                while (value_end < r && !isspace((unsigned char)*value_end) && *value_end != '>') {
-                                    value_end++;
-                                }
-                                /* If r is in this unquoted value, we're inside an attribute */
-                                if (r <= value_end) {
-                                    in_html_attribute = true;
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        if (in_html_attribute) {
-            /* Inside HTML attribute, copy as-is */
+        /* Skip autolinking if we're inside a markdown link URL */
+        if (in_markdown_link_url) {
+            apex_autolink_html_consume(*r, &in_html_tag, &html_quote_active,
+                                       &html_quote_char);
             *w++ = *r++;
             continue;
         }
@@ -953,6 +967,7 @@ static char *apex_preprocess_autolinks(const char *text, const apex_options *opt
                     *w++ = ']'; *w++ = '(';
                     memcpy(w, start, url_len); w += url_len;
                     *w++ = ')';
+                    /* Rewritten away from HTML; net tag state is unchanged. */
                     r = end + 1;
                     continue;
                 }
@@ -975,6 +990,9 @@ static char *apex_preprocess_autolinks(const char *text, const apex_options *opt
                 }
                 memcpy(w, r, comment_len);
                 w += comment_len;
+                apex_autolink_html_consume_range(r, comment_len, &in_html_tag,
+                                                &html_quote_active,
+                                                &html_quote_char);
                 r = comment_end + 3;
                 continue;
             }
@@ -984,87 +1002,7 @@ static char *apex_preprocess_autolinks(const char *text, const apex_options *opt
         bool is_url_start = false;
         bool is_email_start = false;
 
-        /* Check again if we're inside an HTML attribute before processing URLs */
-        bool in_html_attribute_url = false;
-        if (!isspace((unsigned char)*r) && (*r == 'h' || *r == 'm' || *r == '@')) {
-            const char *p = r - 1;
-            const char *tag_start = NULL;
-            const char *tag_end = NULL;
-
-            /* Find nearest < or > before r */
-            while (p >= text) {
-                if (*p == '>') {
-                    tag_end = p;
-                    break;
-                } else if (*p == '<') {
-                    tag_start = p;
-                    break;
-                }
-                p--;
-            }
-
-            /* If we're inside a tag (between < and >), check if we're in an attribute */
-            if (tag_start && (!tag_end || tag_start > tag_end)) {
-                /* Look backwards from r to find the nearest = sign within this tag */
-                p = r - 1;
-                const char *equals_pos = NULL;
-                while (p > tag_start) {
-                    if (*p == '=') {
-                        equals_pos = p;
-                        break;
-                    } else if (*p == '>') {
-                        break;
-                    }
-                    p--;
-                }
-
-                if (equals_pos) {
-                    /* Check what comes after the = */
-                    const char *after_equals = equals_pos + 1;
-                    /* Skip whitespace */
-                    while (after_equals < r && isspace((unsigned char)*after_equals)) {
-                        after_equals++;
-                    }
-
-                    if (after_equals < r) {
-                        /* Check if it's a quoted attribute */
-                        if (*after_equals == '"' || *after_equals == '\'') {
-                            char quote = *after_equals;
-                            const char *value_start = after_equals + 1;
-
-                            /* If r is after the opening quote, check if we're inside */
-                            if (r >= value_start) {
-                                /* Look for the closing quote - scan forward from value_start */
-                                const char *quote_end = value_start;
-                                while (quote_end < r && *quote_end != quote && *quote_end != '\0') {
-                                    quote_end++;
-                                }
-
-                                /* If we haven't found the closing quote by the time we reach r, we're inside */
-                                if (quote_end >= r || *quote_end != quote) {
-                                    in_html_attribute_url = true;
-                                }
-                            }
-                        } else {
-                            /* Unquoted attribute - value is between = and next space or > */
-                            const char *value_start = after_equals;
-                            if (r > value_start) {
-                                const char *value_end = value_start;
-                                while (value_end < r && !isspace((unsigned char)*value_end) && *value_end != '>') {
-                                    value_end++;
-                                }
-                                /* If r is in this unquoted value, we're inside an attribute */
-                                if (r <= value_end) {
-                                    in_html_attribute_url = true;
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        if (!isspace((unsigned char)*r) && !in_html_attribute_url) {
+        if (!isspace((unsigned char)*r)) {
             /* Check for URL protocols */
             if (strncmp(r, "http://", 7) == 0 || strncmp(r, "https://", 8) == 0 || strncmp(r, "mailto:", 7) == 0) {
                 is_url_start = true;
@@ -1090,6 +1028,30 @@ static char *apex_preprocess_autolinks(const char *text, const apex_options *opt
                     /* Require that the character immediately before @ is alphanumeric.
                      * This prevents matching @ in URLs like https://example.com/@user */
                     if (at_pos > r && isalnum((unsigned char)at_pos[-1])) {
+                        /* Ignore image-density suffixes like @2x.jpg, @3x.avif, etc. */
+                        const char *suffix = at_pos + 1;
+                        if (suffix < token_end && isdigit((unsigned char)*suffix)) {
+                            while (suffix < token_end && isdigit((unsigned char)*suffix)) {
+                                suffix++;
+                            }
+                            if (suffix < token_end && *suffix == 'x') {
+                                suffix++;
+                                if (suffix < token_end && *suffix == '.') {
+                                    suffix++;
+                                    if (suffix < token_end && isalnum((unsigned char)*suffix)) {
+                                        while (suffix < token_end && isalnum((unsigned char)*suffix)) {
+                                            suffix++;
+                                        }
+                                        if (suffix == token_end) {
+                                            /* This token is an image filename density suffix,
+                                             * not an email address. */
+                                            goto skip_email_candidate;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+
                         /* Validate that email has a TLD (at least one dot followed by alphanumeric) */
                         const char *after_at = at_pos + 1;
                         bool has_tld = false;
@@ -1113,6 +1075,7 @@ static char *apex_preprocess_autolinks(const char *text, const apex_options *opt
                 }
             }
         }
+skip_email_candidate:
 
         if (is_url_start || is_email_start) {
             const char *start = r;
@@ -1170,6 +1133,9 @@ static char *apex_preprocess_autolinks(const char *text, const apex_options *opt
                 *w++ = ']'; *w++ = '(';
                 memcpy(w, href_text, href_len); w += href_len;
                 *w++ = ')';
+                apex_autolink_html_consume_range(start, (size_t)(end - start),
+                                                &in_html_tag, &html_quote_active,
+                                                &html_quote_char);
                 r = end;
                 free(mailto_buf);
                 continue;
@@ -1177,6 +1143,8 @@ static char *apex_preprocess_autolinks(const char *text, const apex_options *opt
             free(mailto_buf);
         }
 
+        apex_autolink_html_consume(*r, &in_html_tag, &html_quote_active,
+                                   &html_quote_char);
         *w++ = *r++;
 
         /* Safety: ensure we always advance */
@@ -2207,9 +2175,13 @@ static char *apex_preprocess_table_colspans(const char *text) {
 
 /**
  * Preprocess alpha list markers (a., b., c. and A., B., C.)
- * Converts them to numbered markers (1., 2., 3.) and adds markers for post-processing
+ * Converts them to numbered markers (1., 2., 3.) and inserts an HTML comment (indented like
+ * the list items) so the HTML pass can apply list-style-type; bracket tokens are not used
+ * because the Markdown parser strips them before HTML is produced.
  */
-static char *apex_preprocess_alpha_lists(const char *text) {
+static char *apex_preprocess_alpha_lists(const char *text,
+                                         bool *inserted_synthetic_nested_alpha_break,
+                                         bool *saw_explicit_nested_alpha_break) {
     if (!text) return NULL;
 
     size_t text_len = strlen(text);
@@ -2227,6 +2199,8 @@ static char *apex_preprocess_alpha_lists(const char *text) {
     bool is_upper = false;
     int item_number = 1;
     int blank_lines_since_alpha = 0;  /* Track blank lines to detect list breaks */
+    if (inserted_synthetic_nested_alpha_break) *inserted_synthetic_nested_alpha_break = false;
+    if (saw_explicit_nested_alpha_break) *saw_explicit_nested_alpha_break = false;
 
     while (*read) {
         const char *line_start = read;
@@ -2261,6 +2235,14 @@ static char *apex_preprocess_alpha_lists(const char *text) {
         }
 
         if (is_alpha_marker) {
+            bool nested_alpha_after_item = false;
+            if (in_alpha_list && alpha_is_upper == is_upper && current_indent > alpha_list_indent) {
+                if (alpha_is_upper) {
+                    nested_alpha_after_item = (alpha_char == expected_upper);
+                } else {
+                    nested_alpha_after_item = (alpha_char == expected_lower);
+                }
+            }
             /* Check if this continues an existing alpha list */
             bool continues_list = false;
             if (in_alpha_list) {
@@ -2278,6 +2260,13 @@ static char *apex_preprocess_alpha_lists(const char *text) {
             }
 
             if (!continues_list) {
+                if (nested_alpha_after_item) {
+                    if (blank_lines_since_alpha > 0) {
+                        if (saw_explicit_nested_alpha_break) *saw_explicit_nested_alpha_break = true;
+                    } else {
+                        if (inserted_synthetic_nested_alpha_break) *inserted_synthetic_nested_alpha_break = true;
+                    }
+                }
                 /* Start new alpha list */
                 in_alpha_list = true;
                 is_upper = alpha_is_upper;
@@ -2289,8 +2278,10 @@ static char *apex_preprocess_alpha_lists(const char *text) {
                 } else {
                     expected_lower = alpha_char;
                 }
-                /* Add marker paragraph before the list (will be rendered as <p data-apex-alpha-list="lower|upper"></p>) */
-                int needed = snprintf(write, remaining, "[apex-alpha-list:%s]\n\n", alpha_is_upper ? "upper" : "lower");
+                /* HTML comment + indent: bracket markers are stripped by the parser; comments survive in unsafe HTML
+                 * and must be indented like the following list items to stay inside a parent <li>. */
+                int needed = snprintf(write, remaining, "%.*s<!-- apex-alpha-list-%s -->\n\n",
+                                      (int)(p - line_start), line_start, alpha_is_upper ? "upper" : "lower");
                 if (needed > 0 && needed < (int)remaining) {
                     write += needed;
                     remaining -= needed;
@@ -2407,7 +2398,9 @@ static char *apex_preprocess_alpha_lists(const char *text) {
  * Insert a blank line before indented ordered sublists that directly follow
  * a parent list item line, so they parse as nested <ol> blocks.
  */
-static char *apex_preprocess_nested_ordered_sublists(const char *text) {
+static char *apex_preprocess_nested_ordered_sublists(const char *text,
+                                                     bool *inserted_synthetic_break,
+                                                     bool *saw_explicit_break) {
     if (!text) return NULL;
 
     size_t text_len = strlen(text);
@@ -2423,6 +2416,9 @@ static char *apex_preprocess_nested_ordered_sublists(const char *text) {
     bool prev_line_was_list_item = false;
     size_t prev_line_indent = 0;
 
+    if (inserted_synthetic_break) *inserted_synthetic_break = false;
+    if (saw_explicit_break) *saw_explicit_break = false;
+
     while (*read) {
         const char *line_start = read;
         const char *line_end = strchr(read, '\n');
@@ -2454,8 +2450,14 @@ static char *apex_preprocess_nested_ordered_sublists(const char *text) {
             }
         }
 
-        if (!prev_line_was_blank && prev_line_was_list_item &&
-            current_line_ordered_marker && current_indent > prev_line_indent) {
+        bool nested_ordered_after_item = (prev_line_was_list_item &&
+                                          current_line_ordered_marker &&
+                                          current_indent > prev_line_indent);
+        if (nested_ordered_after_item && prev_line_was_blank) {
+            if (saw_explicit_break) *saw_explicit_break = true;
+        }
+
+        if (!prev_line_was_blank && nested_ordered_after_item) {
             if (remaining < 1) {
                 size_t used = (size_t)(write - output);
                 size_t new_capacity = output_capacity * 2 + 64;
@@ -2471,6 +2473,7 @@ static char *apex_preprocess_nested_ordered_sublists(const char *text) {
             }
             *write++ = '\n';
             remaining--;
+            if (inserted_synthetic_break) *inserted_synthetic_break = true;
             prev_line_was_blank = true;
         }
 
@@ -2507,6 +2510,35 @@ static char *apex_preprocess_nested_ordered_sublists(const char *text) {
     return output;
 }
 
+/* Force tight rendering for lists synthesized from nested ordered sublist fixes. */
+static void apex_tighten_nested_ordered_list_items(cmark_node *node) {
+    if (!node) return;
+
+    for (cmark_node *child = cmark_node_first_child(node); child; ) {
+        cmark_node *next = cmark_node_next(child);
+        apex_tighten_nested_ordered_list_items(child);
+        child = next;
+    }
+
+    if (cmark_node_get_type(node) != CMARK_NODE_LIST) return;
+
+    bool has_para_then_sublist_item = false;
+    for (cmark_node *item = cmark_node_first_child(node); item; item = cmark_node_next(item)) {
+        if (cmark_node_get_type(item) != CMARK_NODE_ITEM) continue;
+        cmark_node *first = cmark_node_first_child(item);
+        cmark_node *second = first ? cmark_node_next(first) : NULL;
+        if (first && second &&
+            cmark_node_get_type(first) == CMARK_NODE_PARAGRAPH &&
+            cmark_node_get_type(second) == CMARK_NODE_LIST) {
+            has_para_then_sublist_item = true;
+            break;
+        }
+    }
+    if (has_para_then_sublist_item) {
+        cmark_node_set_list_tight(node, 1);
+    }
+}
+
 /**
  * Post-process HTML to add style attributes to alpha lists
  * Finds HTML comments like <!-- apex-alpha-list-lower --> or <!-- apex-alpha-list-upper -->
@@ -2516,9 +2548,10 @@ static char *apex_preprocess_nested_ordered_sublists(const char *text) {
 static char *apex_postprocess_alpha_lists_html(const char *html) {
     if (!html) return NULL;
 
-    /* Early exit: check if alpha list markers exist before processing */
-    if (strstr(html, "[apex-alpha-list:") == NULL) {
-        return NULL;  /* No alpha list markers, skip processing */
+    /* Early exit: bracket markers (legacy) or HTML comments from preprocessor */
+    if (strstr(html, "[apex-alpha-list:") == NULL &&
+        strstr(html, "<!-- apex-alpha-list-") == NULL) {
+        return NULL;
     }
 
     size_t html_len = strlen(html);
@@ -2546,9 +2579,78 @@ static char *apex_postprocess_alpha_lists_html(const char *html) {
         } \
     } while(0)
 
-    /* Single-pass optimization: look for markers as we go */
-    const char *read_start = read;  /* Track where we started reading from */
+    /* Single-pass: HTML comments (current), <p>[apex-alpha-list:…]</p> (legacy), or stray brackets */
+    const char *read_start = read;
+    static const char alpha_comment_lower[] = "<!-- apex-alpha-list-lower -->";
+    static const char alpha_comment_upper[] = "<!-- apex-alpha-list-upper -->";
+    const size_t alpha_comment_lower_len = sizeof(alpha_comment_lower) - 1;
+    const size_t alpha_comment_upper_len = sizeof(alpha_comment_upper) - 1;
+
     while (*read) {
+        /* Strip HTML comment markers and style the following <ol> (not copied to output). */
+        bool comment_upper = false;
+        size_t comment_len = 0;
+        if ((size_t)(html + html_len - read) >= alpha_comment_lower_len &&
+            strncmp(read, alpha_comment_lower, alpha_comment_lower_len) == 0) {
+            comment_len = alpha_comment_lower_len;
+        } else if ((size_t)(html + html_len - read) >= alpha_comment_upper_len &&
+                   strncmp(read, alpha_comment_upper, alpha_comment_upper_len) == 0) {
+            comment_upper = true;
+            comment_len = alpha_comment_upper_len;
+        }
+        if (comment_len > 0) {
+            size_t copy_len = (size_t)(read - read_start);
+            ENSURE_SPACE(copy_len);
+            if (copy_len > 0) {
+                memcpy(write, read_start, copy_len);
+                write += copy_len;
+                remaining -= copy_len;
+            }
+            read += comment_len;
+            read_start = read;
+            while (*read == ' ' || *read == '\t' || *read == '\n' || *read == '\r') {
+                read++;
+            }
+            read_start = read;
+            if (read[0] == '<' && read[1] == 'o' && read[2] == 'l' &&
+                (read[3] == '>' || read[3] == ' ' || read[3] == '\t' || read[3] == '\n')) {
+                const char *ol_start = read;
+                const char *tag_end = strchr(ol_start, '>');
+
+                if (tag_end) {
+                    bool has_style = false;
+                    for (const char *p = ol_start; p < tag_end; p++) {
+                        if (strncmp(p, "style=", 6) == 0) {
+                            has_style = true;
+                            break;
+                        }
+                    }
+                    size_t tag_len = (size_t)(tag_end - ol_start); /* before '>' */
+                    ENSURE_SPACE(tag_len + 50);
+                    memcpy(write, ol_start, tag_len);
+                    write += tag_len;
+                    remaining -= tag_len;
+                    if (!has_style) {
+                        const char *style = comment_upper
+                            ? " style=\"list-style-type: upper-alpha\">"
+                            : " style=\"list-style-type: lower-alpha\">";
+                        size_t style_len = strlen(style);
+                        memcpy(write, style, style_len);
+                        write += style_len;
+                        remaining -= style_len;
+                    } else {
+                        ENSURE_SPACE(1);
+                        *write++ = '>';
+                        remaining--;
+                    }
+                    read = tag_end + 1;
+                    read_start = read;
+                    continue;
+                }
+            }
+            continue;
+        }
+
         /* Drop any stray raw markers that did not form a standalone paragraph. */
         if (strncmp(read, "[apex-alpha-list:lower]", 23) == 0 ||
             strncmp(read, "[apex-alpha-list:upper]", 23) == 0) {
@@ -2823,9 +2925,22 @@ apex_options apex_options_default(void) {
     opts.enable_task_lists = true;
     opts.enable_attributes = true;
     opts.enable_callouts = true;
+    opts.enable_py_callouts = false;
+    opts.enable_quarto_callouts = false;
+    opts.enable_quarto_extensions = false;
+    opts.enable_quarto_raw = false;
+    opts.enable_quarto_example_lists = false;
+    opts.enable_quarto_line_blocks = false;
+    opts.enable_quarto_roman_lists = false;
+    opts.enable_quarto_code_attrs = false;
+    opts.enable_quarto_diagrams = false;
+    opts.enable_quarto_shortcodes = false;
+    opts.enable_quarto_strict_lists = false;
+    opts.enable_quarto_xrefs = false;
     opts.enable_marked_extensions = true;
     opts.enable_divs = true;  /* Enabled by default in unified mode */
     opts.enable_spans = true;  /* Enabled by default in unified mode */
+    opts.enable_grid_tables = false;  /* Disabled by default - enable with --grid-tables */
 
     /* Critic markup mode (0=accept, 1=reject, 2=markup) */
     opts.critic_mode = 2;  /* Default: show markup */
@@ -2861,6 +2976,10 @@ apex_options apex_options_default(void) {
     opts.generate_header_ids = true;
     opts.header_anchors = false;  /* Use header IDs by default, not anchor tags */
     opts.id_format = 0;  /* GFM format (with dashes) */
+    opts.toc_min = 1;
+    opts.toc_max = 3;
+    opts.toc_entries_out = NULL;
+    opts.toc_entries_count_out = NULL;
 
     /* Table options */
     opts.relaxed_tables = true;  /* Default: enabled in unified mode (can be disabled with --no-relaxed-tables) */
@@ -2903,6 +3022,7 @@ apex_options apex_options_default(void) {
     opts.enable_leanpub_index_syntax = false;
     opts.suppress_index = false;
     opts.group_index_by_letter = true;
+    opts.concordance_files = NULL;
 
     /* Wiki link options */
     opts.wikilink_space = 0;  /* Default: dash (0=dash, 1=none, 2=underscore, 3=space) */
@@ -2960,6 +3080,7 @@ apex_options apex_options_default(void) {
     opts.theme_name = NULL;
     opts.terminal_width = 0;
     opts.paginate = false;
+    opts.paginate_symbols = false;
     opts.terminal_inline_images = true;
     opts.terminal_image_width = 50;
 
@@ -2986,6 +3107,8 @@ apex_options apex_options_for_mode(apex_mode_t mode) {
             opts.enable_task_lists = false;
             opts.enable_attributes = false;
             opts.enable_callouts = false;
+            opts.enable_py_callouts = false;
+            opts.enable_quarto_callouts = false;
             opts.enable_marked_extensions = false;
             opts.enable_divs = false;
             opts.enable_spans = false;
@@ -3021,6 +3144,8 @@ apex_options apex_options_for_mode(apex_mode_t mode) {
             opts.enable_wiki_links = false;
             opts.enable_attributes = false;
             opts.enable_callouts = false;
+            opts.enable_py_callouts = false;
+            opts.enable_quarto_callouts = false;
             opts.enable_marked_extensions = false;
             opts.enable_divs = false;
             opts.enable_spans = false;
@@ -3058,6 +3183,8 @@ apex_options apex_options_for_mode(apex_mode_t mode) {
             opts.enable_task_lists = false;
             opts.enable_attributes = false;
             opts.enable_callouts = false;
+            opts.enable_py_callouts = false;
+            opts.enable_quarto_callouts = false;
             opts.enable_marked_extensions = false;
             opts.enable_divs = false;
             opts.enable_spans = false;
@@ -3092,6 +3219,8 @@ apex_options apex_options_for_mode(apex_mode_t mode) {
             opts.enable_task_lists = false;
             opts.enable_attributes = true;
             opts.enable_callouts = false;
+            opts.enable_py_callouts = false;
+            opts.enable_quarto_callouts = false;
             /* Enable Marked-style extensions (including TOC) so that
              * Kramdown documents can use <!--TOC--> and {:toc} syntax
              * for table-of-contents generation. */
@@ -3133,16 +3262,142 @@ apex_options apex_options_for_mode(apex_mode_t mode) {
             opts.enable_mmark_index_syntax = true;  /* Unified: mmark index syntax */
             opts.enable_textindex_syntax = true;  /* Unified: TextIndex syntax enabled */
             opts.enable_leanpub_index_syntax = true;  /* Unified: Leanpub index syntax enabled */
+            opts.enable_py_callouts = false;  /* Unified default: off unless explicitly enabled */
+            opts.enable_quarto_callouts = false;  /* Unified default: off unless explicitly enabled */
             opts.enable_divs = true;  /* Unified: Pandoc fenced divs enabled */
             opts.enable_spans = true;  /* Unified: bracketed spans enabled */
             opts.enable_emoji_autocorrect = true;  /* Unified: emoji autocorrect enabled */
             opts.enable_image_captions = true;     /* Unified: image captions enabled by default */
             break;
+
+        case APEX_MODE_QUARTO:
+            /* Pandoc/Quarto markdown: unified-family defaults tuned for Quarto docs */
+            opts = apex_options_for_mode(APEX_MODE_UNIFIED);
+            opts.mode = APEX_MODE_QUARTO;
+            opts.enable_quarto_extensions = true;
+            opts.enable_quarto_raw = true;
+            opts.enable_quarto_example_lists = true;
+            opts.enable_quarto_line_blocks = true;
+            opts.enable_quarto_roman_lists = true;
+            opts.enable_quarto_code_attrs = true;
+            opts.enable_quarto_diagrams = true;
+            opts.enable_quarto_shortcodes = true;
+            opts.enable_quarto_xrefs = true;
+            opts.enable_quarto_strict_lists = false;
+            opts.enable_quarto_callouts = true;
+            opts.enable_wiki_links = false;
+            opts.enable_marked_extensions = false;
+            opts.enable_py_callouts = false;
+            opts.enable_indices = false;
+            opts.enable_mmark_index_syntax = false;
+            opts.enable_textindex_syntax = false;
+            opts.enable_leanpub_index_syntax = false;
+            break;
     }
 
     return opts;
 }
 
+bool apex_options_apply_meta_file(apex_options *options, const char *path) {
+    if (!options || !path || !path[0]) {
+        return false;
+    }
+
+    apex_options original_options = *options;
+    apex_metadata_item *metadata = apex_load_metadata_from_file(path);
+    if (!metadata) {
+        return false;
+    }
+
+    apex_apply_metadata_to_options(metadata, options);
+
+    bool owns_csl_file = options->csl_file &&
+                         options->csl_file != original_options.csl_file;
+    bool owns_document_title = options->document_title &&
+                               options->document_title != original_options.document_title;
+    bool owns_base_directory = options->base_directory &&
+                               options->base_directory != original_options.base_directory;
+    bool owns_wikilink_extension = options->wikilink_extension &&
+                                   options->wikilink_extension != original_options.wikilink_extension;
+    bool owns_theme_name = options->theme_name &&
+                           options->theme_name != original_options.theme_name;
+    bool owns_code_highlight_theme = options->code_highlight_theme &&
+                                     options->code_highlight_theme != original_options.code_highlight_theme;
+    bool owns_stylesheet_paths = options->stylesheet_paths &&
+                                 options->stylesheet_paths != original_options.stylesheet_paths;
+
+    char *csl_file = owns_csl_file ? strdup(options->csl_file) : NULL;
+    char *document_title = owns_document_title ? strdup(options->document_title) : NULL;
+    char *base_directory = owns_base_directory ? strdup(options->base_directory) : NULL;
+    char *wikilink_extension = owns_wikilink_extension ? strdup(options->wikilink_extension) : NULL;
+    char *theme_name = owns_theme_name ? strdup(options->theme_name) : NULL;
+    char *code_highlight_theme = owns_code_highlight_theme ? strdup(options->code_highlight_theme) : NULL;
+    const char **stylesheet_paths = NULL;
+    bool copy_failed = (owns_csl_file && !csl_file) ||
+                       (owns_document_title && !document_title) ||
+                       (owns_base_directory && !base_directory) ||
+                       (owns_wikilink_extension && !wikilink_extension) ||
+                       (owns_theme_name && !theme_name) ||
+                       (owns_code_highlight_theme && !code_highlight_theme);
+
+    if (owns_stylesheet_paths) {
+        stylesheet_paths = calloc(options->stylesheet_count + 1, sizeof(*stylesheet_paths));
+        if (!stylesheet_paths) {
+            copy_failed = true;
+        } else {
+            for (size_t i = 0; i < options->stylesheet_count; i++) {
+                if (options->stylesheet_paths[i]) {
+                    stylesheet_paths[i] = strdup(options->stylesheet_paths[i]);
+                    if (!stylesheet_paths[i]) {
+                        copy_failed = true;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+
+    if (copy_failed) {
+        free(csl_file);
+        free(document_title);
+        free(base_directory);
+        free(wikilink_extension);
+        free(theme_name);
+        free(code_highlight_theme);
+        if (stylesheet_paths) {
+            for (size_t i = 0; i < options->stylesheet_count; i++) {
+                free((void *)stylesheet_paths[i]);
+            }
+            free(stylesheet_paths);
+        }
+        if (owns_stylesheet_paths) {
+            free(options->stylesheet_paths);
+        }
+        apex_free_metadata(metadata);
+        *options = original_options;
+        return false;
+    }
+
+    if (owns_stylesheet_paths) {
+        free(options->stylesheet_paths);
+    }
+    apex_free_metadata(metadata);
+
+    if (owns_csl_file) options->csl_file = csl_file;
+    if (owns_document_title) options->document_title = document_title;
+    if (owns_base_directory) options->base_directory = base_directory;
+    if (owns_wikilink_extension) options->wikilink_extension = wikilink_extension;
+    if (owns_theme_name) options->theme_name = theme_name;
+    if (owns_code_highlight_theme) options->code_highlight_theme = code_highlight_theme;
+    if (owns_stylesheet_paths) options->stylesheet_paths = stylesheet_paths;
+    return true;
+}
+
+static bool apex_quarto_feature(const apex_options *options, bool feature_enabled) {
+    return feature_enabled &&
+           (options->enable_quarto_extensions || options->mode == APEX_MODE_QUARTO);
+}
+
 /**
  * Convert cmark-gfm option flags based on Apex options
  */
@@ -3221,7 +3476,7 @@ static void apex_register_extensions(cmark_parser *parser, const apex_options *o
     }
 
     /* GFM autolink - enable for GFM and Unified modes if autolink is enabled */
-    if (options->enable_autolink && (options->mode == APEX_MODE_GFM || options->mode == APEX_MODE_UNIFIED)) {
+    if (options->enable_autolink && (options->mode == APEX_MODE_GFM || apex_mode_is_unified_family(options->mode))) {
         cmark_syntax_extension *autolink_ext = cmark_find_syntax_extension("autolink");
         if (autolink_ext) {
             cmark_parser_attach_syntax_extension(parser, autolink_ext);
@@ -4479,6 +4734,30 @@ fail:
     return NULL;
 }
 
+apex_toc_entry *apex_markdown_to_toc_entries(const char *markdown, size_t len,
+                                             const apex_options *options,
+                                             size_t *out_count) {
+    if (out_count) *out_count = 0;
+    if (!out_count) return NULL;
+    if (!markdown || len == 0) return NULL;
+
+    apex_options opts = options ? *options : apex_options_default();
+    opts.output_format = APEX_OUTPUT_TOC;
+    opts.toc_entries_out = NULL; /* set below after locals exist */
+    opts.toc_entries_count_out = NULL;
+
+    apex_toc_entry *entries = NULL;
+    size_t count = 0;
+    opts.toc_entries_out = &entries;
+    opts.toc_entries_count_out = &count;
+
+    char *discard = apex_markdown_to_html(markdown, len, &opts);
+    apex_free_string(discard);
+
+    *out_count = count;
+    return entries;
+}
+
 char *apex_markdown_to_html(const char *markdown, size_t len, const apex_options *options) {
     if (!markdown || len == 0) {
         char *empty = malloc(1);
@@ -4529,6 +4808,19 @@ char *apex_markdown_to_html(const char *markdown, size_t len, const apex_options
         plugin_manager = apex_plugins_load(options);
     }
 
+    char *quarto_shortcodes_processed = NULL;
+    if (apex_quarto_feature(options, options->enable_quarto_shortcodes)) {
+        bool warn_unknown = getenv("APEX_VERBOSE") != NULL;
+        PROFILE_START(quarto_shortcodes_preprocess);
+        quarto_shortcodes_processed = apex_preprocess_quarto_shortcodes(working_text, warn_unknown, options->unsafe);
+        PROFILE_END(quarto_shortcodes_preprocess);
+        if (quarto_shortcodes_processed) {
+            free(working_text);
+            working_text = quarto_shortcodes_processed;
+            len = strlen(working_text);
+        }
+    }
+
     /* Optional pre-parse plugin hook: run all configured pre_parse plugins
      * over the raw markdown before any Apex-specific preprocessing.
      */
@@ -4552,6 +4844,19 @@ char *apex_markdown_to_html(const char *markdown, size_t len, const apex_options
     char **liquid_tags = NULL;
     size_t liquid_tag_count = 0;
     char *liquid_protected = NULL;
+    char *py_callouts_processed = NULL;
+    /* Process Python-Markdown/markdown-callouts syntax early so metadata parsing
+     * doesn't consume top-of-file TYPE: lines before they can be treated as callouts.
+     */
+    if (options->enable_py_callouts) {
+        PROFILE_START(py_callouts_preprocess);
+        py_callouts_processed = apex_preprocess_py_callouts(text_ptr);
+        PROFILE_END(py_callouts_preprocess);
+        if (py_callouts_processed) {
+            text_ptr = py_callouts_processed;
+        }
+    }
+
 
 
     if (getenv("APEX_DEBUG_PIPELINE")) {
@@ -4565,7 +4870,7 @@ char *apex_markdown_to_html(const char *markdown, size_t len, const apex_options
 
     if (options->mode == APEX_MODE_MULTIMARKDOWN ||
         options->mode == APEX_MODE_KRAMDOWN ||
-        options->mode == APEX_MODE_UNIFIED) {
+        apex_mode_is_unified_family(options->mode)) {
         /* Extract metadata FIRST */
         PROFILE_START(metadata);
         metadata = apex_extract_metadata_for_mode(&text_ptr, options->mode);
@@ -4577,7 +4882,7 @@ char *apex_markdown_to_html(const char *markdown, size_t len, const apex_options
         }
 
         /* Extract ALDs for Kramdown */
-        if (options->mode == APEX_MODE_KRAMDOWN || options->mode == APEX_MODE_UNIFIED) {
+        if (apex_mode_is_kramdown_or_unified_family(options->mode)) {
             alds = apex_extract_alds(&text_ptr);
             if (getenv("APEX_DEBUG_PIPELINE")) {
                 size_t len = strlen(text_ptr);
@@ -4717,13 +5022,27 @@ char *apex_markdown_to_html(const char *markdown, size_t len, const apex_options
 
     /* Process index entries (preprocessing) */
     apex_index_registry index_registry = {0};
+    char *concordance_processed = NULL;
     char *indices_processed = NULL;
+    if (options->enable_indices && options->concordance_files && options->concordance_files[0]) {
+        PROGRESS_REPORT("Applying concordance", -1);
+        PROFILE_START(concordance);
+        concordance_processed = apex_apply_concordance(text_ptr, options);
+        PROFILE_END(concordance);
+        if (concordance_processed) {
+            text_ptr = concordance_processed;
+        }
+    }
     if (options->enable_indices) {
         PROGRESS_REPORT("Processing indices", -1);
         PROFILE_START(indices);
         indices_processed = apex_process_index_entries(text_ptr, &index_registry, options);
         PROFILE_END(indices);
         if (indices_processed) {
+            if (concordance_processed) {
+                free(concordance_processed);
+                concordance_processed = NULL;
+            }
             text_ptr = indices_processed;
         }
     }
@@ -4746,9 +5065,11 @@ char *apex_markdown_to_html(const char *markdown, size_t len, const apex_options
     /* Preprocess image attributes and URL-encode all link URLs */
     image_attr_entry *img_attrs = NULL;
     char *image_attrs_processed = NULL;
-    if (options->mode == APEX_MODE_UNIFIED ||
+    if (apex_mode_is_unified_family(options->mode) ||
         options->mode == APEX_MODE_MULTIMARKDOWN ||
-        options->mode == APEX_MODE_KRAMDOWN) {
+        options->mode == APEX_MODE_KRAMDOWN ||
+        options->mode == APEX_MODE_GFM ||
+        options->mode == APEX_MODE_COMMONMARK) {
         PROFILE_START(image_attrs_preprocess);
         image_attrs_processed = apex_preprocess_image_attributes(text_ptr, &img_attrs, options->mode);
         PROFILE_END(image_attrs_preprocess);
@@ -4764,7 +5085,8 @@ char *apex_markdown_to_html(const char *markdown, size_t len, const apex_options
 
     /* Preprocess IAL markers (insert blank lines before them so cmark parses correctly) */
     char *ial_preprocessed = NULL;
-    if (options->mode == APEX_MODE_KRAMDOWN || options->mode == APEX_MODE_UNIFIED) {
+    char *escaped_toc_protected = NULL;
+    if (options->mode == APEX_MODE_KRAMDOWN || apex_mode_is_unified_family(options->mode)) {
         PROFILE_START(ial_preprocess);
         ial_preprocessed = apex_preprocess_ial(text_ptr);
         PROFILE_END(ial_preprocess);
@@ -4778,9 +5100,42 @@ char *apex_markdown_to_html(const char *markdown, size_t len, const apex_options
         }
     }
 
+    /* Preprocess grid tables BEFORE spans/special_markers.
+     * Grid tables must process === separators before proofreader/highlight converts them.
+     * Converts Pandoc +---+ syntax to pipe tables for the normal table pipeline.
+     */
+    char *grid_tables_processed = NULL;
+    char *normalized_for_grid_tables = NULL;
+    if (options->enable_grid_tables && options->enable_tables) {
+        size_t pre_grid_len = strlen(text_ptr);
+        bool needs_newline_for_grid = (pre_grid_len > 0 &&
+                                       text_ptr[pre_grid_len - 1] != '\n' &&
+                                       text_ptr[pre_grid_len - 1] != '\r');
+        if (needs_newline_for_grid) {
+            normalized_for_grid_tables = malloc(pre_grid_len + 2);
+            if (normalized_for_grid_tables) {
+                memcpy(normalized_for_grid_tables, text_ptr, pre_grid_len);
+                normalized_for_grid_tables[pre_grid_len] = '\n';
+                normalized_for_grid_tables[pre_grid_len + 1] = '\0';
+            }
+        }
+
+        PROFILE_START(grid_tables_preprocess);
+        grid_tables_processed = apex_preprocess_grid_tables(normalized_for_grid_tables ? normalized_for_grid_tables : text_ptr);
+        PROFILE_END(grid_tables_preprocess);
+
+        if (normalized_for_grid_tables) {
+            free(normalized_for_grid_tables);
+        }
+
+        if (grid_tables_processed) {
+            text_ptr = grid_tables_processed;
+        }
+    }
+
     /* Preprocess bracketed spans [text]{IAL} */
     char *spans_preprocessed = NULL;
-    if (options->enable_spans && (options->mode == APEX_MODE_UNIFIED || options->mode == APEX_MODE_KRAMDOWN)) {
+    if (options->enable_spans && apex_mode_is_kramdown_or_unified_family(options->mode)) {
         PROFILE_START(spans_preprocess);
         spans_preprocessed = apex_preprocess_bracketed_spans(text_ptr);
         PROFILE_END(spans_preprocess);
@@ -4793,7 +5148,13 @@ char *apex_markdown_to_html(const char *markdown, size_t len, const apex_options
     char *includes_processed = NULL;
     if (options->enable_file_includes) {
         PROFILE_START(includes);
-        includes_processed = apex_process_includes(text_ptr, options->base_directory, metadata, 0);
+        includes_processed = apex_process_includes(text_ptr,
+                                                   options->base_directory,
+                                                   metadata,
+                                                   0,
+                                                   options->wikilink_extension,
+                                                   plugin_manager,
+                                                   options);
         PROFILE_END(includes);
         if (includes_processed) {
             text_ptr = includes_processed;
@@ -4821,11 +5182,58 @@ char *apex_markdown_to_html(const char *markdown, size_t len, const apex_options
         text_ptr = inline_tables_processed;
     }
 
+    /* Pandoc/Quarto list extensions before alpha/roman marker normalization */
+    char *example_lists_processed = NULL;
+    char *line_blocks_processed = NULL;
+    char *roman_lists_processed = NULL;
+    char *strict_lists_processed = NULL;
+    if (apex_quarto_feature(options, options->enable_quarto_example_lists)) {
+        PROFILE_START(example_lists_preprocess);
+        example_lists_processed = apex_preprocess_example_lists(text_ptr);
+        PROFILE_END(example_lists_preprocess);
+        if (example_lists_processed) {
+            text_ptr = example_lists_processed;
+        }
+    }
+
+    if (apex_quarto_feature(options, options->enable_quarto_line_blocks)) {
+        PROFILE_START(line_blocks_preprocess);
+        line_blocks_processed = apex_preprocess_line_blocks(text_ptr, options->unsafe);
+        PROFILE_END(line_blocks_preprocess);
+        if (line_blocks_processed) {
+            text_ptr = line_blocks_processed;
+        }
+    }
+
+    if (apex_quarto_feature(options, options->enable_quarto_roman_lists)) {
+        PROFILE_START(roman_lists_preprocess);
+        roman_lists_processed = apex_preprocess_roman_lists(text_ptr);
+        PROFILE_END(roman_lists_preprocess);
+        if (roman_lists_processed) {
+            text_ptr = roman_lists_processed;
+        }
+    }
+
+    if (apex_quarto_feature(options, options->enable_quarto_strict_lists)) {
+        PROFILE_START(quarto_strict_lists_preprocess);
+        strict_lists_processed = apex_preprocess_quarto_strict_lists(text_ptr);
+        PROFILE_END(quarto_strict_lists_preprocess);
+        if (strict_lists_processed) {
+            text_ptr = strict_lists_processed;
+        }
+    }
+
     /* Process alpha lists before parsing (preprocessing) */
     char *alpha_lists_processed = NULL;
+    bool inserted_synthetic_nested_alpha_break = false;
+    bool saw_explicit_nested_alpha_break = false;
     if (options->allow_alpha_lists) {
         PROFILE_START(alpha_lists);
-        alpha_lists_processed = apex_preprocess_alpha_lists(text_ptr);
+        alpha_lists_processed = apex_preprocess_alpha_lists(
+            text_ptr,
+            &inserted_synthetic_nested_alpha_break,
+            &saw_explicit_nested_alpha_break
+        );
         PROFILE_END(alpha_lists);
         if (alpha_lists_processed) {
             text_ptr = alpha_lists_processed;
@@ -4833,10 +5241,12 @@ char *apex_markdown_to_html(const char *markdown, size_t len, const apex_options
     }
 
     char *nested_ordered_sublists_processed = NULL;
+    bool inserted_synthetic_nested_ordered_break = false;
+    bool saw_explicit_nested_ordered_break = false;
 
     /* Process emoji autocorrect before parsing (preprocessing) */
     char *emoji_autocorrect_processed = NULL;
-    if (options->enable_emoji_autocorrect && (options->mode == APEX_MODE_UNIFIED || options->mode == APEX_MODE_GFM)) {
+    if (options->enable_emoji_autocorrect && (options->mode == APEX_MODE_GFM || apex_mode_is_unified_family(options->mode))) {
         PROFILE_START(emoji_autocorrect);
         emoji_autocorrect_processed = apex_autocorrect_emoji_names(text_ptr);
         PROFILE_END(emoji_autocorrect);
@@ -5063,10 +5473,52 @@ char *apex_markdown_to_html(const char *markdown, size_t len, const apex_options
         }
     }
 
+    /* Pandoc/Quarto raw content ({=format}) before other fence preprocessors */
+    char *raw_content_processed = NULL;
+    char *code_fence_attrs_processed = NULL;
+    char *quarto_diagrams_processed = NULL;
+    if (apex_quarto_feature(options, options->enable_quarto_raw)) {
+        PROFILE_START(raw_content_preprocess);
+        raw_content_processed = apex_preprocess_raw_content(text_ptr, options->unsafe);
+        PROFILE_END(raw_content_preprocess);
+        if (raw_content_processed) {
+            text_ptr = raw_content_processed;
+        }
+    }
+
+    if (apex_quarto_feature(options, options->enable_quarto_code_attrs)) {
+        PROFILE_START(code_fence_attrs_preprocess);
+        code_fence_attrs_processed = apex_preprocess_code_fence_attrs(text_ptr);
+        PROFILE_END(code_fence_attrs_preprocess);
+        if (code_fence_attrs_processed) {
+            text_ptr = code_fence_attrs_processed;
+        }
+    }
+
+    if (apex_quarto_feature(options, options->enable_quarto_diagrams)) {
+        PROFILE_START(quarto_diagrams_preprocess);
+        quarto_diagrams_processed = apex_preprocess_quarto_diagrams(text_ptr, options->unsafe);
+        PROFILE_END(quarto_diagrams_preprocess);
+        if (quarto_diagrams_processed) {
+            text_ptr = quarto_diagrams_processed;
+        }
+    }
+
+    /* Process Quarto ::: callouts before fenced divs so recognized callouts bypass generic div conversion */
+    char *quarto_callouts_processed = NULL;
+    if (options->enable_quarto_callouts) {
+        PROFILE_START(quarto_callouts_preprocess);
+        quarto_callouts_processed = apex_preprocess_quarto_callouts(text_ptr);
+        PROFILE_END(quarto_callouts_preprocess);
+        if (quarto_callouts_processed) {
+            text_ptr = quarto_callouts_processed;
+        }
+    }
+
     /* Process fenced divs before parsing (preprocessing) */
     /* Only enabled in Unified mode */
     char *fenced_divs_processed = NULL;
-    if (options->enable_divs && options->mode == APEX_MODE_UNIFIED) {
+    if (options->enable_divs && apex_mode_is_unified_family(options->mode)) {
         PROFILE_START(fenced_divs);
         fenced_divs_processed = apex_process_fenced_divs(text_ptr);
         PROFILE_END(fenced_divs);
@@ -5473,9 +5925,13 @@ char *apex_markdown_to_html(const char *markdown, size_t len, const apex_options
     }
 
     /* Keep this late so later preprocessors do not collapse inserted separation. */
-    if (options->mode == APEX_MODE_UNIFIED) {
+    if (apex_mode_is_unified_family(options->mode)) {
         PROFILE_START(nested_ordered_sublists);
-        nested_ordered_sublists_processed = apex_preprocess_nested_ordered_sublists(text_ptr);
+        nested_ordered_sublists_processed = apex_preprocess_nested_ordered_sublists(
+            text_ptr,
+            &inserted_synthetic_nested_ordered_break,
+            &saw_explicit_nested_ordered_break
+        );
         PROFILE_END(nested_ordered_sublists);
         if (nested_ordered_sublists_processed) {
             text_ptr = nested_ordered_sublists_processed;
@@ -5526,6 +5982,15 @@ char *apex_markdown_to_html(const char *markdown, size_t len, const apex_options
     /* Convert options to cmark-gfm format */
     int cmark_opts = apex_to_cmark_options(options);
 
+    /* Protect backslash-escaped {{TOC...}} markers before parsing */
+    if (options->enable_marked_extensions || options->mode == APEX_MODE_MULTIMARKDOWN) {
+        escaped_toc_protected = apex_protect_escaped_toc_markers(text_ptr);
+        if (escaped_toc_protected) {
+            text_ptr = escaped_toc_protected;
+            text_len = strlen(text_ptr);
+        }
+    }
+
     /* Create parser */
     PROFILE_START(parsing);
     cmark_parser *parser = cmark_parser_new(cmark_opts);
@@ -5596,6 +6061,8 @@ char *apex_markdown_to_html(const char *markdown, size_t len, const apex_options
         } else if (options->output_format == APEX_OUTPUT_TERMINAL ||
                    options->output_format == APEX_OUTPUT_TERMINAL256) {
             target_format = "terminal";
+        } else if (options->output_format == APEX_OUTPUT_RTF) {
+            target_format = "rtf";
         }
         cmark_node *filtered = apex_run_ast_filters(document, options, target_format);
         if (!filtered && options->ast_filter_strict) {
@@ -5631,14 +6098,14 @@ char *apex_markdown_to_html(const char *markdown, size_t len, const apex_options
 
     /* Postprocess callouts if enabled */
     if (options->enable_callouts) {
-        apex_process_callouts_in_tree(document);
+        apex_process_callouts_in_tree(document, options->enable_py_callouts);
     }
 
     /* Process IAL (Inline Attribute Lists) BEFORE manual header IDs.
        IAL handles {: #id}, {#id}, and {.class} - running first ensures these
        are extracted and removed from heading text before manual header ID
        looks for MMD [id] or Kramdown {#id}. Avoids duplicate handling. */
-    if (alds || options->mode == APEX_MODE_KRAMDOWN || options->mode == APEX_MODE_UNIFIED) {
+    if (alds || apex_mode_is_kramdown_or_unified_family(options->mode)) {
         /* Fast path: skip AST walk if no IAL markers present */
         /* Check for both Kramdown-style ({:) and Pandoc-style ({# or {.) IALs */
         if (strstr(text_ptr, "{:") != NULL ||
@@ -5676,6 +6143,11 @@ char *apex_markdown_to_html(const char *markdown, size_t len, const apex_options
     if (options->allow_mixed_list_markers) {
         apex_merge_mixed_list_markers(document);
     }
+    if (apex_mode_is_unified_family(options->mode) &&
+        ((inserted_synthetic_nested_ordered_break && !saw_explicit_nested_ordered_break) ||
+         (inserted_synthetic_nested_alpha_break && !saw_explicit_nested_alpha_break))) {
+        apex_tighten_nested_ordered_list_items(document);
+    }
 
     /* Note: Critic Markup is now handled via preprocessing (before parsing) */
 
@@ -5687,6 +6159,18 @@ char *apex_markdown_to_html(const char *markdown, size_t len, const apex_options
         return json;
     }
 
+    if (options->output_format == APEX_OUTPUT_TOC) {
+        if (options->toc_entries_out && options->toc_entries_count_out) {
+            *options->toc_entries_out = apex_generate_toc_entries(
+                document, options->id_format, options->toc_min, options->toc_max,
+                options->toc_entries_count_out);
+            return strdup("");
+        }
+        char *toc_md = apex_generate_toc_markdown(document, options->id_format,
+                                                  options->toc_min, options->toc_max);
+        return toc_md ? toc_md : strdup("");
+    }
+
     /* If output format is Markdown, serialize AST to Markdown and return */
     if (options->output_format == APEX_OUTPUT_MARKDOWN ||
         options->output_format == APEX_OUTPUT_MMD ||
@@ -5729,13 +6213,19 @@ char *apex_markdown_to_html(const char *markdown, size_t len, const apex_options
         return man_html ? man_html : strdup("<!DOCTYPE html><html><body><p>stub</p></body></html>");
     }
 
+    /* If output format is RTF, serialize AST and return */
+    if (options->output_format == APEX_OUTPUT_RTF) {
+        char *rtf = apex_cmark_to_rtf(document, options);
+        return rtf ? rtf : strdup("{\\rtf1\\ansi\\deff0\\pard\\par}\n");
+    }
+
     /* Render to HTML
      * Use custom renderer when we have attributes (IAL, ALDs, or image attributes)
      * Otherwise use standard renderer
      */
     PROFILE_START(rendering);
     char *html;
-    if (img_attrs || alds || options->mode == APEX_MODE_KRAMDOWN || options->mode == APEX_MODE_UNIFIED) {
+    if (img_attrs || alds || apex_mode_is_kramdown_or_unified_family(options->mode)) {
         /* Use custom renderer to inject attributes */
         html = apex_render_html_with_attributes(document, cmark_opts);
     } else {
@@ -5761,7 +6251,7 @@ char *apex_markdown_to_html(const char *markdown, size_t len, const apex_options
     }
 
     /* Restore custom element tags from fenced-div wrappers (fixes out-of-order HTML) */
-    if (html && options->enable_divs && options->mode == APEX_MODE_UNIFIED) {
+    if (html && options->enable_divs && apex_mode_is_unified_family(options->mode)) {
         char *fenced_divs_html = apex_postprocess_fenced_divs_html(html);
         if (fenced_divs_html) {
             free(html);
@@ -6041,12 +6531,18 @@ char *apex_markdown_to_html(const char *markdown, size_t len, const apex_options
      */
     if ((options->enable_marked_extensions || options->mode == APEX_MODE_MULTIMARKDOWN) && html) {
         PROFILE_START(toc);
-        char *with_toc = apex_process_toc(html, document, options->id_format);
+        char *with_toc = apex_process_toc(html, document, options->id_format,
+                                          options->toc_min, options->toc_max);
         PROFILE_END(toc);
         if (with_toc) {
             free(html);
             html = with_toc;
         }
+        char *restored = apex_restore_escaped_toc_markers(html);
+        if (restored) {
+            free(html);
+            html = restored;
+        }
     }
 
     /* Apply ARIA labels if enabled */
@@ -6077,6 +6573,16 @@ char *apex_markdown_to_html(const char *markdown, size_t len, const apex_options
         }
     }
 
+    if (apex_quarto_feature(options, options->enable_quarto_code_attrs) && html) {
+        PROFILE_START(code_fence_attrs_postprocess);
+        char *fence_html = apex_postprocess_code_fence_attrs_html(html);
+        PROFILE_END(code_fence_attrs_postprocess);
+        if (fence_html) {
+            free(html);
+            html = fence_html;
+        }
+    }
+
     /* Replace abbreviations if any were found */
     if (abbreviations && html) {
         PROFILE_START(abbreviations);
@@ -6089,7 +6595,7 @@ char *apex_markdown_to_html(const char *markdown, size_t len, const apex_options
     }
 
     /* Replace GitHub emoji if in GFM or Unified mode */
-    if ((options->mode == APEX_MODE_GFM || options->mode == APEX_MODE_UNIFIED) && html) {
+    if ((options->mode == APEX_MODE_GFM || apex_mode_is_unified_family(options->mode)) && html) {
         PROFILE_START(emoji);
         char *with_emoji = apex_replace_emoji(html);
         PROFILE_END(emoji);
@@ -6211,6 +6717,26 @@ char *apex_markdown_to_html(const char *markdown, size_t len, const apex_options
         }
     }
 
+    if (apex_quarto_feature(options, options->enable_quarto_roman_lists) && html) {
+        PROFILE_START(roman_lists_postprocess);
+        char *roman_html = apex_postprocess_roman_lists_html(html);
+        PROFILE_END(roman_lists_postprocess);
+        if (roman_html) {
+            free(html);
+            html = roman_html;
+        }
+    }
+
+    if (apex_quarto_feature(options, options->enable_quarto_xrefs) && html) {
+        PROFILE_START(quarto_xrefs_postprocess);
+        char *xref_html = apex_postprocess_quarto_xrefs_html(html);
+        PROFILE_END(quarto_xrefs_postprocess);
+        if (xref_html) {
+            free(html);
+            html = xref_html;
+        }
+    }
+
     /* Remove empty paragraphs created by ^ marker (zero-width space only) */
     if (html && options->enable_marked_extensions) {
         PROFILE_START(remove_empty_paragraphs);
@@ -6230,7 +6756,18 @@ char *apex_markdown_to_html(const char *markdown, size_t len, const apex_options
     cmark_parser_free(parser);
     free(working_text);
     if (ial_preprocessed) free(ial_preprocessed);
+    if (escaped_toc_protected) free(escaped_toc_protected);
     if (spans_preprocessed) free(spans_preprocessed);
+    if (grid_tables_processed) free(grid_tables_processed);
+    if (raw_content_processed) free(raw_content_processed);
+    if (code_fence_attrs_processed) free(code_fence_attrs_processed);
+    if (quarto_diagrams_processed) free(quarto_diagrams_processed);
+    if (example_lists_processed) free(example_lists_processed);
+    if (line_blocks_processed) free(line_blocks_processed);
+    if (roman_lists_processed) free(roman_lists_processed);
+    if (strict_lists_processed) free(strict_lists_processed);
+    if (quarto_callouts_processed) free(quarto_callouts_processed);
+    if (py_callouts_processed) free(py_callouts_processed);
     if (includes_processed) free(includes_processed);
     if (emoji_autocorrect_processed) free(emoji_autocorrect_processed);
     if (markers_processed_early) {
@@ -6250,6 +6787,7 @@ char *apex_markdown_to_html(const char *markdown, size_t len, const apex_options
     if (deflist_processed) free(deflist_processed);
     if (fenced_divs_processed) free(fenced_divs_processed);
     if (metadata_replaced) free(metadata_replaced);
+    if (concordance_processed) free(concordance_processed);
     if (autolinks_processed) free(autolinks_processed);
     if (html_markdown_processed) free(html_markdown_processed);
     if (hashtags_processed) free(hashtags_processed);
@@ -6284,28 +6822,55 @@ char *apex_markdown_to_html(const char *markdown, size_t len, const apex_options
 
     /* Build script HTML (if any) from script_tags before wrapping or appending */
     char *scripts_html = NULL;
-    if (local_opts.script_tags) {
+    const char *auto_mermaid_script = NULL;
+    if (local_opts.standalone && html && local_opts.enable_quarto_diagrams &&
+        apex_html_has_mermaid_diagram(html)) {
+        bool has_mermaid_script = false;
+        if (local_opts.script_tags) {
+            for (char **p = local_opts.script_tags; *p; ++p) {
+                if (*p && strstr(*p, "mermaid")) {
+                    has_mermaid_script = true;
+                    break;
+                }
+            }
+        }
+        if (!has_mermaid_script) {
+            auto_mermaid_script = apex_mermaid_script_tag();
+        }
+    }
+
+    if (local_opts.script_tags || auto_mermaid_script) {
         /* Join script tag snippets with newlines */
         size_t total_len = 0;
         size_t count = 0;
-        for (char **p = local_opts.script_tags; *p; ++p) {
+        for (char **p = local_opts.script_tags; p && *p; ++p) {
             size_t len = strlen(*p);
             if (len == 0) continue;
             total_len += len + 1; /* +1 for newline */
             count++;
         }
+        if (auto_mermaid_script) {
+            total_len += strlen(auto_mermaid_script) + 1;
+            count++;
+        }
 
         if (count > 0 && total_len > 0) {
             scripts_html = malloc(total_len + 1); /* +1 for null terminator */
             if (scripts_html) {
                 size_t pos = 0;
-                for (char **p = local_opts.script_tags; *p; ++p) {
+                for (char **p = local_opts.script_tags; p && *p; ++p) {
                     size_t len = strlen(*p);
                     if (len == 0) continue;
                     memcpy(scripts_html + pos, *p, len);
                     pos += len;
                     scripts_html[pos++] = '\n';
                 }
+                if (auto_mermaid_script) {
+                    size_t len = strlen(auto_mermaid_script);
+                    memcpy(scripts_html + pos, auto_mermaid_script, len);
+                    pos += len;
+                    scripts_html[pos++] = '\n';
+                }
                 scripts_html[pos] = '\0';
             }
         }
@@ -7016,6 +7581,11 @@ char *apex_wrap_html_document(const char *content, const char *title, const char
             "    ins { background: #d4fcbc; text-decoration: none; }\n"
             "    del { background: #fbb6c2; text-decoration: line-through; }\n"
             "    mark { background: #fff3cd; }\n"
+            "    .smallcaps { font-variant: small-caps; }\n"
+            "    .underline { text-decoration: underline; }\n"
+            "    span.mark { background: #fff3cd; }\n"
+            "    .hidden { display: none; }\n"
+            "    .quarto-xref { font-variant: normal; }\n"
             "    .critic.comment { background: #e7e7e7; color: #666; font-style: italic; }\n"
             "    .mkhashtag { color: #666; }\n"
             "    .mkstyledtag {\n"