apex-ruby 1.0.42 → 1.0.43

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d4df60b99bfd0063dfd468268a2b99a820856158ab33592e0d6e1c7079e7a7df
-  data.tar.gz: cfb5ae10aa5b1fb839c1fff62f2447b2109e06ef0a04f322877ddfb66f60a545
+  metadata.gz: fa99154791a5f1be0a4beab63a0165635067fed9488a9326fb5191aecbf6d43c
+  data.tar.gz: 2a079dc8f17c2acf9fbda21bf6c84cc858ab4bc9e20487f811b7d900931ff3ea
 SHA512:
-  metadata.gz: 073d0df457e0035ac85d57b70e98907dfcfbc8c935a5ffb06863ca3a0fff07e87fb15ea4e76e946c877f6213e18f4e78e0d50e75df3353451fa216cb651b6ae1
-  data.tar.gz: ae64955ab3a1572574454348f695790fd0f225d953c0165d1cd06712da4bd2791bdd50ca38c5c6d0c3a2da949a77c8b1d8e943f00bd9b7fe2e73b3de6ffcccb2
+  metadata.gz: 37d89512a545e58f6936f538dbe3dffa37988fabeee0164e9a82ca212ac66f99b2ff65974a8c1b374dceb36b6f4e9e8365aaf48f29b9614709ce8612e5e291d7
+  data.tar.gz: 0c71583002c433c95043d06426cf04060747f47efadf4f8ab8a178f174f93b0d24bc092aa74abfb69118d3942ca240535af00d8fc82cfb03a3324d5591a5708a

data/ext/apex_ext/apex_src/include/apex/apex.h

@@ -21,8 +21,8 @@ typedef struct cmark_node cmark_node;
 
 #define APEX_VERSION_MAJOR 1
 #define APEX_VERSION_MINOR 1
-#define APEX_VERSION_PATCH 47
-#define APEX_VERSION_STRING "1.1.47"
+#define APEX_VERSION_PATCH 49
+#define APEX_VERSION_STRING "1.1.49"
 
 /**
  * Processor compatibility modes
@@ -111,6 +111,8 @@ bool apex_plugin_register(apex_plugin_manager *manager, const char *id, apex_plu
 
 struct cmark_parser;  /* Opaque; for cmark_init callback. Include cmark-gfm when implementing. */
 
+struct apex_metadata_item;
+
 /**
  * Configuration options for the parser and renderer
  */
@@ -182,6 +184,13 @@ typedef struct apex_options {
     bool paginate_symbols;       /* When paginating, render images as chafa ANSI symbols (less -R compatible) */
     bool terminal_inline_images; /* When true, render local images via imgcat/chafa/viu/catimg on a TTY */
     int terminal_image_width;    /* Max width/cells for terminal image tools (default 50; 0 = use 50) */
+    /* Terminal metadata header. When terminal_document_metadata_explicit is
+     * false, apex_markdown_to_html fills terminal_document_metadata from the
+     * metadata it extracted. When true, the pointer is the document-only list
+     * (NULL means the document had none) and extracted metadata is not printed.
+     * The renderer does not free the list. */
+    bool terminal_document_metadata_explicit;
+    const struct apex_metadata_item *terminal_document_metadata;
 
     /* Line break handling */
     bool hardbreaks;  /* Treat newlines as hard breaks (GFM style) */

data/ext/apex_ext/apex_src/include/apex/ast_terminal.h

@@ -38,6 +38,9 @@ char *apex_cmark_to_terminal(cmark_node *document,
  */
 size_t apex_terminal_output_length(void);
 
+/** Adjust that length after the caller replaces the buffer (for example, liquid restore). */
+void apex_terminal_set_output_length(size_t len);
+
 #ifdef __cplusplus
 }
 #endif

data/ext/apex_ext/apex_src/include/module.modulemap

@@ -2,3 +2,36 @@ module ApexC {
   header "apexc.h"
   export *
 }
+
+// Kept in this map, which SwiftPM loads, so ApexObjC can import <apex/apex.h>
+// without an -fmodule-map-file unsafe flag. A map inside include/apex/ would
+// be a second definition of the same module.
+module ApexHeaders {
+    umbrella header "apex/apex.h"
+    header "apex/plugins.h"
+    explicit module parser {
+        header "apex/parser.h"
+        export *
+    }
+    explicit module renderer {
+        header "apex/renderer.h"
+        export *
+    }
+    explicit module buffer {
+        header "apex/buffer.h"
+        export *
+    }
+    explicit module ast_markdown {
+        header "apex/ast_markdown.h"
+        export *
+    }
+    explicit module ast_man {
+        header "apex/ast_man.h"
+        export *
+    }
+    explicit module ast_rtf {
+        header "apex/ast_rtf.h"
+        export *
+    }
+    export *
+}

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

@@ -1940,6 +1940,15 @@ static char *apex_restore_liquid_tags(const char *html,
     return output;
 }
 
+/* Put {% %} tags back into an output string that left the HTML path early. */
+static char *apex_restore_liquid_in_output(char *text, char **tags, size_t tag_count) {
+    if (!text || !tags || tag_count == 0) return text;
+    char *restored = apex_restore_liquid_tags(text, tags, tag_count);
+    if (!restored) return text;
+    free(text);
+    return restored;
+}
+
 /**
  * Preprocess table rows to convert consecutive pipes without whitespace into << markers
  * for colspan detection.
@@ -3127,6 +3136,8 @@ apex_options apex_options_default(void) {
     opts.paginate_symbols = false;
     opts.terminal_inline_images = true;
     opts.terminal_image_width = 50;
+    opts.terminal_document_metadata_explicit = false;
+    opts.terminal_document_metadata = NULL;
 
     return opts;
 }
@@ -6100,7 +6111,7 @@ char *apex_markdown_to_html(const char *markdown, size_t len, const apex_options
         apex_free_metadata(metadata);
         /* Note: Preprocessing buffers are conditionally allocated and may not be in scope here.
          * This is acceptable as JSON output is typically used for debugging/inspection. */
-        return json;
+        return apex_restore_liquid_in_output(json, liquid_tags, liquid_tag_count);
     }
 
     /* Run AST-level filters (Pandoc-style JSON filters) before any */
@@ -6215,7 +6226,7 @@ char *apex_markdown_to_html(const char *markdown, size_t len, const apex_options
         char *json = apex_cmark_to_pandoc_json(document, options);
         /* Note: Cleanup happens at end of function - document and other resources
          * will be freed there. We return the JSON string here. */
-        return json;
+        return apex_restore_liquid_in_output(json, liquid_tags, liquid_tag_count);
     }
 
     if (options->output_format == APEX_OUTPUT_TOC) {
@@ -6223,11 +6234,11 @@ char *apex_markdown_to_html(const char *markdown, size_t len, const apex_options
             *options->toc_entries_out = apex_generate_toc_entries(
                 document, options->id_format, options->toc_min, options->toc_max,
                 options->toc_entries_count_out);
-            return strdup("");
+            return apex_restore_liquid_in_output(strdup(""), liquid_tags, liquid_tag_count);
         }
         char *toc_md = apex_generate_toc_markdown(document, options->id_format,
                                                   options->toc_min, options->toc_max);
-        return toc_md ? toc_md : strdup("");
+        return apex_restore_liquid_in_output(toc_md ? toc_md : strdup(""), liquid_tags, liquid_tag_count);
     }
 
     /* If output format is Markdown, serialize AST to Markdown and return */
@@ -6251,31 +6262,51 @@ char *apex_markdown_to_html(const char *markdown, size_t len, const apex_options
         char *markdown = apex_cmark_to_markdown(document, options, dialect);
         /* Note: Cleanup happens at end of function - document and other resources
          * will be freed there. We return the markdown string here. */
-        return markdown;
+        return apex_restore_liquid_in_output(markdown, liquid_tags, liquid_tag_count);
     }
 
     /* If output format is terminal/terminal256, serialize AST to ANSI terminal and return */
     if (options->output_format == APEX_OUTPUT_TERMINAL ||
         options->output_format == APEX_OUTPUT_TERMINAL256) {
+        if (!options->terminal_document_metadata_explicit) {
+            options->terminal_document_metadata = metadata;
+        }
         bool use_256 = (options->output_format == APEX_OUTPUT_TERMINAL256);
         char *tty = apex_cmark_to_terminal(document, options, use_256);
-        return tty;
+        size_t recorded = apex_terminal_output_length();
+        size_t before = tty ? strlen(tty) : 0;
+        char *out = apex_restore_liquid_in_output(tty, liquid_tags, liquid_tag_count);
+        if (out && out != tty) {
+            size_t after = strlen(out);
+            if (after >= before && recorded >= before) {
+                apex_terminal_set_output_length(recorded + (after - before));
+            } else if (recorded >= (before - after)) {
+                apex_terminal_set_output_length(recorded - (before - after));
+            } else {
+                apex_terminal_set_output_length(after);
+            }
+        }
+        return out;
     }
 
     /* If output format is man (roff) or man-html, serialize AST and return */
     if (options->output_format == APEX_OUTPUT_MAN) {
         char *roff = apex_cmark_to_man_roff(document, options);
-        return roff ? roff : strdup(".TH stub 1 \"\" \"\"\n");
+        return apex_restore_liquid_in_output(roff ? roff : strdup(".TH stub 1 \"\" \"\"\n"),
+                                             liquid_tags, liquid_tag_count);
     }
     if (options->output_format == APEX_OUTPUT_MAN_HTML) {
         char *man_html = apex_cmark_to_man_html(document, options);
-        return man_html ? man_html : strdup("<!DOCTYPE html><html><body><p>stub</p></body></html>");
+        return apex_restore_liquid_in_output(
+            man_html ? man_html : strdup("<!DOCTYPE html><html><body><p>stub</p></body></html>"),
+            liquid_tags, liquid_tag_count);
     }
 
     /* If output format is RTF, serialize AST and return */
     if (options->output_format == APEX_OUTPUT_RTF) {
         char *rtf = apex_cmark_to_rtf(document, options);
-        return rtf ? rtf : strdup("{\\rtf1\\ansi\\deff0\\pard\\par}\n");
+        return apex_restore_liquid_in_output(rtf ? rtf : strdup("{\\rtf1\\ansi\\deff0\\pard\\par}\n"),
+                                             liquid_tags, liquid_tag_count);
     }
 
     /* Render to HTML

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

@@ -16,6 +16,7 @@
 #include "apex/ast_terminal.h"
 #include "table.h"          /* For CMARK_NODE_TABLE, CMARK_NODE_TABLE_ROW, CMARK_NODE_TABLE_CELL */
 #include "extensions/emoji.h"
+#include "extensions/metadata.h"
 
 #include <stdlib.h>
 #include <string.h>
@@ -420,6 +421,10 @@ typedef struct terminal_theme {
      * the built-in default of bold bright red. */
     char *list_marker;
 
+    char *metadata_key;
+    char *metadata_color;
+    char *metadata_border;
+
     /* Per-span class styles (for bracketed spans / HTML spans with classes) */
     span_class_style *span_classes;
     size_t span_classes_count;
@@ -442,6 +447,9 @@ static void free_theme(terminal_theme *theme) {
     free(theme->table_border);
 
     free(theme->list_marker);
+    free(theme->metadata_key);
+    free(theme->metadata_color);
+    free(theme->metadata_border);
 
     if (theme->span_classes) {
         for (size_t i = 0; i < theme->span_classes_count; i++) {
@@ -551,6 +559,10 @@ static char *build_theme_path(const char *name) {
  *   classname: "style tokens"
  *
  * list_marker: "style tokens"
+ * metadata:
+ *   key: "style tokens"     # key and colon; blank inherits color
+ *   color: "style tokens"   # value text
+ *   border: "style tokens"  # rule under the block
  */
 static char *trim_whitespace(char *s) {
     if (!s) return s;
@@ -716,6 +728,15 @@ static terminal_theme *load_theme_from_simple_yaml(const char *path) {
         } else if (strcmp(l1, "table") == 0 && strcmp(l2, "border") == 0) {
             free(theme->table_border);
             theme->table_border = dup_or_null(val);
+        } else if (strcmp(l1, "metadata") == 0 && strcmp(l2, "key") == 0) {
+            free(theme->metadata_key);
+            theme->metadata_key = dup_or_null(val);
+        } else if (strcmp(l1, "metadata") == 0 && strcmp(l2, "color") == 0) {
+            free(theme->metadata_color);
+            theme->metadata_color = dup_or_null(val);
+        } else if (strcmp(l1, "metadata") == 0 && strcmp(l2, "border") == 0) {
+            free(theme->metadata_border);
+            theme->metadata_border = dup_or_null(val);
         } else if (strcmp(l1, "table") == 0 && strcmp(l2, "bold") == 0) {
             if (parse_bool_value(val)) {
                 ensure_bold_prefix(&theme->table_border);
@@ -932,6 +953,15 @@ static terminal_theme *load_theme_from_yaml(const char *path) {
                         } else if (strcmp(l1, "table") == 0 && strcmp(l2, "border") == 0) {
                             free(theme->table_border);
                             theme->table_border = dup_or_null(val);
+                        } else if (strcmp(l1, "metadata") == 0 && strcmp(l2, "key") == 0) {
+                            free(theme->metadata_key);
+                            theme->metadata_key = dup_or_null(val);
+                        } else if (strcmp(l1, "metadata") == 0 && strcmp(l2, "color") == 0) {
+                            free(theme->metadata_color);
+                            theme->metadata_color = dup_or_null(val);
+                        } else if (strcmp(l1, "metadata") == 0 && strcmp(l2, "border") == 0) {
+                            free(theme->metadata_border);
+                            theme->metadata_border = dup_or_null(val);
                         } else if (strcmp(l1, "table") == 0 && strcmp(l2, "bold") == 0) {
                             if (parse_bool_value(val)) {
                                 ensure_bold_prefix(&theme->table_border);
@@ -1993,6 +2023,288 @@ static void serialize_terminal_image_as_link(terminal_buffer *buf,
     }
 }
 
+/* Render definition-list HTML (<dl>/<dt>/<dd>, including nested inline tags
+ * and blockquotes) as terminal text instead of leaking the tag names. */
+typedef struct {
+    char href[2048];
+    int quote_depth;
+    bool at_line_start;
+    bool skip_ws;
+} term_dl_state;
+
+static void term_decode_basic_entities(char *s) {
+    char *read = s;
+    char *write = s;
+    while (*read) {
+        if (*read == '&') {
+            if (strncmp(read, "&amp;", 5) == 0) { *write++ = '&'; read += 5; continue; }
+            if (strncmp(read, "&lt;", 4) == 0) { *write++ = '<'; read += 4; continue; }
+            if (strncmp(read, "&gt;", 4) == 0) { *write++ = '>'; read += 4; continue; }
+            if (strncmp(read, "&quot;", 6) == 0) { *write++ = '"'; read += 6; continue; }
+            if (strncmp(read, "&#39;", 5) == 0) { *write++ = '\''; read += 5; continue; }
+            if (strncmp(read, "&apos;", 6) == 0) { *write++ = '\''; read += 6; continue; }
+        }
+        *write++ = *read++;
+    }
+    *write = '\0';
+}
+
+static const char *term_append_html_text(terminal_buffer *buf, const char *p) {
+    if (*p != '&') {
+        buffer_append(buf, p, 1);
+        return p + 1;
+    }
+    char ent[16];
+    size_t n = 0;
+    const char *q = p;
+    while (*q && *q != ';' && n + 1 < sizeof(ent)) {
+        ent[n++] = *q++;
+    }
+    if (*q == ';' && n + 1 < sizeof(ent)) {
+        ent[n++] = ';';
+        ent[n] = '\0';
+        char decoded[8];
+        snprintf(decoded, sizeof(decoded), "%s", ent);
+        term_decode_basic_entities(decoded);
+        if (strcmp(decoded, ent) != 0) {
+            buffer_append_str(buf, decoded);
+            return q + 1;
+        }
+    }
+    buffer_append(buf, p, 1);
+    return p + 1;
+}
+
+typedef struct {
+    char name[32];
+    bool closing;
+    char href[2048];
+} term_html_tag;
+
+static const char *term_parse_html_tag(const char *p, term_html_tag *tag) {
+    memset(tag, 0, sizeof(*tag));
+    if (!p || *p != '<') return NULL;
+    if (strncmp(p, "<!--", 4) == 0) {
+        const char *end = strstr(p + 4, "-->");
+        tag->name[0] = '!';
+        return end ? end + 3 : p + strlen(p);
+    }
+
+    const char *s = p + 1;
+    if (*s == '/') {
+        tag->closing = true;
+        s++;
+    }
+    size_t n = 0;
+    while (*s && (isalnum((unsigned char)*s) || *s == '-') && n + 1 < sizeof(tag->name)) {
+        tag->name[n++] = (char)tolower((unsigned char)*s);
+        s++;
+    }
+    tag->name[n] = '\0';
+
+    const char *gt = strchr(s, '>');
+    const char *href = strstr(s, "href");
+    if (href && gt && href < gt) {
+        const char *v = href + 4;
+        while (*v == ' ' || *v == '\t') v++;
+        if (*v == '=') {
+            v++;
+            while (*v == ' ' || *v == '\t') v++;
+            char quote = 0;
+            if (*v == '"' || *v == '\'') {
+                quote = *v++;
+            }
+            size_t h = 0;
+            while (*v && *v != '>' && h + 1 < sizeof(tag->href)) {
+                if (quote) {
+                    if (*v == quote) break;
+                } else if (*v == ' ' || *v == '\t' || *v == '\n') {
+                    break;
+                }
+                tag->href[h++] = *v++;
+            }
+            tag->href[h] = '\0';
+            term_decode_basic_entities(tag->href);
+        }
+    }
+    if (!gt) return p + strlen(p);
+    return gt + 1;
+}
+
+static bool term_tag_is(const term_html_tag *tag, const char *name) {
+    return strcmp(tag->name, name) == 0;
+}
+
+static void term_dl_newline(terminal_buffer *buf, term_dl_state *st) {
+    if (!st->at_line_start) {
+        buffer_append_str(buf, "\n");
+        st->at_line_start = true;
+    }
+}
+
+static void term_dl_finish_link(terminal_buffer *buf, term_dl_state *st, bool use_256_color) {
+    append_ansi_reset(buf);
+    if (st->href[0]) {
+        buffer_append_str(buf, " ");
+        apply_style_string(buf, "cyan", use_256_color);
+        buffer_append_str(buf, "(");
+        buffer_append_str(buf, st->href);
+        buffer_append_str(buf, ")");
+        append_ansi_reset(buf);
+        st->href[0] = '\0';
+    }
+}
+
+static void term_dl_handle_tag(terminal_buffer *buf, term_dl_state *st, const term_html_tag *tag,
+                               bool use_256_color) {
+    if (tag->name[0] == '!' || tag->name[0] == '\0') return;
+
+    if (term_tag_is(tag, "blockquote")) {
+        if (tag->closing) {
+            if (st->quote_depth > 0) st->quote_depth--;
+            term_dl_newline(buf, st);
+        } else {
+            st->quote_depth++;
+            st->at_line_start = true;
+        }
+        return;
+    }
+    if (term_tag_is(tag, "p") || term_tag_is(tag, "br")) {
+        term_dl_newline(buf, st);
+        return;
+    }
+    if (term_tag_is(tag, "strong") || term_tag_is(tag, "b")) {
+        if (tag->closing) append_ansi_reset(buf);
+        else apply_style_string(buf, "b", use_256_color);
+        return;
+    }
+    if (term_tag_is(tag, "em") || term_tag_is(tag, "i")) {
+        if (tag->closing) append_ansi_reset(buf);
+        else apply_style_string(buf, "i", use_256_color);
+        return;
+    }
+    if (term_tag_is(tag, "code")) {
+        if (tag->closing) append_ansi_reset(buf);
+        else apply_style_string(buf, "b white on_intense_black", use_256_color);
+        return;
+    }
+    if (term_tag_is(tag, "a")) {
+        if (tag->closing) {
+            term_dl_finish_link(buf, st, use_256_color);
+        } else {
+            apply_style_string(buf, "u b blue", use_256_color);
+            if (tag->href[0]) {
+                snprintf(st->href, sizeof(st->href), "%s", tag->href);
+            }
+        }
+    }
+}
+
+static void terminal_render_definition_html(terminal_buffer *buf, const char *literal,
+                                            bool use_256_color, int indent_level) {
+    const char *p = literal;
+    bool in_dt = false;
+    bool in_dd = false;
+    bool first_block = true;
+    term_dl_state st;
+    memset(&st, 0, sizeof(st));
+    st.at_line_start = true;
+    st.skip_ws = true;
+
+    while (*p) {
+        if (strncmp(p, "<dt>", 4) == 0 || strncmp(p, "<dt ", 4) == 0) {
+            in_dt = true;
+            in_dd = false;
+            st.quote_depth = 0;
+            st.at_line_start = true;
+            st.skip_ws = true;
+            st.href[0] = '\0';
+            if (!first_block) buffer_append_str(buf, "\n");
+            first_block = false;
+            const char *gt = strchr(p, '>');
+            p = gt ? gt + 1 : p + 4;
+            continue;
+        }
+        if (strncmp(p, "</dt>", 5) == 0) {
+            in_dt = false;
+            if (!st.at_line_start) append_ansi_reset(buf);
+            p += 5;
+            buffer_append_str(buf, "\n");
+            st.at_line_start = true;
+            continue;
+        }
+        if (strncmp(p, "<dd>", 4) == 0 || strncmp(p, "<dd ", 4) == 0) {
+            in_dd = true;
+            in_dt = false;
+            st.quote_depth = 0;
+            st.at_line_start = true;
+            st.skip_ws = true;
+            st.href[0] = '\0';
+            first_block = false;
+            const char *gt = strchr(p, '>');
+            p = gt ? gt + 1 : p + 4;
+            continue;
+        }
+        if (strncmp(p, "</dd>", 5) == 0) {
+            in_dd = false;
+            if (!st.at_line_start) {
+                append_ansi_reset(buf);
+                buffer_append_str(buf, "\n");
+                st.at_line_start = true;
+            }
+            st.quote_depth = 0;
+            p += 5;
+            continue;
+        }
+        if (strncmp(p, "<dl>", 4) == 0 || strncmp(p, "<dl ", 4) == 0 ||
+            strncmp(p, "</dl>", 5) == 0) {
+            const char *gt = strchr(p, '>');
+            p = gt ? gt + 1 : p + 4;
+            continue;
+        }
+
+        if ((in_dt || in_dd) && *p == '<') {
+            term_html_tag tag;
+            const char *next = term_parse_html_tag(p, &tag);
+            if (!next || next == p) {
+                p++;
+                continue;
+            }
+            term_dl_handle_tag(buf, &st, &tag, use_256_color);
+            st.skip_ws = term_tag_is(&tag, "p") || term_tag_is(&tag, "br") ||
+                         term_tag_is(&tag, "blockquote");
+            p = next;
+            continue;
+        }
+
+        if (in_dt || in_dd) {
+            if (st.skip_ws && (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r')) {
+                if ((*p == '\n' || *p == '\r') && st.quote_depth > 0) st.at_line_start = true;
+                p++;
+                continue;
+            }
+            st.skip_ws = false;
+            if (st.at_line_start) {
+                if (in_dd) indent_spaces(buf, indent_level + 1);
+                if (st.quote_depth > 0) buffer_append_str(buf, "> ");
+                st.at_line_start = false;
+            }
+            if (*p == '\n' || *p == '\r') {
+                buffer_append_str(buf, "\n");
+                st.at_line_start = true;
+                st.skip_ws = true;
+                p++;
+                continue;
+            }
+            p = term_append_html_text(buf, p);
+            st.at_line_start = false;
+            continue;
+        }
+        p++;
+    }
+    buffer_append_str(buf, "\n");
+}
+
 static void serialize_block(terminal_buffer *buf,
                             cmark_node *node,
                             const apex_options *options,
@@ -2843,54 +3155,7 @@ static void serialize_block(terminal_buffer *buf,
             if (literal) {
                 /* Handle definition lists: <dl><dt>Term</dt><dd>Definition</dd></dl> */
                 if (strstr(literal, "<dl>") || strstr(literal, "<dt>") || strstr(literal, "<dd>")) {
-                    const char *p = literal;
-                    bool in_dt = false;
-                    bool in_dd = false;
-                    bool first_dd = true;
-                    
-                    while (*p) {
-                        if (strncmp(p, "<dt>", 4) == 0) {
-                            in_dt = true;
-                            p += 4;
-                            if (!first_dd) {
-                                buffer_append_str(buf, "\n");
-                            }
-                            first_dd = false;
-                            continue;
-                        }
-                        if (strncmp(p, "</dt>", 5) == 0) {
-                            in_dt = false;
-                            p += 5;
-                            buffer_append_str(buf, "\n");
-                            continue;
-                        }
-                        if (strncmp(p, "<dd>", 4) == 0) {
-                            in_dd = true;
-                            p += 4;
-                            indent_spaces(buf, indent_level + 1);
-                            continue;
-                        }
-                        if (strncmp(p, "</dd>", 5) == 0) {
-                            in_dd = false;
-                            p += 5;
-                            buffer_append_str(buf, "\n");
-                            continue;
-                        }
-                        if (strncmp(p, "<dl>", 4) == 0 || strncmp(p, "</dl>", 5) == 0) {
-                            p += (p[1] == 'd' && p[2] == 'l') ? 4 : 5;
-                            continue;
-                        }
-                        
-                        if (in_dt || in_dd) {
-                            if (*p == '\n' || *p == '\r') {
-                                buffer_append_str(buf, " ");
-                            } else if (*p != '<') {
-                                buffer_append(buf, p, 1);
-                            }
-                        }
-                        p++;
-                    }
-                    buffer_append_str(buf, "\n");
+                    terminal_render_definition_html(buf, literal, use_256_color, indent_level);
                 }
                 /* Handle callouts: <div class="callout callout-TYPE">...</div> */
                 else if (strstr(literal, "callout")) {
@@ -3048,6 +3313,140 @@ static void serialize_block(terminal_buffer *buf,
     }
 }
 
+/* ------------------------------------------------------------------------- */
+/* Document metadata header                                                  */
+/* ------------------------------------------------------------------------- */
+
+static int utf8_columns(const char *s, size_t n) {
+    int cols = 0;
+    size_t i = 0;
+    while (s && i < n) {
+        unsigned char c = (unsigned char)s[i];
+        size_t seq = 1;
+        if ((c & 0x80) == 0) {
+            seq = 1;
+        } else if (c >= 0xC2 && c <= 0xDF) {
+            seq = 2;
+        } else if ((c & 0xF0) == 0xE0) {
+            seq = 3;
+        } else if (c >= 0xF0 && c <= 0xF4) {
+            seq = 4;
+        } else {
+            /* C0, C1, F5-FF, and stray continuation bytes. */
+            cols++;
+            i++;
+            continue;
+        }
+        if (i + seq > n) {
+            cols++;
+            i++;
+            continue;
+        }
+        bool valid = true;
+        for (size_t j = 1; j < seq; j++) {
+            unsigned char b = (unsigned char)s[i + j];
+            if ((b & 0xC0) != 0x80) {
+                valid = false;
+                break;
+            }
+        }
+        if (!valid) {
+            cols++;
+            i++;
+            continue;
+        }
+        cols++;
+        i += seq;
+    }
+    return cols;
+}
+
+static bool metadata_item_visible(const apex_metadata_item *item) {
+    return item && item->key && item->key[0] && item->value && item->value[0];
+}
+
+static const char *metadata_color_style(const terminal_theme *theme) {
+    if (theme && theme->metadata_color && theme->metadata_color[0]) return theme->metadata_color;
+    return "d";
+}
+
+static const char *metadata_key_style(const terminal_theme *theme) {
+    if (theme && theme->metadata_key && theme->metadata_key[0]) return theme->metadata_key;
+    return metadata_color_style(theme);
+}
+
+static const char *metadata_border_style(const terminal_theme *theme) {
+    if (theme && theme->metadata_border && theme->metadata_border[0]) return theme->metadata_border;
+    return "d";
+}
+
+static int metadata_block_width(const apex_metadata_item *item) {
+    if (!item) return 0;
+    int width = metadata_block_width(item->next);
+    if (!metadata_item_visible(item)) return width;
+    const char *v = item->value;
+    bool first = true;
+    while (v && *v) {
+        const char *nl = strchr(v, '\n');
+        size_t len = nl ? (size_t)(nl - v) : strlen(v);
+        if (len > 0 && v[len - 1] == '\r') len--;
+        if (nl && len == 0 && nl[1] == '\0') break;
+        int cols = utf8_columns(v, len);
+        if (first) cols += utf8_columns(item->key, strlen(item->key)) + 2;
+        if (cols > width) width = cols;
+        first = false;
+        if (!nl) break;
+        v = nl + 1;
+    }
+    return width;
+}
+
+static void append_metadata_items(terminal_buffer *buf, const apex_metadata_item *item,
+                                  const terminal_theme *theme, bool use_256) {
+    if (!item) return;
+    append_metadata_items(buf, item->next, theme, use_256);
+    if (!metadata_item_visible(item)) return;
+    const char *key_style = metadata_key_style(theme);
+    const char *value_style = metadata_color_style(theme);
+    const char *v = item->value;
+    bool first = true;
+    while (v && *v) {
+        const char *nl = strchr(v, '\n');
+        size_t len = nl ? (size_t)(nl - v) : strlen(v);
+        if (len > 0 && v[len - 1] == '\r') len--;
+        if (nl && len == 0 && nl[1] == '\0') break;
+        if (first) {
+            apply_style_string(buf, key_style, use_256);
+            buffer_append_str(buf, item->key);
+            buffer_append_str(buf, ":");
+            append_ansi_reset(buf);
+            buffer_append_str(buf, " ");
+        }
+        apply_style_string(buf, value_style, use_256);
+        buffer_append(buf, v, len);
+        append_ansi_reset(buf);
+        buffer_append_str(buf, "\n");
+        first = false;
+        if (!nl) break;
+        v = nl + 1;
+    }
+}
+
+static void append_terminal_metadata_header(terminal_buffer *buf,
+                                            const apex_metadata_item *metadata,
+                                            const terminal_theme *theme,
+                                            bool use_256) {
+    int width = metadata_block_width(metadata);
+    if (width <= 0) return;
+    append_metadata_items(buf, metadata, theme, use_256);
+    apply_style_string(buf, metadata_border_style(theme), use_256);
+    for (int i = 0; i < width; i++) {
+        buffer_append_str(buf, "\xE2\x95\x90");
+    }
+    append_ansi_reset(buf);
+    buffer_append_str(buf, "\n\n");
+}
+
 /* ------------------------------------------------------------------------- */
 /* Public API                                                                */
 /* ------------------------------------------------------------------------- */
@@ -3109,6 +3508,9 @@ char *apex_cmark_to_terminal(cmark_node *document,
     }
 
     terminal_theme *theme = load_theme(options);
+    append_terminal_metadata_header(&buf,
+                                    options ? options->terminal_document_metadata : NULL,
+                                    theme, use_256);
     if (getenv("APEX_DEBUG_THEME")) {
         const char *tname = (options && options->theme_name) ? options->theme_name : "(null)";
         fprintf(stderr,
@@ -3140,3 +3542,7 @@ size_t apex_terminal_output_length(void) {
     return g_terminal_output_len;
 }
 
+void apex_terminal_set_output_length(size_t len) {
+    g_terminal_output_len = len;
+}
+

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

@@ -69,6 +69,26 @@ static int find_def_separator(const unsigned char *line, int len) {
     return -1;
 }
 
+/**
+ * True for a CommonMark link reference definition (`[label]: destination`).
+ * An inline link such as `[Masoc](https://example.com)` also contains a colon,
+ * but the colon is inside the destination, not the `[label]:` marker.
+ */
+static bool line_is_link_reference_definition(const char *line, const char *line_end) {
+    const char *p = line;
+    while (p < line_end && (*p == ' ' || *p == '\t')) p++;
+    if (p >= line_end || *p != '[') return false;
+
+    for (const char *q = p + 1; q < line_end; q++) {
+        if (*q != ']') continue;
+        const char *r = q + 1;
+        while (r < line_end && (*r == ' ' || *r == '\t')) r++;
+        if (r < line_end && *r == '(') return false;
+        if (r < line_end && *r == ':') return true;
+    }
+    return false;
+}
+
 /**
  * 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.
@@ -695,9 +715,7 @@ char *apex_process_definition_lists(const char *text, bool unsafe) {
                     term_len = 0;
                     blanks_after_term = 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);
+                bool is_ref_def = line_is_link_reference_definition(line_start, line_end);
                 if (is_ref_def || is_atx_heading_line(line_start, line_length) ||
                     is_block_start_line(line_start, line_length) ||
                     line_length >= sizeof(term_buffer) - 1) {

data/lib/apex/version.rb

@@ -6,7 +6,7 @@ module Apex
   # via Apex::Native.version.
   module Version
     # Current gem version.
-    VERSION = "1.0.42"
+    VERSION = "1.0.43"
   end
 
   # Shortcut to gem version string.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: apex-ruby
 version: !ruby/object:Gem::Version
-  version: 1.0.42
+  version: 1.0.43
 platform: ruby
 authors:
 - Brett Terpstra
@@ -32,7 +32,6 @@ files:
 - ext/apex_ext/apex_src/include/apex/ast_rtf.h
 - ext/apex_ext/apex_src/include/apex/ast_terminal.h
 - ext/apex_ext/apex_src/include/apex/buffer.h
-- ext/apex_ext/apex_src/include/apex/module.modulemap
 - ext/apex_ext/apex_src/include/apex/parser.h
 - ext/apex_ext/apex_src/include/apex/plugins.h
 - ext/apex_ext/apex_src/include/apex/renderer.h

data/ext/apex_ext/apex_src/include/apex/module.modulemap

@@ -1,29 +0,0 @@
-module ApexHeaders {
-    umbrella header "apex.h"
-    header "plugins.h"
-    explicit module parser {
-        header "parser.h"
-        export *
-    }
-    explicit module renderer {
-        header "renderer.h"
-        export *
-    }
-    explicit module buffer {
-        header "buffer.h"
-        export *
-    }
-    explicit module ast_markdown {
-        header "ast_markdown.h"
-        export *
-    }
-    explicit module ast_man {
-        header "ast_man.h"
-        export *
-    }
-    explicit module ast_rtf {
-        header "ast_rtf.h"
-        export *
-    }
-    export *
-}