apex-ruby 1.0.6 → 1.0.7

data/ext/apex_ext/apex_src/src/extensions/definition_list.c

@@ -1,19 +1,24 @@
 /**
  * Definition List Extension for Apex
- * Implementation
  *
- * Supports Kramdown/PHP Markdown Extra style definition lists:
- * Term
- * : Definition 1
- * : Definition 2
+ * Supports four formats (all produce <dl><dt>term</dt><dd>definition</dd></dl>):
  *
- * With block-level content in definitions:
- * Term
- * : Definition with paragraphs
+ * 1. Kramdown single colon:
+ *    term
+ *    : definition
  *
- *   And code blocks
+ * 2. Kramdown double colon:
+ *    term
+ *    :: definition
  *
- *       code here
+ * 3. One-line no space: term::definition
+ *
+ * 4. One-line with space: term :: definition
+ *
+ * For one-line format, :: must NOT be at line start (that's Kramdown).
+ * Whitespace around :: is allowed in one-line format.
+ *
+ * Both formats enabled by default in unified mode.
  */
 
 #include "definition_list.h"
@@ -24,1647 +29,619 @@
 #include "render.h"
 #include <string.h>
 #include <stdlib.h>
-#include <ctype.h>
 #include <stdbool.h>
-#include <stdio.h>
-
-/* Node type IDs */
-cmark_node_type APEX_NODE_DEFINITION_LIST;
-cmark_node_type APEX_NODE_DEFINITION_TERM;
-cmark_node_type APEX_NODE_DEFINITION_DATA;
 
 /**
- * Check if a line starts a definition (starts with : optionally indented up to 3 spaces)
+ * Check if a line matches the one-line definition format: Term :: Definition
+ * The line must contain :: with optional whitespace around it.
+ * Uses the last :: to avoid splitting URLs (e.g. http://example.com).
+ * Returns the position of :: or -1 if not a match.
  */
-static bool is_definition_line(const unsigned char *input, int len, int *indent) {
-    if (!input || len == 0) return false;
-
-    int spaces = 0;
-
-    /* Count leading spaces (up to 3 allowed) */
-    while (spaces < 3 && spaces < len && input[spaces] == ' ') {
-        spaces++;
+static int find_def_separator(const unsigned char *line, int len) {
+    if (!line || len < 3) return -1;
+
+    int last_sep = -1;
+    for (int i = 0; i < len - 1; i++) {
+        if (line[i] == ':' && line[i + 1] == ':') {
+            /* Skip :: that's part of URL (://) */
+            if (i + 3 <= len && line[i + 2] == '/') continue;
+            /* Skip :: that's part of div/custom element (::: or more) */
+            if (i > 0 && line[i - 1] == ':') continue;
+            if (i + 2 < len && line[i + 2] == ':') continue;
+            last_sep = i;
+        }
     }
+    if (last_sep < 0) return -1;
 
-    if (spaces >= len) return false;
-
-    /* Must start with : */
-    if (input[spaces] != ':') return false;
-
-    /* Must be followed by space or tab */
-    if (spaces + 1 >= len) return false;
-    if (input[spaces + 1] != ' ' && input[spaces + 1] != '\t') return false;
+    /* Ensure we have content before (at least one non-space) */
+    int before = 0;
+    for (int j = 0; j < last_sep; j++) {
+        if (line[j] != ' ' && line[j] != '\t') {
+            before = 1;
+            break;
+        }
+    }
+    /* After: at least one character */
+    int after = (last_sep + 2 < len);
+    if (before && after) return last_sep;
+    return -1;
+}
 
-    *indent = spaces;
+/**
+ * Check if a line is a Kramdown-style definition line (starts with : or :: after optional spaces).
+ * Reject ::: or more - those are div/custom element fences, not definition lists.
+ */
+static bool is_kramdown_def_line(const char *line, size_t len) {
+    if (!line || len == 0) return false;
+    size_t i = 0;
+    while (i < len && (line[i] == ' ' || line[i] == '\t')) i++;
+    if (i >= len) return false;
+    if (line[i] != ':') return false;
+    int colon_len = 1;
+    if (i + 2 <= len && line[i + 1] == ':') colon_len = 2;
+    /* Reject 3+ colons (::: is div fence) */
+    if (i + 3 <= len && line[i + 2] == ':') return false;
+    if (i + (size_t)colon_len >= len) return false;
+    if (line[i + colon_len] != ' ' && line[i + colon_len] != '\t') return false;
     return true;
 }
 
 /**
- * Extract reference link IDs from text (e.g., "1670-042" from "[KeyRemap4MacBook][1670-042]")
- * Returns a dynamically allocated array of strings (IDs), with NULL terminator
- * Caller must free each string and the array itself
+ * Check if a line looks like a table row (starts with | after optional indent).
+ * Used to avoid treating : Caption as a definition when it's a table caption.
  */
-static char **extract_reference_link_ids(const char *text, size_t *count) {
-    if (!text || !count) return NULL;
-
-    *count = 0;
-    size_t capacity = 16;
-    char **ids = malloc(capacity * sizeof(char*));
-    if (!ids) return NULL;
-
-    const char *p = text;
-    while (*p) {
-        if (*p == '[') {
-            const char *text_start = p + 1;
-            const char *text_end = strchr(text_start, ']');
-            if (text_end) {
-                if (text_end[1] == '[' && text_end[2] == ']') {
-                    /* Found shortcut reference [text][] - use text as the ID */
-                    size_t text_len = text_end - text_start;
-                    if (text_len > 0) {
-                        char *id = malloc(text_len + 1);
-                        if (id) {
-                            memcpy(id, text_start, text_len);
-                            id[text_len] = '\0';
-
-                            /* Check if we already have this ID */
-                            bool found = false;
-                            for (size_t i = 0; i < *count; i++) {
-                                if (strcmp(ids[i], id) == 0) {
-                                    found = true;
-                                    free(id);
-                                    break;
-                                }
-                            }
-
-                            if (!found) {
-                                /* Add to array */
-                                if (*count >= capacity) {
-                                    capacity *= 2;
-                                    char **new_ids = realloc(ids, capacity * sizeof(char*));
-                                    if (!new_ids) {
-                                        free(id);
-                                        break;
-                                    }
-                                    ids = new_ids;
-                                }
-                                ids[*count] = id;
-                                (*count)++;
-                            }
-                        }
-                    }
-                    p = text_end + 3;  /* Skip past ]] */
-                    continue;
-                } else if (text_end[1] == '[') {
-                    /* Found [text][ref] pattern */
-                    const char *ref_start = text_end + 2;
-                    const char *ref_end = strchr(ref_start, ']');
-                    if (ref_end) {
-                        /* Extract the reference ID */
-                        size_t ref_len = ref_end - ref_start;
-                        if (ref_len > 0) {
-                            char *id = malloc(ref_len + 1);
-                            if (id) {
-                                memcpy(id, ref_start, ref_len);
-                                id[ref_len] = '\0';
-
-                                /* Check if we already have this ID */
-                                bool found = false;
-                                for (size_t i = 0; i < *count; i++) {
-                                    if (strcmp(ids[i], id) == 0) {
-                                        found = true;
-                                        free(id);
-                                        break;
-                                    }
-                                }
-
-                                if (!found) {
-                                    /* Add to array */
-                                    if (*count >= capacity) {
-                                        capacity *= 2;
-                                        char **new_ids = realloc(ids, capacity * sizeof(char*));
-                                        if (!new_ids) {
-                                            free(id);
-                                            break;
-                                        }
-                                        ids = new_ids;
-                                    }
-                                    ids[*count] = id;
-                                    (*count)++;
-                                }
-                            }
-                        }
-                        p = ref_end + 1;
-                        continue;
-                    }
-                }
-            }
-        }
-        p++;
-    }
-
-    /* Add NULL terminator */
-    if (*count >= capacity) {
-        char **new_ids = realloc(ids, (capacity + 1) * sizeof(char*));
-        if (new_ids) ids = new_ids;
-    }
-    if (ids) ids[*count] = NULL;
-
-    return ids;
+static bool is_table_row_line(const char *line, size_t len) {
+    if (!line || len == 0) return false;
+    size_t i = 0;
+    while (i < len && (line[i] == ' ' || line[i] == '\t')) i++;
+    return i < len && line[i] == '|';
 }
 
 /**
- * Extract specific reference definitions from the full reference definitions string
- * based on a list of reference IDs
- * Returns a string containing only the needed definitions, or NULL if none found
- * Caller must free the returned string
+ * Check if the next non-blank line after pos is a table row. Used for "caption before table".
  */
-static char *extract_specific_reference_definitions(const char *all_refs, char **needed_ids) {
-    if (!all_refs || !needed_ids || !needed_ids[0]) return NULL;
-
-    size_t result_capacity = 1024;
-    size_t result_len = 0;
-    char *result = malloc(result_capacity);
-    if (!result) return NULL;
-    result[0] = '\0';
-
-    const char *p = all_refs;
-    while (*p) {
-        const char *line_start = p;
-        const char *line_end = strchr(p, '\n');
-        if (!line_end) line_end = p + strlen(p);
-
-        /* Skip leading whitespace */
-        const char *content_start = line_start;
-        while (content_start < line_end && (*content_start == ' ' || *content_start == '\t')) {
-            content_start++;
-        }
-
-        /* Check if this is a reference link definition: [id]: URL */
-        if (content_start < line_end && *content_start == '[') {
-            const char *id_end = strchr(content_start + 1, ']');
-            if (id_end && id_end < line_end && id_end[1] == ':') {
-                /* Extract the ID from this definition */
-                size_t def_id_len = id_end - (content_start + 1);
-                char *def_id = malloc(def_id_len + 1);
-                if (def_id) {
-                    memcpy(def_id, content_start + 1, def_id_len);
-                    def_id[def_id_len] = '\0';
-
-                    /* Check if this ID is in our needed list */
-                    bool needed = false;
-                    for (size_t i = 0; needed_ids[i]; i++) {
-                        if (strcmp(needed_ids[i], def_id) == 0) {
-                            needed = true;
-                            break;
-                        }
-                    }
-
-                    if (needed) {
-                        /* Include this definition */
-                        size_t line_len = line_end - line_start;
-                        if (line_end < p + strlen(p) && *line_end == '\n') {
-                            line_len++; /* Include newline */
-                        }
-
-                        /* Expand buffer if needed */
-                        if (result_len + line_len + 1 >= result_capacity) {
-                            result_capacity = (result_len + line_len + 1) * 2;
-                            char *new_result = realloc(result, result_capacity);
-                            if (!new_result) {
-                                free(def_id);
-                                break;
-                            }
-                            result = new_result;
-                        }
-
-                        /* Copy the line */
-                        memcpy(result + result_len, line_start, line_len);
-                        result_len += line_len;
-                        result[result_len] = '\0';
-                    }
-
-                    free(def_id);
-                }
-            }
-        }
-
-        /* Move to next line */
-        p = line_end;
-        if (*p == '\n') p++;
+static bool next_nonblank_line_is_table(const char *pos, const char *text_end) {
+    while (pos < text_end) {
+        if (*pos == '\n') { pos++; continue; }
+        const char *line_end = strchr(pos, '\n');
+        if (!line_end) line_end = text_end;
+        const char *p = pos;
+        while (p < line_end && (*p == ' ' || *p == '\t')) p++;
+        if (p < line_end) return *p == '|';
+        pos = line_end + (line_end < text_end && *line_end == '\n' ? 1 : 0);
     }
+    return false;
+}
 
-    if (result_len == 0) {
-        free(result);
-        return NULL;
+/** True if content at p looks like a list marker (- , * , + , or digit+. ) */
+static bool looks_like_list_marker(const char *p) {
+    if (*p == '-' || *p == '*' || *p == '+')
+        return (p[1] == ' ' || p[1] == '\t');
+    if (isdigit((unsigned char)*p)) {
+        while (isdigit((unsigned char)*p)) p++;
+        return (*p == '.' && (p[1] == ' ' || p[1] == '\t'));
     }
-
-    return result;
+    return false;
 }
 
 /**
- * Extract all reference link definitions from the document
- * Returns a string containing all reference definitions, or NULL if none found
- * Caller must free the returned string
+ * True if line is an indented code block (4+ spaces or tab at start, not a list line).
+ * Used to skip definition list processing inside indented code blocks.
  */
-static char *extract_reference_definitions(const char *text) {
-    if (!text) return NULL;
-
-    size_t text_len = strlen(text);
-    size_t refs_capacity = text_len + 1;
-    char *refs = malloc(refs_capacity);
-    if (!refs) return NULL;
-    refs[0] = '\0';
-
-    const char *p = text;
-    size_t refs_len = 0;
-
-    while (*p) {
-        const char *line_start = p;
-        const char *line_end = strchr(p, '\n');
-        if (!line_end) line_end = p + strlen(p);
-
-        /* Skip leading whitespace */
-        const char *content_start = line_start;
-        while (content_start < line_end && (*content_start == ' ' || *content_start == '\t')) {
-            content_start++;
-        }
-
-        /* Check if this is a reference link definition: [id]: URL */
-        if (content_start < line_end && *content_start == '[') {
-            const char *id_end = strchr(content_start + 1, ']');
-            if (id_end && id_end < line_end && id_end[1] == ':') {
-                /* This is a reference definition - extract the entire line */
-                size_t line_len = line_end - line_start;
-                if (line_end < p + strlen(p) && *line_end == '\n') {
-                    line_len++; /* Include newline */
-                }
-
-                /* Check if we need to expand the buffer */
-                if (refs_len + line_len + 1 >= refs_capacity) {
-                    refs_capacity = (refs_len + line_len + 1) * 2;
-                    char *new_refs = realloc(refs, refs_capacity);
-                    if (!new_refs) {
-                        free(refs);
-                        return NULL;
-                    }
-                    refs = new_refs;
-                }
-
-                /* Copy the line */
-                memcpy(refs + refs_len, line_start, line_len);
-                refs_len += line_len;
-                refs[refs_len] = '\0';
-            }
-        }
-
-        /* Move to next line */
-        p = line_end;
-        if (*p == '\n') p++;
-    }
-
-    if (refs_len == 0) {
-        free(refs);
-        return NULL;
-    }
-
-    return refs;
+static bool line_is_indented_code_block(const char *line, size_t len) {
+    if (len == 0) return false;
+    if (line[0] == '\t') {
+        return len > 1 && !looks_like_list_marker(line + 1);
+    }
+    if (len < 4 || line[0] != ' ' || line[1] != ' ' || line[2] != ' ' || line[3] != ' ')
+        return false;
+    const char *content = line + 4;
+    while (content < line + len && *content == ' ') content++;
+    return (content < line + len) && !looks_like_list_marker(content);
 }
 
 /**
- * Open block - called when we see a ':' character that might start a definition
+ * Scans line for inline code backticks, updates state for next line, and returns
+ * whether sep_pos is inside an inline code span. Single backticks toggle; 3+ are
+ * fenced blocks (handled elsewhere). Used to skip definition processing inside
+ * inline code spans, including multi-line spans like `term::def\n :more:`.
  */
-static cmark_node *open_block(cmark_syntax_extension *ext,
-                              int indented,
-                              cmark_parser *parser,
-                              cmark_node *parent_container,
-                              unsigned char *input,
-                              int len) {
-    (void)ext;
-    if (indented > 3) {
-        return NULL; /* Too indented */
-    }
-
-    /* Check for 4+ leading spaces - these are table captions, not definition lists */
-    int leading_spaces = 0;
-    while (leading_spaces < len && leading_spaces < 10 && input[leading_spaces] == ' ') {
-        leading_spaces++;
-    }
-    if (leading_spaces >= 4) {
-        return NULL; /* Table caption, not definition list */
-    }
-
-    int def_indent;
-    if (!is_definition_line(input, len, &def_indent)) {
-        return NULL;
-    }
-
-    /* Check if the line contains an IAL (Inline Attribute List) like {#id .class} */
-    /* Lines with IALs are almost always table captions, not definition lists */
-    const unsigned char *p = input;
-    const unsigned char *end = input + len;
-    while (p < end) {
-        if (*p == '{') {
-            p++;
-            /* Check if it looks like an IAL: {# or {. or {: */
-            if (p < end && (*p == '#' || *p == '.' || *p == ':')) {
-                /* Look for closing } */
-                while (p < end && *p != '}') {
-                    p++;
-                }
-                if (p < end && *p == '}') {
-                    return NULL; /* This is a table caption, not a definition list */
-                }
-            }
+static bool scan_inline_code_for_sep(const char *line, size_t len, int sep_pos,
+                                     bool in_span_at_start, bool *out_in_span_at_end) {
+    bool in = in_span_at_start;
+    bool sep_inside = false;
+    for (size_t i = 0; i < len; i++) {
+        if ((int)i == sep_pos) sep_inside = in;
+        if (line[i] == '`') {
+            int count = 1;
+            while (i + (size_t)count < len && line[i + count] == '`') count++;
+            if (count == 1) in = !in;
+            i += (size_t)(count - 1);
         }
-        p++;
-    }
-
-    /* Safety check: parent_container must be valid */
-    if (!parent_container) {
-        return NULL;
     }
-
-    /* Additional safety: verify parent_container is a valid node type */
-    cmark_node_type parent_type = cmark_node_get_type(parent_container);
-
-    /* Check if previous block was a paragraph (term) */
-    /* Only try to get last child for node types that support children */
-    cmark_node *prev = NULL;
-    if (parent_type == CMARK_NODE_DOCUMENT ||
-        parent_type == CMARK_NODE_BLOCK_QUOTE ||
-        parent_type == CMARK_NODE_LIST ||
-        parent_type == CMARK_NODE_ITEM ||
-        parent_type == APEX_NODE_DEFINITION_LIST ||
-        parent_type == APEX_NODE_DEFINITION_DATA) {
-        prev = cmark_node_last_child(parent_container);
-    } else {
-        /* For other node types, don't try to get last child */
-        return NULL;
-    }
-
-    if (!prev) {
-        return NULL;
-    }
-
-    cmark_node_type prev_type = cmark_node_get_type(prev);
-    if (prev_type != CMARK_NODE_PARAGRAPH) {
-        return NULL;
-    }
-
-    /* Additional safety: verify prev is still valid and attached to parent */
-    cmark_node *prev_parent = cmark_node_parent(prev);
-    if (prev_parent != parent_container) {
-        return NULL;
-    }
-
-    /* Create definition list container */
-    cmark_node *def_list = cmark_node_new_with_mem(APEX_NODE_DEFINITION_LIST, parser->mem);
-    if (!def_list) return NULL;
-
-    /* Convert previous paragraph to term */
-    cmark_node *term = cmark_node_new_with_mem(APEX_NODE_DEFINITION_TERM, parser->mem);
-    if (!term) {
-        cmark_node_free(def_list);
-        return NULL;
-    }
-
-    /* Move paragraph children to term - but DON'T unlink prev itself */
-    /* Unlinking prev during parsing causes segfaults because the parser is still using it */
-    cmark_node *child;
-    while ((child = cmark_node_first_child(prev))) {
-        cmark_node_unlink(child);
-        cmark_node_append_child(term, child);
-    }
-
-    cmark_node_append_child(def_list, term);
-    return def_list;
+    *out_in_span_at_end = in;
+    return (sep_pos >= 0 && (size_t)sep_pos < len) ? sep_inside : false;
 }
 
 /**
- * Match block - check if a line continues a definition list
+ * Check if we're inside a fenced code block (```) - don't process definition lists there
  */
-static int match_block(cmark_syntax_extension *ext,
-                      cmark_parser *parser,
-                      unsigned char *input,
-                      int len,
-                      cmark_node *container) {
-    (void)ext;
-    (void)parser;
-    if (cmark_node_get_type(container) != APEX_NODE_DEFINITION_LIST &&
-        cmark_node_get_type(container) != APEX_NODE_DEFINITION_DATA) {
-        return 0;
+static bool is_code_fence_line(const char *line, size_t len) {
+    const char *p = line;
+    while (p < line + len && (*p == ' ' || *p == '\t')) p++;
+    if (p + 3 <= line + len && p[0] == '`' && p[1] == '`' && p[2] == '`') {
+        return true;
     }
-
-    int def_indent;
-    if (is_definition_line(input, len, &def_indent)) {
-        return 1; /* This line continues the definition list */
-    }
-
-    /* Also continue if line is blank or indented (block content in definition) */
-    if (len == 0 || (len > 0 && (input[0] == ' ' || input[0] == '\t'))) {
-        if (cmark_node_get_type(container) == APEX_NODE_DEFINITION_DATA) {
-            return 1; /* Block content in definition */
-        }
-    }
-
-    return 0;
+    return false;
 }
 
 /**
- * Can contain - definition data can contain block-level content
+ * Render inline content (term or definition) with full document context so cmark
+ * can resolve reference links. Parses full_doc + "\n\n" + content so ref defs are
+ * available. Returns HTML of the last block (our content), stripping <p></p>.
+ * Caller must free the returned string.
  */
-static int can_contain(cmark_syntax_extension *ext,
-                      cmark_node *node,
-                      cmark_node_type child_type) {
-    (void)ext;
-    if (cmark_node_get_type(node) == APEX_NODE_DEFINITION_DATA) {
-        /* Definition data can contain any block-level content */
-        return child_type == CMARK_NODE_PARAGRAPH ||
-               child_type == CMARK_NODE_CODE_BLOCK ||
-               child_type == CMARK_NODE_BLOCK_QUOTE ||
-               child_type == CMARK_NODE_LIST ||
-               child_type == CMARK_NODE_HEADING ||
-               child_type == CMARK_NODE_THEMATIC_BREAK;
+static char *render_inline_with_doc(const char *content, size_t content_len,
+                                    const char *full_doc, size_t full_doc_len, bool unsafe) {
+    size_t buf_len = full_doc_len + 2 + content_len + 1;
+    char *buf = malloc(buf_len);
+    if (!buf) return NULL;
+    memcpy(buf, full_doc, full_doc_len);
+    buf[full_doc_len] = '\n';
+    buf[full_doc_len + 1] = '\n';
+    memcpy(buf + full_doc_len + 2, content, content_len);
+    buf[buf_len - 1] = '\0';
+
+    int opts = CMARK_OPT_DEFAULT | CMARK_OPT_SMART;
+    if (unsafe) opts |= CMARK_OPT_UNSAFE | CMARK_OPT_LIBERAL_HTML_TAG;
+    cmark_parser *cp = cmark_parser_new(opts);
+    if (!cp) { free(buf); return NULL; }
+    cmark_parser_feed(cp, buf, (int)(buf_len - 1));
+    free(buf);
+    cmark_node *doc = cmark_parser_finish(cp);
+    cmark_parser_free(cp);
+    if (!doc) return NULL;
+
+    cmark_node *last = cmark_node_last_child(doc);
+    if (!last) {
+        cmark_node_free(doc);
+        return NULL;
     }
-    return 0;
+    char *html = cmark_render_html(last, opts, NULL);
+    cmark_node_free(doc);
+    if (!html) return NULL;
+
+    /* Strip <p> and </p> wrapper, return inner content */
+    char *content_start = html;
+    if (strncmp(html, "<p>", 3) == 0) content_start = html + 3;
+    size_t html_len = strlen(content_start);
+    if (html_len > 5 && strcmp(content_start + html_len - 5, "</p>\n") == 0)
+        html_len -= 5;
+    else if (html_len > 4 && strcmp(content_start + html_len - 4, "</p>") == 0)
+        html_len -= 4;
+    char *result = malloc(html_len + 1);
+    if (result) {
+        memcpy(result, content_start, html_len);
+        result[html_len] = '\0';
+    }
+    free(html);
+    return result;
 }
 
 /**
- * Process definition lists - convert : syntax to HTML
- * This is a preprocessing approach
+ * Process one-line definition lists: Term :: Definition -> <dl><dt>Term</dt><dd>Definition</dd></dl>
+ * Returns newly allocated string with HTML, or NULL if no changes (caller uses original).
  */
 char *apex_process_definition_lists(const char *text, bool unsafe) {
     if (!text) return NULL;
 
     size_t text_len = strlen(text);
 
-    /* Quick scan: check if any definition list patterns exist before processing */
-    /* Definition lists start with : (after up to 3 spaces or blockquote) */
-    bool has_def_list_pattern = false;
-    const char *p = text;
-    const char *end = text + text_len;
-
-    while (p < end) {
-        /* Look for start of line (beginning of text or after newline) */
-        if (p == text || p[-1] == '\n') {
-            const char *check = p;
-            int spaces = 0;
-
-            /* Skip up to 3 leading spaces */
-            while (spaces < 3 && check < end && *check == ' ') {
-                spaces++;
-                check++;
-            }
-
-            /* Skip blockquote prefix (>) */
-            while (check < end && *check == '>') {
-                check++;
-                /* Skip optional space after > */
-                if (check < end && (*check == ' ' || *check == '\t')) {
-                    check++;
-                }
-            }
-
-            /* Check if this line starts with : followed by space/tab */
-            if (check < end && *check == ':' && (check + 1) < end && (check[1] == ' ' || check[1] == '\t')) {
-                has_def_list_pattern = true;
+    /* Quick scan: check for :: or : at line start (skip reference defs [id]: url) */
+    bool has_pattern = false;
+    const char *scan = text;
+    while (*scan) {
+        if (scan[0] == ':' && scan[1] == ':') {
+            /* Skip ::: or more (div/custom element fence) - only match exactly :: */
+            if (scan > text && scan[-1] == ':') { scan++; continue; }
+            if (scan[2] == ':') { scan++; continue; }
+            const char *line_start = scan;
+            while (line_start > text && line_start[-1] != '\n') line_start--;
+            const char *p = line_start;
+            while (p < scan && (*p == ' ' || *p == '\t')) p++;
+            if (p >= scan || *p != '[') { has_pattern = true; break; }
+        }
+        if ((scan == text || scan[-1] == '\n') && *scan) {
+            const char *p = scan;
+            while (*p == ' ' || *p == '\t') p++;
+            if (*p == ':' && (p[1] == ' ' || p[1] == '\t' || (p[1] == ':' && (p[2] == ' ' || p[2] == '\t')))) {
+                has_pattern = true;
                 break;
             }
-
-            /* Move to next line */
-            while (p < end && *p != '\n') {
-                p++;
-            }
-            if (p < end) p++; /* Skip the newline */
-        } else {
-            p++;
         }
+        scan++;
     }
+    if (!has_pattern) return NULL;
 
-    /* Early exit if no definition list patterns found */
-    if (!has_def_list_pattern) {
-        return NULL;
-    }
-
-    size_t output_capacity = text_len * 3;  /* Generous for HTML tags */
-    char *output = malloc(output_capacity + 1);  /* +1 for null terminator */
+    size_t output_capacity = text_len * 3;
+    char *output = malloc(output_capacity + 1);
     if (!output) return NULL;
 
-    /* Extract all reference link definitions from the document */
-    char *ref_definitions = extract_reference_definitions(text);
-
     const char *read = text;
     char *write = output;
-    /* Reserve 1 byte for null terminator, so we have output_capacity bytes to write */
     size_t remaining = output_capacity;
 
-    /* Helper macro to expand buffer if needed */
-    /* Always reserves 1 byte for null terminator */
-    #define ENSURE_SPACE(needed) do { \
-        /* We need 'needed' bytes for content + 1 for null terminator = needed+1 total */ \
-        /* So we need remaining > needed (not >=) to have space for both */ \
-        if (remaining <= (needed)) { \
-            size_t used = write - output; \
-            /* Allocate enough space: used + needed + 1 for null terminator, then double for safety */ \
-            size_t min_capacity = used + (needed) + 1; \
-            output_capacity = (min_capacity < 1024) ? 2048 : min_capacity * 2; \
-            char *new_output = realloc(output, output_capacity + 1); \
-            if (!new_output) { \
-                free(output); \
-                free(ref_definitions); \
-                return NULL; \
-            } \
-            output = new_output; \
-            write = output + used; \
-            remaining = output_capacity - used; \
-        } \
-    } while(0)
+#define ENSURE_SPACE(needed) do { \
+    if (remaining <= (needed)) { \
+        size_t used = write - output; \
+        size_t min_capacity = used + (needed) + 1; \
+        output_capacity = (min_capacity < 1024) ? 2048 : min_capacity * 2; \
+        char *new_output = realloc(output, output_capacity + 1); \
+        if (!new_output) { free(output); return NULL; } \
+        output = new_output; \
+        write = output + used; \
+        remaining = output_capacity - used; \
+    } \
+} while(0)
 
     bool in_def_list = false;
-    bool in_blockquote_context = false;  /* Track if we're processing blockquote-prefixed definition lists */
-    int blockquote_depth = 0;  /* Track nesting depth of blockquotes (number of > characters) */
+    bool in_code_block = false;
+    bool in_indented_code_block = false;
+    bool in_inline_code_span = false;
     char term_buffer[4096];
     int term_len = 0;
-    bool term_has_blockquote = false;  /* Track if buffered term has blockquote prefix */
-    int term_blockquote_depth = 0;  /* Track blockquote depth of buffered term */
-    bool found_any_def_list = false;  /* Track if we actually created any definition lists */
-    bool in_code_block = false;  /* Track if we're inside a fenced code block */
-    bool skipped_blank_after_term = false;  /* Track if we skipped a blank line after a buffered term */
-
-    const char *prev_read_pos = NULL;
-    int iteration_count = 0;
-    const int MAX_ITERATIONS = 1000000;  /* Safety limit */
+    bool dd_open = false;  /* True when we output <dd> but not yet </dd> (for Kramdown continuation) */
+    bool prev_line_was_table_row = false;
 
     while (*read) {
-        /* Safety: prevent infinite loops */
-        if (++iteration_count > MAX_ITERATIONS) {
-            /* Something is wrong - return original text to avoid hanging */
-            free(output);
-            free(ref_definitions);
-            return strdup(text);
-        }
-
-        /* Safety: if we haven't advanced, break to prevent infinite loop */
-        if (prev_read_pos == read) {
-            break;
-        }
-        prev_read_pos = read;
-
         const char *line_start = read;
         const char *line_end = strchr(read, '\n');
-        if (!line_end) {
-            /* No newline found - we're at the last line */
-            /* Find the end by looking for null terminator */
-            line_end = read;
-            while (*line_end != '\0') line_end++;
-            /* If line_end == read, we're at the end - break */
-            if (line_end == read) {
-                break;
-            }
-        }
+        if (!line_end) line_end = read + strlen(read);
 
-        size_t line_length = line_end - line_start;
+        size_t line_length = (size_t)(line_end - line_start);
+        int sep = -1;  /* One-line def separator pos; -1 = none (used for inline code state update) */
 
-        /* Check for fenced code blocks (```) */
-        const char *code_check = line_start;
-        while (code_check < line_end && (*code_check == ' ' || *code_check == '\t')) code_check++;
-        bool is_code_fence = false;
-        bool is_closing_fence = false;  /* True if this is a closing fence (no language identifier) */
-        if (code_check + 3 <= line_end &&
-            code_check[0] == '`' && code_check[1] == '`' && code_check[2] == '`') {
-            is_code_fence = true;
-            /* Check if this is a closing fence (just ``` with optional whitespace, no language identifier) */
-            const char *after_fence = code_check + 3;
-            while (after_fence < line_end && (*after_fence == ' ' || *after_fence == '\t')) after_fence++;
-            is_closing_fence = (after_fence >= line_end || *after_fence == '\n' || *after_fence == '\r');
+        /* Track indented code blocks (4+ spaces or tab, not list continuation) */
+        if (read == text || read[-1] == '\n') {
+            bool this_line_indented = line_is_indented_code_block(line_start, line_length);
+            if (this_line_indented) {
+                in_indented_code_block = true;
+            } else {
+                /* Non-blank line without indent ends the block */
+                bool is_blank = (line_length == 0 || (line_length == 1 && (*line_start == '\r' || *line_start == '\n')));
+                if (!is_blank) in_indented_code_block = false;
+            }
         }
 
-        /* If we're inside a code block OR this is a code fence line, just copy the line as-is */
-        if (in_code_block || is_code_fence) {
-            /* Handle code block state when we see a fence */
-            if (is_code_fence) {
-                bool was_in_code_block = in_code_block;
-                /* If we're inside a code block, only a closing fence (no language identifier) closes it.
-                   Otherwise, any fence opens a new code block. */
-                if (in_code_block) {
-                    if (is_closing_fence) {
-                        in_code_block = false;
-                    }
-                    /* If it's an opening fence with language identifier inside a code block, treat as content (don't change state) */
-                } else {
-                    in_code_block = true;
-                }
-                /* If we're entering a code block, clear any pending definition list state */
-                if (in_code_block && !was_in_code_block) {
-                    if (in_def_list) {
-                        /* Close any open definition list */
-                        const char *dl_end = "</dl>\n";
-                        size_t dl_end_len = strlen(dl_end);
-                        ENSURE_SPACE(dl_end_len + 1);
-                        memcpy(write, dl_end, dl_end_len);
-                        write += dl_end_len;
-                        remaining -= dl_end_len;
-                    }
-                    in_def_list = false;
-                    term_len = 0;
-                    term_has_blockquote = false;
-                    term_blockquote_depth = 0;
-                    skipped_blank_after_term = false;
-                }
-                /* If we're exiting a code block, clear any pending definition list state */
-                if (!in_code_block && was_in_code_block) {
-                    in_def_list = false;
-                    term_len = 0;
-                    term_has_blockquote = false;
-                    term_blockquote_depth = 0;
-                    skipped_blank_after_term = false;
-                }
+        /* Track code blocks */
+        if (is_code_fence_line(line_start, line_length)) {
+            in_code_block = !in_code_block;
+            if (in_def_list && in_code_block) {
+                /* Close def list before code block */
+                ENSURE_SPACE(10);
+                memcpy(write, "</dl>\n", 6);
+                write += 6;
+                remaining -= 6;
+                in_def_list = false;
             }
-            ENSURE_SPACE(line_length + 1);
+            ENSURE_SPACE(line_length + 2);
             memcpy(write, line_start, line_length);
             write += line_length;
             remaining -= line_length;
             *write++ = '\n';
             remaining--;
-            read = line_end;
-            if (*read == '\n') {
-                read++;
-            }
+            read = line_end + (line_end < text + text_len && *line_end == '\n' ? 1 : 0);
             continue;
         }
 
-        /* Skip table rows (lines that start with |) */
-        const char *p = line_start;
-        while (p < line_end && (*p == ' ' || *p == '\t')) p++;
-        bool is_table_row = (p < line_end && *p == '|');
-
-        /* Check if line is a list item (starts with -, *, +, or number.) */
-        const char *list_check = line_start;
-        int list_spaces = 0;
-        while (list_check < line_end && (*list_check == ' ' || *list_check == '\t') && list_spaces < 4) {
-            list_spaces++;
-            list_check++;
-        }
-        bool is_list_item = false;
-        if (list_check < line_end) {
-            if (*list_check == '-' || *list_check == '*' || *list_check == '+') {
-                /* Check if followed by space or tab */
-                if (list_check + 1 < line_end && (list_check[1] == ' ' || list_check[1] == '\t')) {
-                    is_list_item = true;
-                }
-            } else if (*list_check >= '0' && *list_check <= '9') {
-                /* Check for numbered list (digit followed by . and space) */
-                const char *num_check = list_check;
-                while (num_check < line_end && *num_check >= '0' && *num_check <= '9') {
-                    num_check++;
-                }
-                if (num_check < line_end && *num_check == '.' &&
-                    num_check + 1 < line_end && (num_check[1] == ' ' || num_check[1] == '\t')) {
-                    is_list_item = true;
-                }
-            }
+        if (in_code_block) {
+            ENSURE_SPACE(line_length + 2);
+            memcpy(write, line_start, line_length);
+            write += line_length;
+            remaining -= line_length;
+            *write++ = '\n';
+            remaining--;
+            read = line_end + (line_end < text + text_len && *line_end == '\n' ? 1 : 0);
+            continue;
         }
 
-        /* Check if line starts with : (definition) */
-        /* Also handle blockquote prefixes: > : or >: */
-        p = line_start;
-        int spaces = 0;
-        while (*p == ' ' && spaces < 3 && p < line_end) {
-            spaces++;
-            p++;
+        /* Skip definition processing inside indented code blocks */
+        if (in_indented_code_block) {
+            ENSURE_SPACE(line_length + 2);
+            memcpy(write, line_start, line_length);
+            write += line_length;
+            remaining -= line_length;
+            *write++ = '\n';
+            remaining--;
+            read = line_end + (line_end < text + text_len && *line_end == '\n' ? 1 : 0);
+            continue;
         }
 
-        /* Check for blockquote prefix (may be nested: > > >) */
-        bool has_blockquote_prefix = false;
-        int current_blockquote_depth = 0;
-        while (p < line_end && *p == '>') {
-            has_blockquote_prefix = true;
-            current_blockquote_depth++;
-            p++;
-            /* Skip optional space after > */
-            if (p < line_end && (*p == ' ' || *p == '\t')) {
-                p++;
+        /* Check for Kramdown-style definition: : Definition (requires buffered term) */
+        bool is_kramdown_def = !in_code_block && !in_inline_code_span && is_kramdown_def_line(line_start, line_length);
+        if (is_kramdown_def) {
+            /* Skip reference link definitions [id]: url */
+            const char *p = line_start;
+            while (p < line_end && (*p == ' ' || *p == '\t')) p++;
+            if (p < line_end && *p == '[') {
+                is_kramdown_def = false;  /* Reference def, not a definition line */
             }
         }
-
-        bool is_def_line = false;
-        /* Only check for definition line if it's not a table row or list item */
-        /* Definition lines must start with : (after whitespace/blockquote), not contain : */
-        /* Also skip if we're inside a code block (shouldn't happen due to early continue, but be safe) */
-        if (!in_code_block && !is_table_row && !is_list_item && p < line_end && *p == ':' && (p + 1) < line_end &&
-            (p[1] == ' ' || p[1] == '\t')) {
-            /* Double-check: make sure : is at the start of the line content (after whitespace/blockquote) */
-            /* p already points after whitespace and blockquote, so if *p == ':', it's a definition line */
-            is_def_line = true;
-
-            /* Check if this : Caption line is followed by a table */
-            /* If so, skip processing it as a definition list - let table caption detection handle it */
-            /* Calculate end of text buffer safely - use original text parameter */
-            const char *text_end = text + text_len; /* End of entire text buffer */
-            const char *next_line_start = line_end;
-            if (next_line_start < text_end && *next_line_start == '\n') {
-                next_line_start++; /* Skip the newline */
-            }
-
-            /* Skip blank lines to find the next non-blank line */
-            /* Safety: limit look-ahead to prevent infinite loops or buffer overruns */
-            int look_ahead_count = 0;
-            const int MAX_LOOK_AHEAD = 100;
-            bool found_table = false;
-            while (next_line_start < text_end && *next_line_start != '\0' && look_ahead_count < MAX_LOOK_AHEAD) {
-                look_ahead_count++;
-                const char *check_line = next_line_start;
-
-                /* Find end of line - only search within remaining buffer */
-                const char *check_line_end = NULL;
-                if (check_line < text_end) {
-                    /* Search for newline only within remaining buffer */
-                    const char *search_start = check_line;
-                    while (search_start < text_end && *search_start != '\n' && *search_start != '\0') {
-                        search_start++;
-                    }
-                    if (search_start < text_end && *search_start == '\n') {
-                        check_line_end = search_start;
-                    } else {
-                        /* No newline found - this is the last line */
-                        check_line_end = text_end;
-                    }
-                } else {
-                    /* Already past end */
-                    check_line_end = text_end;
-                }
-
-                /* Skip whitespace on this line - ensure we don't go past check_line_end */
-                while (check_line < check_line_end && check_line < text_end &&
-                       (*check_line == ' ' || *check_line == '\t')) {
-                    check_line++;
-                }
-
-                /* If line is empty (just whitespace), continue to next line */
-                if (check_line >= check_line_end || check_line >= text_end ||
-                    *check_line == '\r' || *check_line == '\0') {
-                    next_line_start = check_line_end;
-                    if (next_line_start < text_end && *next_line_start == '\n') {
-                        next_line_start++;
-                    }
-                    continue;
-                }
-
-                /* Check if this line starts with | (table row) - ensure we're within bounds */
-                if (check_line < text_end && *check_line == '|') {
-                    /* This : Caption is followed by a table - treat it as a table caption */
-                    /* Add 4 spaces to prevent definition list processing */
-                    is_def_line = false;
-                    found_table = true;
-                    /* Output line with 4 spaces added at the very beginning to prevent definition list matching */
-                    /* Calculate how many spaces we already have at the start */
-                    int existing_spaces = spaces;
-                    /* We need 4 total spaces at the start, so add (4 - existing_spaces) more */
-                    int spaces_to_add = 4 - existing_spaces;
-                    if (spaces_to_add < 0) spaces_to_add = 0;
-
-                    ENSURE_SPACE(spaces_to_add + line_length + 1);
-                    /* Add extra spaces at the very beginning */
-                    for (int i = 0; i < spaces_to_add; i++) {
-                        *write++ = ' ';
-                        remaining--;
-                    }
-                    /* Copy the entire original line */
-                    memcpy(write, line_start, line_length);
-                    write += line_length;
-                    remaining -= line_length;
-                    *write++ = '\n';
-                    remaining--;
-                    read = line_end;
-                    if (*read == '\n') {
-                        read++;
-                    }
-                    /* Break out of look-ahead loop since we found the table */
-                    break;
-                }
-
-                /* Found a non-blank line, stop looking */
-                break;
-            }
-
-            /* If we found a table, skip the rest of the line processing */
-            if (found_table) {
-                continue; /* Skip to next iteration of main while loop */
-            }
-        } else if (in_code_block && p < line_end && *p == ':') {
-            /* Found ':' in code block, skip definition list processing */
+        if (is_kramdown_def && prev_line_was_table_row) {
+            /* : Caption after table is a table caption, not a definition */
+            is_kramdown_def = false;
         }
-
-        if (is_def_line) {
-            /* Definition line */
-            if (!in_def_list) {
-                found_any_def_list = true;  /* We're creating a definition list */
-                /* Check if this definition list is in a blockquote context */
-                in_blockquote_context = has_blockquote_prefix || term_has_blockquote;
-                /* Use the maximum depth from current line or buffered term */
-                blockquote_depth = term_has_blockquote ? term_blockquote_depth : current_blockquote_depth;
-                if (has_blockquote_prefix && current_blockquote_depth > blockquote_depth) {
-                    blockquote_depth = current_blockquote_depth;
-                }
-
-                /* Clear the skipped blank flag - we're using the term now, blank line is ignored */
-                skipped_blank_after_term = false;
-
-                /* Start new definition list */
-                const char *dl_start = "<dl>\n";
-                size_t dl_len = strlen(dl_start);
-                    if (in_blockquote_context) {
-                        /* Add > prefix(es) at start of line for blockquote context */
-                        size_t prefix_needed = blockquote_depth * 2;
-                        /* Need prefix_needed + 1 for null terminator */
-                        ENSURE_SPACE(prefix_needed + 1);
-                        for (int i = 0; i < blockquote_depth && remaining > 2; i++) {
-                            *write++ = '>';
-                            *write++ = ' ';
-                            remaining -= 2;
-                        }
-                    }
-                /* Need dl_len + 1 for null terminator */
-                ENSURE_SPACE(dl_len + 1);
-                memcpy(write, dl_start, dl_len);
-                write += dl_len;
-                remaining -= dl_len;
-
-                /* Write term from buffer */
-                if (term_len > 0) {
-                    /* Strip blockquote prefix from term if present */
-                    const char *term_content = term_buffer;
-                    int term_content_len = term_len;
-                    if (term_has_blockquote) {
-                        /* Skip > and optional space */
-                        term_content = term_buffer;
-                        while (term_content < term_buffer + term_len &&
-                               (*term_content == '>' || *term_content == ' ' || *term_content == '\t')) {
-                            term_content++;
-                            term_content_len--;
-                        }
-                    }
-
-                    if (in_blockquote_context) {
-                        /* Add > prefix(es) at start of line for blockquote context */
-                        size_t prefix_needed = blockquote_depth * 2;
-                        /* Need prefix_needed + 1 for null terminator */
-                        ENSURE_SPACE(prefix_needed + 1);
-                        for (int i = 0; i < blockquote_depth && remaining > 2; i++) {
-                            *write++ = '>';
-                            *write++ = ' ';
-                            remaining -= 2;
-                        }
-                    }
-
-                    const char *dt_start = "<dt>";
-                    size_t dt_start_len = strlen(dt_start);
-                    /* Need dt_start_len + 1 for null terminator */
-                    ENSURE_SPACE(dt_start_len + 1);
-                    memcpy(write, dt_start, dt_start_len);
-                    write += dt_start_len;
-                    remaining -= dt_start_len;
-
-                    /* Parse term text as inline Markdown */
-                    char *term_html = NULL;
-                    if (term_content_len > 0) {
-                        /* Quick check: does this text contain any markdown syntax? */
-                        bool has_markdown = false;
-                        const char *p = term_content;
-                        const char *end = term_content + term_content_len;
-                        while (p < end) {
-                            char c = *p++;
-                            /* Check for common markdown patterns */
-                            if (c == '*' || c == '_' || c == '[' || c == ']' || c == '!' ||
-                                c == '`' || c == '\\' || (c == '<' && p < end && (*p == '!' || isalnum((unsigned char)*p)))) {
-                                has_markdown = true;
-                                break;
-                            }
-                        }
-
-                        if (!has_markdown) {
-                            /* Plain text - just HTML escape */
-                            size_t escaped_len = 0;
-                            for (const char *p = term_content; p < term_content + term_content_len; p++) {
-                                if (*p == '&') escaped_len += 5;  /* &amp; */
-                                else if (*p == '<' || *p == '>') escaped_len += 4;  /* &lt; &gt; */
-                                else if (*p == '"') escaped_len += 6;  /* &quot; */
-                                else escaped_len += 1;
-                            }
-                            term_html = malloc(escaped_len + 1);
-                            if (term_html) {
-                                char *out = term_html;
-                                for (const char *p = term_content; p < term_content + term_content_len; p++) {
-                                    if (*p == '&') { memcpy(out, "&amp;", 5); out += 5; }
-                                    else if (*p == '<') { memcpy(out, "&lt;", 4); out += 4; }
-                                    else if (*p == '>') { memcpy(out, "&gt;", 4); out += 4; }
-                                    else if (*p == '"') { memcpy(out, "&quot;", 6); out += 6; }
-                                    else *out++ = *p;
-                                }
-                                *out = '\0';
-                            }
-                        } else {
-                            /* Note: We don't prepend reference definitions here because:
-                             * 1. It causes cmark to hang on large files with many references
-                             * 2. Reference definitions are already available in the main document context
-                             * 3. Inline parsing should work with references from the main document
-                             */
-                            char *term_text = malloc(term_content_len + 1);
-                            if (term_text) {
-                                memcpy(term_text, term_content, term_content_len);
-                                term_text[term_content_len] = '\0';
-
-                                /* Parse as Markdown and render to HTML */
-                                int parser_opts = CMARK_OPT_DEFAULT | CMARK_OPT_SMART;  /* Enable smart typography */
-                                int render_opts = CMARK_OPT_DEFAULT;
-                                if (unsafe) {
-                                    parser_opts |= CMARK_OPT_UNSAFE;
-                                    parser_opts |= CMARK_OPT_LIBERAL_HTML_TAG;  /* Be liberal in interpreting inline HTML tags */
-                                    render_opts |= CMARK_OPT_UNSAFE;
-                                }
-
-                            /* Extract only the reference definitions actually used in this term */
-                            size_t final_term_len = term_content_len;
-                            char *final_term_text = term_text;
-                            if (ref_definitions) {
-                                size_t id_count = 0;
-                                char **needed_ids = extract_reference_link_ids(term_text, &id_count);
-                                if (needed_ids && id_count > 0) {
-                                    char *selected_refs = extract_specific_reference_definitions(ref_definitions, needed_ids);
-                                    if (selected_refs) {
-                                        size_t ref_len = strlen(selected_refs);
-                                        size_t new_size = ref_len + term_content_len + 2;  /* +2 for newline and null */
-                                        char *new_term_text = malloc(new_size);
-                                        if (new_term_text) {
-                                            size_t offset = 0;
-                                            memcpy(new_term_text, selected_refs, ref_len);
-                                            offset = ref_len;
-                                            if (ref_len > 0 && selected_refs[ref_len - 1] != '\n') {
-                                                new_term_text[offset++] = '\n';
-                                            }
-                                            memcpy(new_term_text + offset, term_text, term_content_len);
-                                            new_term_text[offset + term_content_len] = '\0';
-                                            free(term_text);
-                                            final_term_text = new_term_text;
-                                            final_term_len = offset + term_content_len;
-                                        }
-                                        free(selected_refs);
-                                    }
-                                    /* Free the IDs array */
-                                    for (size_t i = 0; i < id_count; i++) {
-                                        free(needed_ids[i]);
-                                    }
-                                    free(needed_ids);
-                                }
-                            }
-                            cmark_parser *temp_parser = cmark_parser_new(parser_opts);
-                            if (temp_parser) {
-                                cmark_parser_feed(temp_parser, final_term_text, final_term_len);
-                                cmark_node *doc = cmark_parser_finish(temp_parser);
-                                if (doc) {
-                                    /* Render and extract just the content (strip <p> tags) */
-                                    char *full_html = cmark_render_html(doc, render_opts, NULL);
-                                    if (full_html) {
-                                        /* Strip <p> and </p> tags if present */
-                                        char *content_start = full_html;
-                                        if (strncmp(content_start, "<p>", 3) == 0) {
-                                            content_start += 3;
-                                        }
-                                        char *content_end = content_start + strlen(content_start);
-                                        if (content_end > content_start + 4 &&
-                                            strcmp(content_end - 5, "</p>\n") == 0) {
-                                            content_end -= 5;
-                                            *content_end = '\0';
-                                        }
-                                        term_html = strdup(content_start);
-                                        free(full_html);
-                                    }
-                                    cmark_node_free(doc);
-                                }
-                                cmark_parser_free(temp_parser);
-                            }
-                            free(final_term_text);
-                        }
-                        }
-                    }
-
-                    /* Write processed HTML or original text */
-                    if (term_html) {
-                        size_t html_len = strlen(term_html);
-                        /* Need html_len + 1 for null terminator */
-                        ENSURE_SPACE(html_len + 1);
-                        memcpy(write, term_html, html_len);
-                        write += html_len;
-                        remaining -= html_len;
-                        free(term_html);
-                    } else {
-                        /* Need term_content_len + 1 for null terminator */
-                        ENSURE_SPACE((size_t)term_content_len + 1);
-                        memcpy(write, term_content, term_content_len);
-                        write += term_content_len;
-                        remaining -= (size_t)term_content_len;
-                    }
-
-                    const char *dt_end = "</dt>\n";
-                    size_t dt_end_len = strlen(dt_end);
-                    /* Need dt_end_len + 1 for null terminator */
-                    ENSURE_SPACE(dt_end_len + 1);
-                    memcpy(write, dt_end, dt_end_len);
-                    write += dt_end_len;
-                    remaining -= dt_end_len;
-
-                    term_len = 0;
-                    term_has_blockquote = false;
-                    skipped_blank_after_term = false;  /* Clear flag - we used the term */
-                }
-
-                in_def_list = true;
-            }
-
-            /* Write definition */
-            if (in_blockquote_context) {
-                /* Add > prefix(es) at start of line for blockquote context */
-                size_t prefix_needed = blockquote_depth * 2;
-                /* Need prefix_needed + 1 for null terminator */
-                ENSURE_SPACE(prefix_needed + 1);
-                for (int i = 0; i < blockquote_depth && remaining > 2; i++) {
-                    *write++ = '>';
-                    *write++ = ' ';
-                    remaining -= 2;
-                }
-            }
-
-            const char *dd_start = "<dd>";
-            size_t dd_start_len = strlen(dd_start);
-            /* Need dd_start_len + 1 for null terminator */
-            ENSURE_SPACE(dd_start_len + 1);
-            memcpy(write, dd_start, dd_start_len);
-            write += dd_start_len;
-            remaining -= dd_start_len;
-
-            /* Extract definition text (after : and space) */
-            p++;  /* Skip : */
-            while (p < line_end && (*p == ' ' || *p == '\t')) p++;
-
-            size_t def_text_len = line_end - p;
-
-            /* Parse definition text as inline Markdown */
-            char *def_html = NULL;
-            if (def_text_len > 0) {
-                /* Quick check: does this text contain any markdown syntax? */
-                bool has_markdown = false;
-                const char *check_p = p;
-                const char *check_end = p + def_text_len;
-                while (check_p < check_end) {
-                    char c = *check_p++;
-                    /* Check for common markdown patterns */
-                    if (c == '*' || c == '_' || c == '[' || c == ']' || c == '!' ||
-                        c == '`' || c == '\\' || (c == '<' && check_p < check_end && (*check_p == '!' || isalnum((unsigned char)*check_p)))) {
-                        has_markdown = true;
-                        break;
-                    }
-                }
-
-                if (!has_markdown) {
-                    /* Plain text - just HTML escape */
-                    size_t escaped_len = 0;
-                    for (const char *esc_p = p; esc_p < p + def_text_len; esc_p++) {
-                        if (*esc_p == '&') escaped_len += 5;  /* &amp; */
-                        else if (*esc_p == '<' || *esc_p == '>') escaped_len += 4;  /* &lt; &gt; */
-                        else if (*esc_p == '"') escaped_len += 6;  /* &quot; */
-                        else escaped_len += 1;
-                    }
-                    def_html = malloc(escaped_len + 1);
-                    if (def_html) {
-                        char *out = def_html;
-                        for (const char *esc_p = p; esc_p < p + def_text_len; esc_p++) {
-                            if (*esc_p == '&') { memcpy(out, "&amp;", 5); out += 5; }
-                            else if (*esc_p == '<') { memcpy(out, "&lt;", 4); out += 4; }
-                            else if (*esc_p == '>') { memcpy(out, "&gt;", 4); out += 4; }
-                            else if (*esc_p == '"') { memcpy(out, "&quot;", 6); out += 6; }
-                            else *out++ = *esc_p;
-                        }
-                        *out = '\0';
-                    }
-                } else {
-                    char *def_text = malloc(def_text_len + 1);
-                    if (def_text) {
-                        memcpy(def_text, p, def_text_len);
-                        def_text[def_text_len] = '\0';
-
-                        /* Parse as Markdown and render to HTML */
-                        int parser_opts = CMARK_OPT_DEFAULT | CMARK_OPT_SMART;  /* Enable smart typography */
-                        int render_opts = CMARK_OPT_DEFAULT;
-                        if (unsafe) {
-                            parser_opts |= CMARK_OPT_UNSAFE;
-                            parser_opts |= CMARK_OPT_LIBERAL_HTML_TAG;  /* Be liberal in interpreting inline HTML tags */
-                            render_opts |= CMARK_OPT_UNSAFE;
-                        }
-
-                    /* Extract only the reference definitions actually used in this definition */
-                    size_t final_def_len = def_text_len;
-                    char *final_def_text = def_text;
-                    if (ref_definitions) {
-                        size_t id_count = 0;
-                        char **needed_ids = extract_reference_link_ids(def_text, &id_count);
-                        if (needed_ids && id_count > 0) {
-                            char *selected_refs = extract_specific_reference_definitions(ref_definitions, needed_ids);
-                            if (selected_refs) {
-                                size_t ref_len = strlen(selected_refs);
-                                size_t new_size = ref_len + def_text_len + 2;  /* +2 for newline and null */
-                                char *new_def_text = malloc(new_size);
-                                if (new_def_text) {
-                                    size_t offset = 0;
-                                    memcpy(new_def_text, selected_refs, ref_len);
-                                    offset = ref_len;
-                                    if (ref_len > 0 && selected_refs[ref_len - 1] != '\n') {
-                                        new_def_text[offset++] = '\n';
-                                    }
-                                    memcpy(new_def_text + offset, def_text, def_text_len);
-                                    new_def_text[offset + def_text_len] = '\0';
-                                    free(def_text);
-                                    final_def_text = new_def_text;
-                                    final_def_len = offset + def_text_len;
-                                }
-                                free(selected_refs);
-                            }
-                            /* Free the IDs array */
-                            for (size_t i = 0; i < id_count; i++) {
-                                free(needed_ids[i]);
-                            }
-                            free(needed_ids);
-                        }
-                    }
-
-                    cmark_parser *temp_parser = cmark_parser_new(parser_opts);
-                    if (temp_parser) {
-                        cmark_parser_feed(temp_parser, final_def_text, final_def_len);
-                        cmark_node *doc = cmark_parser_finish(temp_parser);
-                        if (doc) {
-                            /* Render and extract just the content (strip <p> tags) */
-                            char *full_html = cmark_render_html(doc, render_opts, NULL);
-                            if (full_html) {
-                                /* Strip <p> and </p> tags if present */
-                                char *content_start = full_html;
-                                if (strncmp(content_start, "<p>", 3) == 0) {
-                                    content_start += 3;
-                                }
-                                char *content_end = content_start + strlen(content_start);
-                                if (content_end > content_start + 4 &&
-                                    strcmp(content_end - 5, "</p>\n") == 0) {
-                                    content_end -= 5;
-                                    *content_end = '\0';
-                                }
-                                def_html = strdup(content_start);
-                                free(full_html);
-                            }
-                            cmark_node_free(doc);
-                        }
-                        cmark_parser_free(temp_parser);
-                    }
-                    free(final_def_text);
-                }
-                }
+        if (is_kramdown_def) {
+            const char *next_start = line_end;
+            if (next_start < text + text_len && *next_start == '\n') next_start++;
+            if (next_nonblank_line_is_table(next_start, text + text_len)) {
+                /* : Caption before table is a table caption, not a definition */
+                is_kramdown_def = false;
             }
+        }
 
-            /* Write processed HTML or original text */
-            if (def_html) {
-                size_t html_len = strlen(def_html);
-                /* Need html_len + 1 for null terminator */
-                ENSURE_SPACE(html_len + 1);
-                memcpy(write, def_html, html_len);
-                write += html_len;
-                remaining -= html_len;
-                free(def_html);
-            } else {
-                /* Need def_text_len + 1 for null terminator */
-                ENSURE_SPACE(def_text_len + 1);
-                memcpy(write, p, def_text_len);
-                write += def_text_len;
-                remaining -= def_text_len;
+        if (is_kramdown_def) {
+            /* Extract definition text (after : or :: and space) */
+            const char *def_start = line_start;
+            while (def_start < line_end && (*def_start == ' ' || *def_start == '\t')) def_start++;
+            if (def_start < line_end && *def_start == ':') {
+                def_start++;
+                if (def_start < line_end && *def_start == ':') def_start++;
+                while (def_start < line_end && (*def_start == ' ' || *def_start == '\t')) def_start++;
             }
+            size_t def_len = (size_t)(line_end - def_start);
 
-            const char *dd_end = "</dd>\n";
-            size_t dd_end_len = strlen(dd_end);
-            /* Need dd_end_len + 1 for null terminator */
-            ENSURE_SPACE(dd_end_len + 1);
-            memcpy(write, dd_end, dd_end_len);
-            write += dd_end_len;
-            remaining -= dd_end_len;
-        } else if (line_length == 0 || (line_length == 1 && *line_start == '\r')) {
-            /* Blank line */
-            if (in_def_list) {
-                /* Allow blank lines within definition lists - skip them to keep HTML block continuous */
-                /* Don't close the list - it will continue if next line is a definition */
-                /* Blank lines in HTML are mostly ignored anyway, so skipping is safe */
-            } else {
-                /* Not in a definition list - check if we have a buffered term */
-                if (term_len > 0) {
-                    /* Keep the term buffered - don't flush it yet */
-                    /* Don't output the blank line yet - wait to see if next line is a definition */
-                    /* If next line is a definition, we'll start the list and the blank line is effectively ignored */
-                    /* If next line is not a definition, we'll output the term and blank line then */
-                    skipped_blank_after_term = true;
-                } else {
-                    /* No buffered term - regular blank line */
-                    ENSURE_SPACE(1);
-                    *write++ = '\n';
-                    remaining--;
-                }
-            }
-        } else {
-            /* Regular line */
-            /* Skip definition list processing if we're inside a code block (shouldn't happen, but be safe) */
-            if (in_code_block) {
-                /* Copy line as-is */
-                ENSURE_SPACE(line_length + 1);
-                memcpy(write, line_start, line_length);
-                write += line_length;
-                remaining -= line_length;
-                *write++ = '\n';
-                remaining--;
-                read = line_end;
-                if (*read == '\n') {
-                    read++;
-                }
-                continue;
-            }
-            if (in_def_list) {
-                /* This could be a new term */
-                /* End current list first */
-                const char *dl_end = "</dl>\n\n";
-                size_t dl_end_len = strlen(dl_end);
-                    if (in_blockquote_context) {
-                        /* Add > prefix(es) at start of line for blockquote context */
-                        size_t prefix_needed = blockquote_depth * 2;
-                        /* Need prefix_needed + 1 for null terminator */
-                        ENSURE_SPACE(prefix_needed + 1);
-                        for (int i = 0; i < blockquote_depth && remaining > 2; i++) {
-                            *write++ = '>';
-                            *write++ = ' ';
-                            remaining -= 2;
-                        }
-                    }
-                /* Need dl_end_len + 1 for null terminator */
-                ENSURE_SPACE(dl_end_len + 1);
-                memcpy(write, dl_end, dl_end_len);
-                write += dl_end_len;
-                remaining -= dl_end_len;
+            if (term_len > 0) {
+                /* We have a buffered term - output <dl><dt>term</dt><dd>def</dd> */
+                if (!in_def_list) {
+                    ENSURE_SPACE(20);
+                    memcpy(write, "<dl>\n", 5);
+                    write += 5;
+                    remaining -= 5;
+                    in_def_list = true;
+                }
+                if (dd_open) {
+                    memcpy(write, "</dd>\n", 6);
+                    write += 6;
+                    remaining -= 6;
+                    dd_open = false;
+                }
+                /* <dt>term</dt> */
+                ENSURE_SPACE(10);
+                memcpy(write, "<dt>", 4);
+                write += 4;
+                remaining -= 4;
+                char *term_html = render_inline_with_doc(term_buffer, (size_t)term_len, text, text_len, unsafe);
+                if (term_html) {
+                    size_t html_len = strlen(term_html);
+                    ENSURE_SPACE(html_len + 20);
+                    memcpy(write, term_html, html_len);
+                    write += html_len;
+                    remaining -= html_len;
+                    free(term_html);
+                }
+                memcpy(write, "</dt>\n", 6);
+                write += 6;
+                remaining -= 6;
+                term_len = 0;
+            } else if (in_def_list) {
+                /* Another : definition for same term */
+                if (dd_open) {
+                    memcpy(write, "</dd>\n", 6);
+                    write += 6;
+                    remaining -= 6;
+                }
+            }
+
+            /* <dd>definition</dd> */
+            ENSURE_SPACE(20 + def_len * 2);
+            memcpy(write, "<dd>", 4);
+            write += 4;
+            remaining -= 4;
+            dd_open = true;
+
+            if (def_len > 0) {
+                char *def_html = render_inline_with_doc(def_start, def_len, text, text_len, unsafe);
+                if (def_html) {
+                    size_t html_len = strlen(def_html);
+                    ENSURE_SPACE(html_len + 20);
+                    memcpy(write, def_html, html_len);
+                    write += html_len;
+                    remaining -= html_len;
+                    free(def_html);
+                }
+            }
+            /* Don't close </dd> yet - allow indented continuation lines */
+        }
+        /* Check for one-line definition: Term :: Definition */
+        else if (!in_code_block) {
+            sep = find_def_separator((const unsigned char *)line_start, (int)line_length);
+            bool sep_inside_inline = false;
+            if (sep >= 0) {
+                sep_inside_inline = scan_inline_code_for_sep(line_start, line_length, sep, in_inline_code_span, &in_inline_code_span);
+            }
+            if (sep >= 0 && !sep_inside_inline) {
+            /* Close any open Kramdown dd and flush unused term buffer */
+            if (dd_open) {
+                memcpy(write, "</dd>\n", 6);
+                write += 6;
+                remaining -= 6;
+                dd_open = false;
+            }
+            if (in_def_list && term_len > 0) {
+                /* Buffered term wasn't used - output as regular line, close list */
+                memcpy(write, "</dl>\n\n", 7);
+                write += 7;
+                remaining -= 7;
                 in_def_list = false;
-                in_blockquote_context = false;
-                blockquote_depth = 0;
             }
-
-            /* If we have a buffered term that wasn't used, write it first */
             if (term_len > 0) {
-                /* Need term_len bytes + 1 for newline + 1 for null terminator */
                 ENSURE_SPACE((size_t)term_len + 2);
-                memcpy(write, term_buffer, term_len);
+                memcpy(write, term_buffer, (size_t)term_len);
                 write += term_len;
                 remaining -= (size_t)term_len;
                 *write++ = '\n';
                 remaining--;
-                /* If we skipped a blank line after the term, output it now */
-                if (skipped_blank_after_term) {
-                    ENSURE_SPACE(1);
-                    *write++ = '\n';
-                    remaining--;
-                    skipped_blank_after_term = false;
-                }
                 term_len = 0;
             }
+            /* Extract term (before ::) and definition (after ::) */
+            const char *term_start = line_start;
+            const char *term_end = line_start + sep;
+            const char *def_start = line_start + sep + 2;
+            const char *def_end = line_end;
+
+            /* Trim term */
+            while (term_start < term_end && (*term_start == ' ' || *term_start == '\t')) term_start++;
+            while (term_end > term_start && (term_end[-1] == ' ' || term_end[-1] == '\t')) term_end--;
+
+            /* Trim definition */
+            while (def_start < def_end && (*def_start == ' ' || *def_start == '\t')) def_start++;
 
-            /* Check if line is a header (starts with #) - check BEFORE other checks */
-            const char *header_check = line_start;
-            while (header_check < line_end && (*header_check == ' ' || *header_check == '\t')) {
-                header_check++;
+            size_t term_len = (size_t)(term_end - term_start);
+            size_t def_len = (size_t)(def_end - def_start);
+
+            if (!in_def_list) {
+                ENSURE_SPACE(10);
+                memcpy(write, "<dl>\n", 5);
+                write += 5;
+                remaining -= 5;
+                in_def_list = true;
             }
-            bool is_header = (header_check < line_end && *header_check == '#');
 
-            /* If this is a table row, write it through immediately without buffering */
-            if (is_table_row) {
-                size_t needed = line_length + (*line_end == '\n' ? 1 : 0);
-                /* Need needed + 1 for null terminator */
-                ENSURE_SPACE(needed + 1);
-                memcpy(write, line_start, line_length);
-                write += line_length;
-                remaining -= line_length;
-                if (*line_end == '\n' && remaining > 0) {
+            /* <dt>term</dt> */
+            ENSURE_SPACE(20 + term_len * 2);
+            memcpy(write, "<dt>", 4);
+            write += 4;
+            remaining -= 4;
+
+            /* Parse term as inline markdown */
+            if (term_len > 0) {
+                char *term_html = render_inline_with_doc(term_start, term_len, text, text_len, unsafe);
+                if (term_html) {
+                    size_t html_len = strlen(term_html);
+                    ENSURE_SPACE(html_len + 20);
+                    memcpy(write, term_html, html_len);
+                    write += html_len;
+                    remaining -= html_len;
+                    free(term_html);
+                }
+            }
+
+            memcpy(write, "</dt>\n", 6);
+            write += 6;
+            remaining -= 6;
+
+            /* <dd>definition</dd> */
+            ENSURE_SPACE(20 + def_len * 2);
+            memcpy(write, "<dd>", 4);
+            write += 4;
+            remaining -= 4;
+
+            if (def_len > 0) {
+                char *def_html = render_inline_with_doc(def_start, def_len, text, text_len, unsafe);
+                if (def_html) {
+                    size_t html_len = strlen(def_html);
+                    ENSURE_SPACE(html_len + 20);
+                    memcpy(write, def_html, html_len);
+                    write += html_len;
+                    remaining -= html_len;
+                    free(def_html);
+                }
+            }
+
+            memcpy(write, "</dd>\n", 6);
+            write += 6;
+            remaining -= 6;
+            } else {
+            /* Not one-line def (sep < 0) - buffer as potential Kramdown term */
+            if (dd_open) {
+                memcpy(write, "</dd>\n", 6);
+                write += 6;
+                remaining -= 6;
+                dd_open = false;
+            }
+            bool is_blank = (line_length == 0 || (line_length == 1 && (*line_start == '\r' || *line_start == '\n')));
+            if (is_blank) {
+                /* Blank line: keep def list open (next line might be : definition for same term) */
+                if (term_len > 0) {
+                    /* Skip blank, keep term buffered */
+                } else if (!in_def_list) {
+                    ENSURE_SPACE(2);
                     *write++ = '\n';
                     remaining--;
                 }
-                /* Move to next line and continue */
-                const char *old_read_continue = read;
-                read = line_end;
-                if (*read == '\n') read++;
-                /* Safety: ensure we advanced */
-                if (read <= old_read_continue) {
-                    /* We're stuck - break instead of continue */
-                    break;
+                /* else: in_def_list, skip blank, list stays open */
+            } else {
+                if (in_def_list) {
+                    memcpy(write, "</dl>\n\n", 7);
+                    write += 7;
+                    remaining -= 7;
+                    in_def_list = false;
                 }
-                continue;
-            }
-            /* If this is a header, write it through immediately without buffering */
-            else if (is_header) {
-                /* But first, flush any buffered term that wasn't used */
                 if (term_len > 0) {
-                    size_t term_needed = (size_t)term_len + 2;
-                    ENSURE_SPACE(term_needed);
-                    memcpy(write, term_buffer, term_len);
+                    ENSURE_SPACE((size_t)term_len + 2);
+                    memcpy(write, term_buffer, (size_t)term_len);
                     write += term_len;
                     remaining -= (size_t)term_len;
                     *write++ = '\n';
                     remaining--;
-                    /* If we skipped a blank line after the term, output it now */
-                    if (skipped_blank_after_term) {
-                        ENSURE_SPACE(1);
-                        *write++ = '\n';
-                        remaining--;
-                        skipped_blank_after_term = false;
-                    }
                     term_len = 0;
                 }
-                size_t needed = line_length + (*line_end == '\n' ? 1 : 0);
-                /* Need needed + 1 for null terminator */
-                ENSURE_SPACE(needed + 1);
-                memcpy(write, line_start, line_length);
-                write += line_length;
-                remaining -= line_length;
-                if (*line_end == '\n' && remaining > 0) {
-                    *write++ = '\n';
-                    remaining--;
-                }
-                /* Move to next line and continue */
-                const char *old_read_continue = read;
-                read = line_end;
-                if (*read == '\n') read++;
-                /* Safety: ensure we advanced */
-                if (read <= old_read_continue) {
-                    /* We're stuck - break instead of continue */
-                    break;
-                }
-                continue;
-            }
-            /* If this is a list item, write it through immediately without buffering */
-            else if (is_list_item) {
-                size_t needed = line_length + (*line_end == '\n' ? 1 : 0);
-                /* Need needed + 1 for null terminator */
-                ENSURE_SPACE(needed + 1);
-                memcpy(write, line_start, line_length);
-                write += line_length;
-                remaining -= line_length;
-                if (*line_end == '\n' && remaining > 0) {
+                const char *p = line_start;
+                while (p < line_end && (*p == ' ' || *p == '\t')) p++;
+                bool is_ref_def = (p < line_end && *p == '[' && memchr(p, ':', (size_t)(line_end - p)) != NULL);
+                if (is_ref_def || line_length >= sizeof(term_buffer) - 1) {
+                    ENSURE_SPACE(line_length + 2);
+                    memcpy(write, line_start, line_length);
+                    write += line_length;
+                    remaining -= line_length;
                     *write++ = '\n';
                     remaining--;
+                } else {
+                    memcpy(term_buffer, line_start, line_length);
+                    term_len = (int)line_length;
+                    term_buffer[term_len] = '\0';
                 }
-                /* Move to next line and continue */
-                const char *old_read_continue = read;
-                read = line_end;
-                if (*read == '\n') read++;
-                /* Safety: ensure we advanced */
-                if (read <= old_read_continue) {
-                    /* We're stuck - break instead of continue */
-                    break;
-                }
-                continue;
             }
-            /* Check if line contains IAL syntax - if so, write immediately without buffering */
-            else if (strstr(line_start, "{:") != NULL) {
-                /* Contains IAL - don't buffer it */
-                size_t needed = line_length + (*line_end == '\n' ? 1 : 0);
-                /* Need needed + 1 for null terminator */
-                ENSURE_SPACE(needed + 1);
-                memcpy(write, line_start, line_length);
-                write += line_length;
-                remaining -= line_length;
-                if (*line_end == '\n' && remaining > 0) {
-                    *write++ = '\n';
-                    remaining--;
-                }
-                /* Move to next line and continue */
-                const char *old_read_continue = read;
-                read = line_end;
-                if (*read == '\n') read++;
-                /* Safety: ensure we advanced */
-                if (read <= old_read_continue) {
-                    /* We're stuck - break instead of continue */
-                    break;
-                }
-                continue;
             }
-            /* Save current line as potential term */
-            if (line_length < sizeof(term_buffer) - 1) {
-                /* Check if line has blockquote prefix and count depth */
-                const char *term_check = line_start;
-                while (term_check < line_end && (*term_check == ' ' || *term_check == '\t')) term_check++;
-                term_has_blockquote = false;
-                term_blockquote_depth = 0;
-                const char *depth_check = term_check;
-                while (depth_check < line_end && *depth_check == '>') {
-                    term_has_blockquote = true;
-                    term_blockquote_depth++;
-                    depth_check++;
-                    /* Skip optional space after > */
-                    if (depth_check < line_end && (*depth_check == ' ' || *depth_check == '\t')) {
-                        depth_check++;
-                    }
-                }
+        }
 
-                memcpy(term_buffer, line_start, line_length);
-                term_len = line_length;
-                term_buffer[term_len] = '\0';
-                /* Don't write yet - wait to see if next line is definition */
-            } else {
-                /* Line too long for buffer, just copy through */
-                size_t needed = line_length + (*line_end == '\n' ? 1 : 0);
-                /* Need needed + 1 for null terminator */
-                ENSURE_SPACE(needed + 1);
-                memcpy(write, line_start, line_length);
-                write += line_length;
-                remaining -= line_length;
-                if (*line_end == '\n' && remaining > 0) {
-                    *write++ = '\n';
-                    remaining--;
-                }
-            }
+        /* Track if this line was a table row (for : Caption after table detection) */
+        bool is_blank = (line_length == 0 || (line_length == 1 && (*line_start == '\r' || *line_start == '\n')));
+        if (!is_blank) prev_line_was_table_row = is_table_row_line(line_start, line_length);
+
+        /* Update inline code span state for next line (if not already updated in one-line def path) */
+        if (sep < 0) {
+            scan_inline_code_for_sep(line_start, line_length, -1, in_inline_code_span, &in_inline_code_span);
         }
 
-        /* Move to next line - ensure we always advance */
-        const char *old_read = read;
         read = line_end;
-        if (*read == '\n') {
-            read++;
-        }
-        /* If we're at the end of the string, break */
-        if (*read == '\0') {
-            break;
-        }
-        /* Critical safety check: if we haven't advanced, break immediately */
-        if (read <= old_read) {
-            /* We're stuck - this should never happen, but break to prevent infinite loop */
-            /* Force advance one character as last resort */
-            if (*read != '\0') {
-                read++;
-            } else {
-                break;
-            }
-        }
-        /* Additional safety: if we've processed more than the text length, something is wrong */
-        if (read > text + text_len) {
-            break;
-        }
+        if (read < text + text_len && *read == '\n') read++;
     }
 
-    /* Close any open definition list */
+
+    if (dd_open) {
+        memcpy(write, "</dd>\n", 6);
+        write += 6;
+    }
     if (in_def_list) {
-        const char *dl_end = "</dl>\n";
-        size_t dl_end_len = strlen(dl_end);
-        if (in_blockquote_context) {
-            /* Add > prefix(es) at start of line for blockquote context */
-            size_t prefix_needed = blockquote_depth * 2;
-            /* Need prefix_needed + 1 for null terminator */
-            ENSURE_SPACE(prefix_needed + 1);
-            for (int i = 0; i < blockquote_depth && remaining > 2; i++) {
-                *write++ = '>';
-                *write++ = ' ';
-                remaining -= 2;
-            }
-        }
-        /* Need dl_end_len + 1 for null terminator */
-        ENSURE_SPACE(dl_end_len + 1);
-        memcpy(write, dl_end, dl_end_len);
-        write += dl_end_len;
-        remaining -= dl_end_len;
+        memcpy(write, "</dl>\n", 6);
+        write += 6;
     }
-
-    /* Write any remaining term */
     if (term_len > 0) {
-        /* Need term_len bytes + 1 for newline + 1 for null terminator */
         ENSURE_SPACE((size_t)term_len + 2);
-        memcpy(write, term_buffer, term_len);
+        memcpy(write, term_buffer, (size_t)term_len);
         write += term_len;
-        remaining -= (size_t)term_len;
         *write++ = '\n';
-        remaining--;
-        /* If we skipped a blank line after the term, output it now */
-        if (skipped_blank_after_term) {
-            ENSURE_SPACE(1);
-            *write++ = '\n';
-            remaining--;
-            skipped_blank_after_term = false;
-        }
-    }
-
-    /* Free reference definitions if we extracted them */
-    if (ref_definitions) {
-        free(ref_definitions);
-        ref_definitions = NULL;  /* Prevent double-free */
-    }
-
-    /* Ensure space for null terminator */
-    if (remaining < 1) {
-        size_t used = write - output;
-        output_capacity = (used + 2) * 2;
-        char *new_output = realloc(output, output_capacity + 1);
-        if (!new_output) {
-            free(output);
-            return NULL;
-        }
-        output = new_output;
-        write = output + used;
-        remaining = output_capacity - used;
-    }
-    /* Safety check: if we processed but didn't actually create any definition lists,
-     * return NULL to use original text. This handles cases where the early exit
-     * incorrectly detected a pattern but no definition lists were actually created. */
-    if (!found_any_def_list) {
-        /* No definition lists were created - if we processed but didn't create any DLs,
-         * something went wrong. Return NULL to use original text. */
-        free(output);
-        if (ref_definitions) {
-            free(ref_definitions);
-        }
-        return NULL;
     }
 
     *write = '\0';
-
-    #undef ENSURE_SPACE
-
-    /* If we didn't write anything, return original text to avoid empty output */
-    if (write == output) {
-        free(output);
-        if (ref_definitions) {
-            free(ref_definitions);
-        }
-        return NULL;  /* Return NULL to indicate no processing was done */
-    }
+#undef ENSURE_SPACE
 
     return output;
 }
 
-/**
- * Post-process - no longer needed with preprocessing approach
- */
-static cmark_node *postprocess(cmark_syntax_extension *ext,
-                               cmark_parser *parser,
-                               cmark_node *root) {
-    (void)ext;
-    (void)parser;
-    /* Definition lists are now handled via preprocessing */
-    return root;
-}
-
-/**
- * Render definition list to HTML
- */
-static void html_render(cmark_syntax_extension *ext,
-                       struct cmark_html_renderer *renderer,
-                       cmark_node *node,
-                       cmark_event_type ev_type,
-                       int options) {
-    (void)ext;
-    (void)options;
-    cmark_strbuf *html = renderer->html;
-
-    if (ev_type == CMARK_EVENT_ENTER) {
-        if (node->type == APEX_NODE_DEFINITION_LIST) {
-            cmark_strbuf_puts(html, "<dl>\n");
-        } else if (node->type == APEX_NODE_DEFINITION_TERM) {
-            cmark_strbuf_puts(html, "<dt>");
-        } else if (node->type == APEX_NODE_DEFINITION_DATA) {
-            cmark_strbuf_puts(html, "<dd>");
-        }
-    } else if (ev_type == CMARK_EVENT_EXIT) {
-        if (node->type == APEX_NODE_DEFINITION_LIST) {
-            cmark_strbuf_puts(html, "</dl>\n");
-        } else if (node->type == APEX_NODE_DEFINITION_TERM) {
-            cmark_strbuf_puts(html, "</dt>\n");
-        } else if (node->type == APEX_NODE_DEFINITION_DATA) {
-            cmark_strbuf_puts(html, "</dd>\n");
-        }
-    }
-}
-
-/**
- * Create definition list extension
- */
-cmark_syntax_extension *create_definition_list_extension(void) {
-    cmark_syntax_extension *ext = cmark_syntax_extension_new("definition_list");
-    if (!ext) return NULL;
-
-    /* Register node types */
-    APEX_NODE_DEFINITION_LIST = cmark_syntax_extension_add_node(0);
-    APEX_NODE_DEFINITION_TERM = cmark_syntax_extension_add_node(0);
-    APEX_NODE_DEFINITION_DATA = cmark_syntax_extension_add_node(0);
-
-    /* Set callbacks */
-    cmark_syntax_extension_set_open_block_func(ext, open_block);
-    cmark_syntax_extension_set_match_block_func(ext, match_block);
-    cmark_syntax_extension_set_can_contain_func(ext, can_contain);
-    cmark_syntax_extension_set_html_render_func(ext, html_render);
-    cmark_syntax_extension_set_postprocess_func(ext, postprocess);
-
-    return ext;
+void apex_deflist_debug_touch(int enable_definition_lists) {
+    (void)enable_definition_lists;
+    /* No-op for one-line format - debug was for old Kramdown format */
 }