markly 0.15.3 → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 76b9702e08b93aa97c2fe8b02d0ac1faea07b8037cf093c48d87b4b7e260806a
-  data.tar.gz: b3cad63b1de5e67e2160c72731f28cea94d02fbe999c5b2f2201f3e94b6c84b7
+  metadata.gz: fda5c52f4ac015dde2e9f22e2a76467ddcb655d197897f7bbd76c7da235f2991
+  data.tar.gz: 936fdce7bd2fde2339e48bf43a9b4f9ae8c4b552844de6cf69bd445965477a3f
 SHA512:
-  metadata.gz: 701981fe8e9c6a229cc93042a40b4600e9d627903dd5f50e80089e2766c506ceb780c9feb3cb0ca3cdb1621be0e58db5cff0795925c8b42324d4b763312abaf0
-  data.tar.gz: 5500f4778efd6753dd6ffc9a5717c372c4a0d422db38695466bb2ddd9bb16a3a1ba138c34382f9ed3278c4a69ff75a29172ce581ce0138a20e4ab3b6c9b2be8a
+  metadata.gz: 74eae720741b8b4aee9e4d01d92d25d53cbd92f46066a4eb341881907a9c5291102b1cb10c4c59c81b2192adc4156bd6eaf619e51836ef661be03dde450f4415
+  data.tar.gz: 1080d1c3a72e238325e017974e34c1ad7ed56174811adcbf1c97d6b860566dd4886ebb71a9a634e8bc05826afd71045b4ef72edb622740ff72af8d6b887534ae

data/context/index.yaml

@@ -3,9 +3,9 @@
 ---
 description: CommonMark parser and renderer. Written in C, wrapped in Ruby.
 metadata:
-  documentation_uri: https://ioquatix.github.io/markly/
-  funding_uri: https://github.com/sponsors/ioquatix/
-  source_code_uri: https://github.com/ioquatix/markly.git
+  documentation_uri: https://socketry.github.io/markly/
+  funding_uri: https://github.com/sponsors/socketry/
+  source_code_uri: https://github.com/socketry/markly.git
 files:
 - path: getting-started.md
   title: Getting Started

data/ext/markly/blocks.c

@@ -23,6 +23,7 @@
 #include "houdini.h"
 #include "buffer.h"
 #include "footnotes.h"
+#include "front_matter.h"
 
 #define CODE_INDENT 4
 #define TAB_STOP 4
@@ -68,16 +69,12 @@ static CMARK_INLINE bool S_is_line_end_char(char c) {
   return (c == '\n' || c == '\r');
 }
 
-static CMARK_INLINE bool S_is_space_or_tab(char c) {
-  return (c == ' ' || c == '\t');
-}
-
 // Returns true if block is being finalized on the same line it ends.
 // This happens for:
 // - Document node (special case)
 // - Fenced code blocks (end on the closing fence line)
 // - Setext headings (end on the underline)
-// - HTML blocks types 1-5 per CommonMark spec §4.6 (end on the line
+// - HTML block types 1-5 per CommonMark spec §4.6 (end on the line
 //   containing the closing marker)
 // - Any block finalized on the same line it started (e.g., single-line blocks)
 static CMARK_INLINE bool S_ends_on_current_line(cmark_parser *parser, cmark_node *b) {
@@ -100,6 +97,10 @@ static CMARK_INLINE bool S_ends_on_current_line(cmark_parser *parser, cmark_node
          b->start_line == parser->line_number;
 }
 
+static CMARK_INLINE bool S_is_space_or_tab(char c) {
+  return (c == ' ' || c == '\t');
+}
+
 static void S_parser_feed(cmark_parser *parser, const unsigned char *buffer,
                           size_t len, bool eof);
 
@@ -159,6 +160,8 @@ static void cmark_parser_reset(cmark_parser *parser) {
 
   cmark_strbuf_init(parser->mem, &parser->curline, 256);
   cmark_strbuf_init(parser->mem, &parser->linebuf, 0);
+  cmark_strbuf_init(parser->mem, &parser->front_matter_buf, 0);
+  cmark_strbuf_init(parser->mem, &parser->front_matter_info, 0);
 
   cmark_node *document = make_document(parser->mem);
 
@@ -189,6 +192,8 @@ void cmark_parser_free(cmark_parser *parser) {
   cmark_parser_dispose(parser);
   cmark_strbuf_free(&parser->curline);
   cmark_strbuf_free(&parser->linebuf);
+  cmark_strbuf_free(&parser->front_matter_buf);
+  cmark_strbuf_free(&parser->front_matter_info);
   cmark_llist_free(parser->mem, parser->syntax_extensions);
   cmark_llist_free(parser->mem, parser->inline_syntax_extensions);
   mem->free(parser);
@@ -1244,7 +1249,8 @@ static void open_new_blocks(cmark_parser *parser, cmark_node **container,
                              parser->first_nonspace + 1);
       S_advance_offset(parser, input, input->len - 1 - parser->offset, false);
     } else if (!indented &&
-               parser->options & CMARK_OPT_FOOTNOTES &&
+               (parser->options & CMARK_OPT_FOOTNOTES) &&
+               depth < MAX_LIST_DEPTH &&
                (matched = scan_footnote_definition(input, parser->first_nonspace))) {
       cmark_chunk c = cmark_chunk_dup(input, parser->first_nonspace + 2, matched - 2);
 
@@ -1516,6 +1522,10 @@ static void S_process_line(cmark_parser *parser, const unsigned char *buffer,
 
   parser->line_number++;
 
+  if ((parser->options & CMARK_OPT_FRONT_MATTER) &&
+      cmark_front_matter_process_line(parser, &input))
+    goto finished;
+
   last_matched_container = check_open_blocks(parser, &input, &all_matched);
 
   if (!last_matched_container)
@@ -1556,12 +1566,20 @@ cmark_node *cmark_parser_finish(cmark_parser *parser) {
     cmark_strbuf_clear(&parser->linebuf);
   }
 
+  // If front matter scanning was still active when the document ended, no
+  // closing delimiter was found.  The entire document (after the opening ---)
+  // is treated as front matter.
+  if ((parser->options & CMARK_OPT_FRONT_MATTER) && parser->front_matter_scanning)
+    cmark_front_matter_process_line(parser, NULL);
+
   finalize_document(parser);
 
   cmark_consolidate_text_nodes(parser->root);
 
   cmark_strbuf_free(&parser->curline);
   cmark_strbuf_free(&parser->linebuf);
+  cmark_strbuf_free(&parser->front_matter_buf);
+  cmark_strbuf_free(&parser->front_matter_info);
 
 #if CMARK_DEBUG_NODES
   if (cmark_node_check(parser->root, stderr)) {

data/ext/markly/cmark-gfm.h

@@ -53,6 +53,7 @@ typedef enum {
   CMARK_NODE_HEADING        = CMARK_NODE_TYPE_BLOCK | 0x0009,
   CMARK_NODE_THEMATIC_BREAK = CMARK_NODE_TYPE_BLOCK | 0x000a,
   CMARK_NODE_FOOTNOTE_DEFINITION = CMARK_NODE_TYPE_BLOCK | 0x000b,
+  CMARK_NODE_FRONT_MATTER       = CMARK_NODE_TYPE_BLOCK | 0x000c,
 
   /* Inline */
   CMARK_NODE_TEXT          = CMARK_NODE_TYPE_INLINE | 0x0001,
@@ -768,6 +769,13 @@ char *cmark_render_latex_with_mem(cmark_node *root, int options, int width, cmar
  */
 #define CMARK_OPT_FULL_INFO_STRING (1 << 16)
 
+/** Parse front matter ("---" delimited block at the start of the document)
+ *  and expose it as a CMARK_NODE_FRONT_MATTER node.  The raw content between
+ *  the delimiters is available via cmark_node_get_literal(); how it is
+ *  interpreted (e.g. as YAML, TOML, JSON) is left to the caller.
+ */
+#define CMARK_OPT_FRONT_MATTER (1 << 18)
+
 /**
  * ## Version information
  */

data/ext/markly/cmark.c

@@ -7,7 +7,7 @@
 #include "cmark-gfm.h"
 #include "buffer.h"
 
-cmark_node_type CMARK_NODE_LAST_BLOCK = CMARK_NODE_FOOTNOTE_DEFINITION;
+cmark_node_type CMARK_NODE_LAST_BLOCK = CMARK_NODE_FRONT_MATTER;
 cmark_node_type CMARK_NODE_LAST_INLINE = CMARK_NODE_FOOTNOTE_REFERENCE;
 
 int cmark_version(void) { return CMARK_GFM_VERSION; }

data/ext/markly/commonmark.c

@@ -492,6 +492,19 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node,
     }
     break;
 
+  case CMARK_NODE_FRONT_MATTER:
+    if (entering) {
+      const char *info = cmark_node_get_fence_info(node);
+      BLANKLINE();
+      LIT("---");
+      if (info && *info) { LIT(" "); OUT(info, false, LITERAL); }
+      LIT("\n");
+      OUT(cmark_node_get_literal(node), false, LITERAL);
+      LIT("---\n");
+      BLANKLINE();
+    }
+    break;
+
   default:
     assert(false);
     break;

data/ext/markly/extconf.rb

@@ -6,12 +6,17 @@
 # Copyright, 2015-2019, by Garen Torikian.
 # Copyright, 2016-2017, by Yuki Izumi.
 # Copyright, 2017, by Ashe Connor.
-# Copyright, 2020-2025, by Samuel Williams.
+# Copyright, 2020-2026, by Samuel Williams.
 
 require "mkmf"
 
 append_cflags(["-O3", "-Wall", "-Wno-unknown-pragmas", "-std=c99"])
 
+# Include the extensions/ subdirectory, mirroring the cmark-gfm source layout.
+$INCFLAGS << " -I$(srcdir)/extensions"
+$VPATH    << "$(srcdir)/extensions"
+$srcs = (Dir["#{$srcdir}/*.c"] + Dir["#{$srcdir}/extensions/*.c"]).map{|f| File.basename(f)}
+
 gem_name = File.basename(__dir__)
 extension_name = "markly"
 

data/ext/markly/{table.c → extensions/table.c}

@@ -11,6 +11,9 @@
 #include "table.h"
 #include "cmark-gfm-core-extensions.h"
 
+// Limit to prevent a malicious input from causing a denial of service.
+#define MAX_AUTOCOMPLETED_CELLS 0x80000
+
 // Custom node flag, initialized in `create_table_extension`.
 static cmark_node_internal_flags CMARK_NODE__TABLE_VISITED;
 
@@ -31,6 +34,8 @@ typedef struct {
 typedef struct {
   uint16_t n_columns;
   uint8_t *alignments;
+  int n_rows;
+  int n_nonempty_cells;
 } node_table;
 
 typedef struct {
@@ -83,6 +88,33 @@ static int set_n_table_columns(cmark_node *node, uint16_t n_columns) {
   return 1;
 }
 
+// Increment the number of rows in the table. Also update n_nonempty_cells,
+// which keeps track of the number of cells which were parsed from the
+// input file. (If one of the rows is too short, then the trailing cells
+// are autocompleted. Autocompleted cells are not counted in n_nonempty_cells.)
+// The purpose of this is to prevent a malicious input from generating a very
+// large number of autocompleted cells, which could cause a denial of service
+// vulnerability.
+static int incr_table_row_count(cmark_node *node, int i) {
+  if (!node || node->type != CMARK_NODE_TABLE) {
+    return 0;
+  }
+
+  ((node_table *)node->as.opaque)->n_rows++;
+  ((node_table *)node->as.opaque)->n_nonempty_cells += i;
+  return 1;
+}
+
+// Calculate the number of autocompleted cells.
+static int get_n_autocompleted_cells(cmark_node *node) {
+  if (!node || node->type != CMARK_NODE_TABLE) {
+    return 0;
+  }
+
+  const node_table *nt = (node_table *)node->as.opaque;
+  return (nt->n_columns * nt->n_rows) - nt->n_nonempty_cells;
+}
+
 static uint8_t *get_table_alignments(cmark_node *node) {
   if (!node || node->type != CMARK_NODE_TABLE)
     return 0;
@@ -98,6 +130,23 @@ static int set_table_alignments(cmark_node *node, uint8_t *alignments) {
   return 1;
 }
 
+static uint8_t get_cell_alignment(cmark_node *node) {
+  if (!node || node->type != CMARK_NODE_TABLE_CELL)
+    return 0;
+
+  const uint8_t *alignments = get_table_alignments(node->parent->parent);
+  int i = node->as.cell_index;
+  return alignments[i];
+}
+
+static int set_cell_index(cmark_node *node, int i) {
+  if (!node || node->type != CMARK_NODE_TABLE_CELL)
+    return 0;
+
+  node->as.cell_index = i;
+  return 1;
+}
+
 static cmark_strbuf *unescape_pipes(cmark_mem *mem, unsigned char *string, bufsize_t len)
 {
   cmark_strbuf *res = (cmark_strbuf *)mem->calloc(1, sizeof(cmark_strbuf));
@@ -257,7 +306,7 @@ static cmark_node *try_opening_table_header(cmark_syntax_extension *self,
                                             unsigned char *input, int len) {
   cmark_node *table_header;
   table_row *header_row = NULL;
-  table_row *marker_row = NULL;
+  table_row *delimiter_row = NULL;
   node_table_row *ntr;
   const char *parent_string;
   uint16_t i;
@@ -270,16 +319,16 @@ static cmark_node *try_opening_table_header(cmark_syntax_extension *self,
     return parent_container;
   }
 
-  // Since scan_table_start was successful, we must have a marker row.
-  marker_row = row_from_string(self, parser,
-                               input + cmark_parser_get_first_nonspace(parser),
-                               len - cmark_parser_get_first_nonspace(parser));
+  // Since scan_table_start was successful, we must have a delimiter row.
+  delimiter_row = row_from_string(
+    self, parser, input + cmark_parser_get_first_nonspace(parser),
+    len - cmark_parser_get_first_nonspace(parser));
   // assert may be optimized out, don't rely on it for security boundaries
-  if (!marker_row) {
+  if (!delimiter_row) {
       return parent_container;
   }
-  
-  assert(marker_row);
+
+  assert(delimiter_row);
 
   cmark_arena_push();
 
@@ -289,8 +338,8 @@ static cmark_node *try_opening_table_header(cmark_syntax_extension *self,
   parent_string = cmark_node_get_string_content(parent_container);
   header_row = row_from_string(self, parser, (unsigned char *)parent_string,
                                (int)strlen(parent_string));
-  if (!header_row || header_row->n_columns != marker_row->n_columns) {
-    free_table_row(parser->mem, marker_row);
+  if (!header_row || header_row->n_columns != delimiter_row->n_columns) {
+    free_table_row(parser->mem, delimiter_row);
     free_table_row(parser->mem, header_row);
     cmark_arena_pop();
     parent_container->flags |= CMARK_NODE__TABLE_VISITED;
@@ -298,14 +347,14 @@ static cmark_node *try_opening_table_header(cmark_syntax_extension *self,
   }
 
   if (cmark_arena_pop()) {
-    marker_row = row_from_string(
+    delimiter_row = row_from_string(
         self, parser, input + cmark_parser_get_first_nonspace(parser),
         len - cmark_parser_get_first_nonspace(parser));
     header_row = row_from_string(self, parser, (unsigned char *)parent_string,
                                  (int)strlen(parent_string));
     // row_from_string can return NULL, add additional check to ensure n_columns match
-    if (!marker_row || !header_row || header_row->n_columns != marker_row->n_columns) {
-        free_table_row(parser->mem, marker_row);
+    if (!delimiter_row || !header_row || header_row->n_columns != delimiter_row->n_columns) {
+        free_table_row(parser->mem, delimiter_row);
         free_table_row(parser->mem, header_row);
         return parent_container;
     }
@@ -313,7 +362,7 @@ static cmark_node *try_opening_table_header(cmark_syntax_extension *self,
 
   if (!cmark_node_set_type(parent_container, CMARK_NODE_TABLE)) {
     free_table_row(parser->mem, header_row);
-    free_table_row(parser->mem, marker_row);
+    free_table_row(parser->mem, delimiter_row);
     return parent_container;
   }
 
@@ -326,12 +375,12 @@ static cmark_node *try_opening_table_header(cmark_syntax_extension *self,
   parent_container->as.opaque = parser->mem->calloc(1, sizeof(node_table));
   set_n_table_columns(parent_container, header_row->n_columns);
 
-  // allocate alignments based on marker_row->n_columns
-  // since we populate the alignments array based on marker_row->cells
+  // allocate alignments based on delimiter_row->n_columns
+  // since we populate the alignments array based on delimiter_row->cells
   uint8_t *alignments =
-      (uint8_t *)parser->mem->calloc(marker_row->n_columns, sizeof(uint8_t));
-  for (i = 0; i < marker_row->n_columns; ++i) {
-    node_cell *node = &marker_row->cells[i];
+      (uint8_t *)parser->mem->calloc(delimiter_row->n_columns, sizeof(uint8_t));
+  for (i = 0; i < delimiter_row->n_columns; ++i) {
+    node_cell *node = &delimiter_row->cells[i];
     bool left = node->buf->ptr[0] == ':', right = node->buf->ptr[node->buf->size - 1] == ':';
 
     if (left && right)
@@ -353,25 +402,26 @@ static cmark_node *try_opening_table_header(cmark_syntax_extension *self,
   table_header->as.opaque = ntr = (node_table_row *)parser->mem->calloc(1, sizeof(node_table_row));
   ntr->is_header = true;
 
-  {
-    for (i = 0; i < header_row->n_columns; ++i) {
-      node_cell *cell = &header_row->cells[i];
-      cmark_node *header_cell = cmark_parser_add_child(parser, table_header,
-          CMARK_NODE_TABLE_CELL, parent_container->start_column + cell->start_offset);
-      header_cell->start_line = header_cell->end_line = parent_container->start_line;
-      header_cell->internal_offset = cell->internal_offset;
-      header_cell->end_column = parent_container->start_column + cell->end_offset;
-      cmark_node_set_string_content(header_cell, (char *) cell->buf->ptr);
-      cmark_node_set_syntax_extension(header_cell, self);
-    }
+  for (i = 0; i < header_row->n_columns; ++i) {
+    node_cell *cell = &header_row->cells[i];
+    cmark_node *header_cell = cmark_parser_add_child(parser, table_header,
+                                                     CMARK_NODE_TABLE_CELL, parent_container->start_column + cell->start_offset);
+    header_cell->start_line = header_cell->end_line = parent_container->start_line;
+    header_cell->internal_offset = cell->internal_offset;
+    header_cell->end_column = parent_container->start_column + cell->end_offset;
+    cmark_node_set_string_content(header_cell, (char *) cell->buf->ptr);
+    cmark_node_set_syntax_extension(header_cell, self);
+    set_cell_index(header_cell, i);
   }
 
+  incr_table_row_count(parent_container, i);
+
   cmark_parser_advance_offset(
       parser, (char *)input,
       (int)strlen((char *)input) - 1 - cmark_parser_get_offset(parser), false);
 
   free_table_row(parser->mem, header_row);
-  free_table_row(parser->mem, marker_row);
+  free_table_row(parser->mem, delimiter_row);
   return parent_container;
 }
 
@@ -385,6 +435,10 @@ static cmark_node *try_opening_table_row(cmark_syntax_extension *self,
   if (cmark_parser_is_blank(parser))
     return NULL;
 
+  if (get_n_autocompleted_cells(parent_container) > MAX_AUTOCOMPLETED_CELLS) {
+    return NULL;
+  }
+
   table_row_block =
       cmark_parser_add_child(parser, parent_container, CMARK_NODE_TABLE_ROW,
                              parent_container->start_column);
@@ -412,12 +466,16 @@ static cmark_node *try_opening_table_row(cmark_syntax_extension *self,
       node->end_column = parent_container->start_column + cell->end_offset;
       cmark_node_set_string_content(node, (char *) cell->buf->ptr);
       cmark_node_set_syntax_extension(node, self);
+      set_cell_index(node, i);
     }
 
+    incr_table_row_count(parent_container, i);
+
     for (; i < table_columns; ++i) {
       cmark_node *node = cmark_parser_add_child(
           parser, table_row_block, CMARK_NODE_TABLE_CELL, 0);
       cmark_node_set_syntax_extension(node, self);
+      set_cell_index(node, i);
     }
   }
 
@@ -602,13 +660,7 @@ static const char *xml_attr(cmark_syntax_extension *extension,
                             cmark_node *node) {
   if (node->type == CMARK_NODE_TABLE_CELL) {
     if (cmark_gfm_extensions_get_table_row_is_header(node->parent)) {
-      uint8_t *alignments = get_table_alignments(node->parent->parent);
-      int i = 0;
-      cmark_node *n;
-      for (n = node->parent->first_child; n; n = n->next, ++i)
-        if (n == node)
-          break;
-      switch (alignments[i]) {
+      switch (get_cell_alignment(node)) {
       case 'l': return " align=\"left\"";
       case 'c': return " align=\"center\"";
       case 'r': return " align=\"right\"";
@@ -696,7 +748,6 @@ static void html_render(cmark_syntax_extension *extension,
                         cmark_event_type ev_type, int options) {
   bool entering = (ev_type == CMARK_EVENT_ENTER);
   cmark_strbuf *html = renderer->html;
-  cmark_node *n;
 
   // XXX: we just monopolise renderer->opaque.
   struct html_table_state *table_state =
@@ -745,7 +796,6 @@ static void html_render(cmark_syntax_extension *extension,
       }
     }
   } else if (node->type == CMARK_NODE_TABLE_CELL) {
-    uint8_t *alignments = get_table_alignments(node->parent->parent);
     if (entering) {
       cmark_html_render_cr(html);
       if (table_state->in_table_header) {
@@ -754,12 +804,7 @@ static void html_render(cmark_syntax_extension *extension,
         cmark_strbuf_puts(html, "<td");
       }
 
-      int i = 0;
-      for (n = node->parent->first_child; n; n = n->next, ++i)
-        if (n == node)
-          break;
-
-      switch (alignments[i]) {
+      switch (get_cell_alignment(node)) {
       case 'l': html_table_add_align(html, "left", options); break;
       case 'c': html_table_add_align(html, "center", options); break;
       case 'r': html_table_add_align(html, "right", options); break;

data/ext/markly/front_matter.c

@@ -0,0 +1,141 @@
+#include "front_matter.h"
+#include "cmark-gfm.h"
+
+#include <string.h>
+
+// ---------------------------------------------------------------------------
+// Delimiter and info string parsing
+// ---------------------------------------------------------------------------
+
+// Return true if `input` is an opening front matter delimiter: "---" followed
+// by an optional info string and a newline.  No leading whitespace before
+// "---" is permitted.
+//
+// Note: some tools (e.g. Jekyll) also accept "..." as a closing delimiter,
+// derived from the YAML document-end marker.  We intentionally do not support
+// it here because this implementation is format-agnostic — the content between
+// the delimiters may be YAML, TOML, JSON, or anything else.  "..." has no
+// meaning outside of YAML, so "---" is the only unambiguous delimiter.
+static bool is_opening_delimiter(cmark_chunk *input) {
+  const unsigned char *p = input->data;
+  if (input->len < 3 || !(p[0] == '-' && p[1] == '-' && p[2] == '-'))
+    return false;
+  // A fourth consecutive dash produces a longer thematic break, not a
+  // front matter delimiter.
+  if (input->len > 3 && p[3] == '-')
+    return false;
+  return true;
+}
+
+// Return true if `input` is a closing front matter delimiter: exactly "---"
+// with optional trailing whitespace then a newline.  An info string is not
+// permitted on the closing delimiter.
+static bool is_closing_delimiter(cmark_chunk *input) {
+  const unsigned char *p = input->data;
+  int len = input->len;
+
+  if (len < 3 || !(p[0] == '-' && p[1] == '-' && p[2] == '-'))
+    return false;
+
+  for (int i = 3; i < len; i++) {
+    if (p[i] == '\n' || p[i] == '\r')
+      return true;
+    if (p[i] != ' ' && p[i] != '\t')
+      return false;
+  }
+  return true;
+}
+
+// Extract the optional info string from an opening delimiter line, e.g.
+// "--- yaml\n" yields "yaml".  Returns a zero-length chunk if absent.
+static cmark_chunk parse_info(cmark_chunk *input) {
+  const unsigned char *p = input->data + 3;
+  int len = input->len - 3;
+
+  while (len > 0 && (*p == ' ' || *p == '\t')) { p++; len--; }
+  while (len > 0 && (p[len-1] == '\n' || p[len-1] == '\r' ||
+                     p[len-1] == ' '  || p[len-1] == '\t'))
+    len--;
+
+  return (cmark_chunk){ .data = (unsigned char *)p,
+                        .len  = (bufsize_t)len,
+                        .alloc = 0 };
+}
+
+// ---------------------------------------------------------------------------
+// Node creation
+// ---------------------------------------------------------------------------
+
+static void create_front_matter_node(cmark_parser *parser) {
+  cmark_node *node =
+      cmark_node_new_with_mem(CMARK_NODE_FRONT_MATTER, parser->mem);
+
+  // Store identically to a code block: info string + literal content.
+  cmark_node_set_fence_info(node,
+      parser->front_matter_info.size > 0
+          ? (const char *)parser->front_matter_info.ptr
+          : "");
+
+  cmark_node_set_literal(node,
+      parser->front_matter_buf.size > 0
+          ? (const char *)parser->front_matter_buf.ptr
+          : "");
+
+  node->start_line = 1;
+  node->start_column = 1;
+  node->end_line = parser->line_number;
+  node->end_column = 3;
+
+  cmark_node *first = cmark_node_first_child(parser->root);
+  if (first)
+    cmark_node_insert_before(first, node);
+  else
+    cmark_node_append_child(parser->root, node);
+
+  parser->front_matter_scanning = false;
+  cmark_strbuf_clear(&parser->front_matter_buf);
+  cmark_strbuf_clear(&parser->front_matter_info);
+}
+
+// ---------------------------------------------------------------------------
+// State machine — called from S_process_line in blocks.c
+// ---------------------------------------------------------------------------
+
+bool cmark_front_matter_process_line(cmark_parser *parser, cmark_chunk *input) {
+  // NULL signals end-of-document: the whole document is the front matter.
+  if (input == NULL) {
+    create_front_matter_node(parser);
+    return true;
+  }
+
+  // Adjust for any offset already consumed (e.g. a UTF-8 BOM on line 1).
+  cmark_chunk adjusted = {
+    .data  = input->data + parser->offset,
+    .len   = input->len  - parser->offset,
+    .alloc = 0,
+  };
+  input = &adjusted;
+
+  if (parser->line_number == 1) {
+    if (is_opening_delimiter(input)) {
+      parser->front_matter_scanning = true;
+      // Capture optional info string (e.g. "yaml" from "--- yaml\n").
+      cmark_chunk info = parse_info(input);
+      if (info.len > 0)
+        cmark_strbuf_put(&parser->front_matter_info, info.data, info.len);
+    }
+    return parser->front_matter_scanning;
+  }
+
+  if (!parser->front_matter_scanning)
+    return false;
+
+  if (is_closing_delimiter(input)) {
+    create_front_matter_node(parser);
+    return true;
+  }
+
+  // Accumulate this content line.
+  cmark_strbuf_put(&parser->front_matter_buf, input->data, input->len);
+  return true;
+}

data/ext/markly/front_matter.h

@@ -0,0 +1,24 @@
+#ifndef CMARK_FRONT_MATTER_H
+#define CMARK_FRONT_MATTER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "cmark-gfm.h"
+#include "parser.h"
+#include "chunk.h"
+
+// Called from S_process_line in blocks.c for every line when
+// CMARK_OPT_FRONT_MATTER is set.  Drives the front matter state machine
+// stored directly on the parser (front_matter_scanning / front_matter_buf).
+//
+// Returns true if the line was consumed by the front matter scanner and
+// should not be passed to the normal block parser.
+bool cmark_front_matter_process_line(cmark_parser *parser, cmark_chunk *input);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/markly/html.c

@@ -457,6 +457,9 @@ static int S_render_node(cmark_html_renderer *renderer, cmark_node *node,
     }
     break;
 
+  case CMARK_NODE_FRONT_MATTER:
+    break;
+
   default:
     assert(false);
     break;

data/ext/markly/latex.c

@@ -451,6 +451,9 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node,
     // TODO
     break;
 
+  case CMARK_NODE_FRONT_MATTER:
+    break;
+
   default:
     assert(false);
     break;

data/ext/markly/man.c

@@ -257,6 +257,9 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node,
     // TODO
     break;
 
+  case CMARK_NODE_FRONT_MATTER:
+    break;
+
   default:
     assert(false);
     break;

data/ext/markly/markly.c

@@ -6,6 +6,7 @@
 #include "parser.h"
 #include "syntax_extension.h"
 #include "cmark-gfm-core-extensions.h"
+#include "front_matter.h"
 
 static VALUE rb_Markly;
 static VALUE rb_Markly_Error;
@@ -34,6 +35,7 @@ static VALUE sym_link;
 static VALUE sym_image;
 static VALUE sym_footnote_reference;
 static VALUE sym_footnote_definition;
+static VALUE sym_front_matter;
 
 static VALUE sym_bullet_list;
 static VALUE sym_ordered_list;
@@ -416,6 +418,9 @@ static VALUE rb_node_get_type(VALUE self) {
 	case CMARK_NODE_FOOTNOTE_DEFINITION:
 		symbol = sym_footnote_definition;
 		break;
+	case CMARK_NODE_FRONT_MATTER:
+		symbol = sym_front_matter;
+		break;
 	default:
 		if (node->extension) {
 			s = node->extension->get_type_string_func(node->extension, node);
@@ -1185,6 +1190,7 @@ __attribute__((visibility("default"))) void Init_markly(void) {
 	sym_image = ID2SYM(rb_intern("image"));
 	sym_footnote_reference = ID2SYM(rb_intern("footnote_reference"));
 	sym_footnote_definition = ID2SYM(rb_intern("footnote_definition"));
+	sym_front_matter = ID2SYM(rb_intern("front_matter"));
 	
 	sym_bullet_list = ID2SYM(rb_intern("bullet_list"));
 	sym_ordered_list = ID2SYM(rb_intern("ordered_list"));

data/ext/markly/node.c

@@ -148,6 +148,7 @@ cmark_node *cmark_node_new(cmark_node_type type) {
 static void free_node_as(cmark_node *node) {
   switch (node->type) {
     case CMARK_NODE_CODE_BLOCK:
+    case CMARK_NODE_FRONT_MATTER:
     cmark_chunk_free(NODE_MEM(node), &node->as.code.info);
     cmark_chunk_free(NODE_MEM(node), &node->as.code.literal);
       break;
@@ -288,6 +289,8 @@ const char *cmark_node_get_type_string(cmark_node *node) {
     return "link";
   case CMARK_NODE_IMAGE:
     return "image";
+  case CMARK_NODE_FRONT_MATTER:
+    return "front_matter";
   }
 
   return "<unknown>";
@@ -381,6 +384,7 @@ const char *cmark_node_get_literal(cmark_node *node) {
     return cmark_chunk_to_cstr(NODE_MEM(node), &node->as.literal);
 
   case CMARK_NODE_CODE_BLOCK:
+  case CMARK_NODE_FRONT_MATTER:
     return cmark_chunk_to_cstr(NODE_MEM(node), &node->as.code.literal);
 
   default:
@@ -405,6 +409,7 @@ int cmark_node_set_literal(cmark_node *node, const char *content) {
     return 1;
 
   case CMARK_NODE_CODE_BLOCK:
+  case CMARK_NODE_FRONT_MATTER:
     cmark_chunk_set_cstr(NODE_MEM(node), &node->as.code.literal, content);
     return 1;
 
@@ -595,7 +600,8 @@ const char *cmark_node_get_fence_info(cmark_node *node) {
     return NULL;
   }
 
-  if (node->type == CMARK_NODE_CODE_BLOCK) {
+  if (node->type == CMARK_NODE_CODE_BLOCK ||
+      node->type == CMARK_NODE_FRONT_MATTER) {
     return cmark_chunk_to_cstr(NODE_MEM(node), &node->as.code.info);
   } else {
     return NULL;
@@ -607,7 +613,8 @@ int cmark_node_set_fence_info(cmark_node *node, const char *info) {
     return 0;
   }
 
-  if (node->type == CMARK_NODE_CODE_BLOCK) {
+  if (node->type == CMARK_NODE_CODE_BLOCK ||
+      node->type == CMARK_NODE_FRONT_MATTER) {
     cmark_chunk_set_cstr(NODE_MEM(node), &node->as.code.info, info);
     return 1;
   } else {

data/ext/markly/node.h

@@ -105,6 +105,7 @@ struct cmark_node {
     cmark_link link;
     cmark_custom custom;
     int html_block_type;
+    int cell_index; // For keeping track of TABLE_CELL table alignments
     void *opaque;
   } as;
 };

data/ext/markly/parser.h

@@ -50,6 +50,25 @@ struct cmark_parser {
   cmark_llist *syntax_extensions;
   cmark_llist *inline_syntax_extensions;
   cmark_ispunct_func backslash_ispunct;
+
+  /* Front matter scanning state (CMARK_OPT_FRONT_MATTER).
+   *
+   * cmark_front_matter_process_line() is called from S_process_line() in
+   * blocks.c immediately after parser->line_number is incremented, so the
+   * first line of the document arrives with line_number == 1.  The function
+   * relies on this: it uses line_number == 1 as the trigger to decide
+   * whether the document opens with a front matter block.
+   *
+   * front_matter_scanning is set to true when a valid opening "---" is seen
+   * on line 1 and remains true until the matching closing "---" is found or
+   * the document ends.  While scanning, each content line is accumulated in
+   * front_matter_buf.  Both fields are reset to zero/empty by
+   * cmark_parser_reset() (via memset + strbuf re-init) and the strbuf is
+   * freed explicitly in cmark_parser_finish() and cmark_parser_free().
+   */
+  bool front_matter_scanning;
+  cmark_strbuf front_matter_buf;  /* accumulated content lines */
+  cmark_strbuf front_matter_info; /* optional format hint from opening "--- <info>" */
 };
 
 #ifdef __cplusplus

data/ext/markly/plaintext.c

@@ -196,6 +196,9 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node,
       cmark_strbuf_truncate(renderer->prefix, renderer->prefix->size - 4);
     }
     break;
+  case CMARK_NODE_FRONT_MATTER:
+    break;
+
   default:
     assert(false);
     break;

data/ext/markly/xml.c

@@ -64,6 +64,13 @@ static int S_render_node(cmark_node *node, cmark_event_type ev_type,
     case CMARK_NODE_DOCUMENT:
       cmark_strbuf_puts(xml, " xmlns=\"http://commonmark.org/xml/1.0\"");
       break;
+    case CMARK_NODE_FRONT_MATTER:
+      cmark_strbuf_puts(xml, " xml:space=\"preserve\">");
+      escape_xml(xml, node->as.code.literal.data, node->as.code.literal.len);
+      cmark_strbuf_puts(xml, "</");
+      cmark_strbuf_puts(xml, cmark_node_get_type_string(node));
+      literal = true;
+      break;
     case CMARK_NODE_TEXT:
     case CMARK_NODE_CODE:
     case CMARK_NODE_HTML_BLOCK:

data/lib/markly/flags.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2020-2023, by Samuel Williams.
+# Copyright, 2020-2026, by Samuel Williams.
 
 module Markly
 	# The default parsing system.
@@ -18,8 +18,14 @@ module Markly
 	STRIKETHROUGH_DOUBLE_TILDE = 1 << 14
 	# Allow raw/custom HTML and unsafe links.
 	UNSAFE = 1 << 17
+	# Parse front matter ("---" delimited block at start of document).
+	# The raw content is available via node.string_content and the optional
+	# format hint (e.g. "yaml", "toml") via node.fence_info; interpretation
+	# is left to the caller.
+	FRONT_MATTER = 1 << 18
 	
 	PARSE_FLAGS = {
+		front_matter: FRONT_MATTER,
 		validate_utf8: VALIDATE_UTF8,
 		smart_quotes: SMART,
 		liberal_html_tags: LIBERAL_HTML_TAG,

data/lib/markly/version.rb

@@ -4,8 +4,8 @@
 # Copyright, 2015-2020, by Garen Torikian.
 # Copyright, 2016-2017, by Yuki Izumi.
 # Copyright, 2017-2018, by Ashe Connor.
-# Copyright, 2020-2025, by Samuel Williams.
+# Copyright, 2020-2026, by Samuel Williams.
 
 module Markly
-	VERSION = "0.15.3"
+	VERSION = "0.16.0"
 end

data/readme.md

@@ -2,7 +2,7 @@
 
 A parser and abstract syntax tree for Markdown documents (CommonMark compatible) in Ruby. Originally forked from [CommonMarker](https://github.com/gjtorikian/commonmarker). It also includes extensions to the CommonMark spec as documented in the [GitHub Flavored Markdown spec](http://github.github.com/gfm/), such as support for tables, strikethroughs, and autolinking.
 
-[![Development Status](https://github.com/ioquatix/markly/workflows/Test/badge.svg)](https://github.com/ioquatix/markly/actions?workflow=Test)
+[![Development Status](https://github.com/socketry/markly/workflows/Test/badge.svg)](https://github.com/socketry/markly/actions?workflow=Test)
 
 ## Motivation
 
@@ -12,17 +12,23 @@ It should be noted that `commonmarker` re-introduced AST access, but the origina
 
 ## Usage
 
-Please see the [project documentation](https://ioquatix.github.io/markly/) for more details.
+Please see the [project documentation](https://socketry.github.io/markly/) for more details.
 
-  - [Getting Started](https://ioquatix.github.io/markly/guides/getting-started/index) - This guide explains now to install and use Markly.
+  - [Getting Started](https://socketry.github.io/markly/guides/getting-started/index) - This guide explains now to install and use Markly.
 
-  - [Abstract Syntax Tree](https://ioquatix.github.io/markly/guides/abstract-syntax-tree/index) - This guide explains how to use Markly's abstract syntax tree (AST) to parse and manipulate Markdown documents.
+  - [Abstract Syntax Tree](https://socketry.github.io/markly/guides/abstract-syntax-tree/index) - This guide explains how to use Markly's abstract syntax tree (AST) to parse and manipulate Markdown documents.
 
-  - [Headings](https://ioquatix.github.io/markly/guides/headings/index) - This guide explains how to work with headings in Markly, including extracting them for navigation and handling duplicate heading text.
+  - [Headings](https://socketry.github.io/markly/guides/headings/index) - This guide explains how to work with headings in Markly, including extracting them for navigation and handling duplicate heading text.
 
 ## Releases
 
-Please see the [project releases](https://ioquatix.github.io/markly/releases/index) for all releases.
+Please see the [project releases](https://socketry.github.io/markly/releases/index) for all releases.
+
+### v0.16.0
+
+  - Update `cmark-gfm` from upstream, including a denial-of-service fix for tables with a large number of autocompleted cells, corrected `end_line` source positions for single-line and multi-line HTML blocks, and a fix for trailing newlines when rendering inline nodes.
+  - Add support for front matter (`CMARK_OPT_FRONT_MATTER`): a `---` delimited block at the start of a document is captured as a `CMARK_NODE_FRONT_MATTER` node.  The raw content is available via `node.string_content` and an optional format hint (e.g. `"yaml"`, `"toml"`) via `node.fence_info`.
+  - Allow `:` in HTML tag names to support XML namespace prefixes (e.g. `<svg:circle>`, `<xhtml:div>`).
 
 ### v0.15.1
 

data/releases.md

@@ -1,5 +1,11 @@
 # Releases
 
+## v0.16.0
+
+  - Update `cmark-gfm` from upstream, including a denial-of-service fix for tables with a large number of autocompleted cells, corrected `end_line` source positions for single-line and multi-line HTML blocks, and a fix for trailing newlines when rendering inline nodes.
+  - Add support for front matter (`CMARK_OPT_FRONT_MATTER`): a `---` delimited block at the start of a document is captured as a `CMARK_NODE_FRONT_MATTER` node.  The raw content is available via `node.string_content` and an optional format hint (e.g. `"yaml"`, `"toml"`) via `node.fence_info`.
+  - Allow `:` in HTML tag names to support XML namespace prefixes (e.g. `<svg:circle>`, `<xhtml:div>`).
+
 ## v0.15.1
 
   - Add agent context.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: markly
 version: !ruby/object:Gem::Version
-  version: 0.15.3
+  version: 0.16.0
 platform: ruby
 authors:
 - Garen Torikian
@@ -69,16 +69,12 @@ files:
 - context/headings.md
 - context/index.yaml
 - ext/markly/arena.c
-- ext/markly/autolink.c
-- ext/markly/autolink.h
 - ext/markly/blocks.c
 - ext/markly/buffer.c
 - ext/markly/buffer.h
 - ext/markly/case_fold_switch.inc
 - ext/markly/chunk.h
-- ext/markly/cmark-gfm-core-extensions.h
 - ext/markly/cmark-gfm-extension_api.h
-- ext/markly/cmark-gfm-extensions_export.h
 - ext/markly/cmark-gfm.h
 - ext/markly/cmark-gfm_export.h
 - ext/markly/cmark-gfm_version.h
@@ -87,13 +83,27 @@ files:
 - ext/markly/cmark_ctype.h
 - ext/markly/commonmark.c
 - ext/markly/config.h
-- ext/markly/core-extensions.c
 - ext/markly/entities.inc
-- ext/markly/ext_scanners.c
-- ext/markly/ext_scanners.h
 - ext/markly/extconf.rb
+- ext/markly/extensions/autolink.c
+- ext/markly/extensions/autolink.h
+- ext/markly/extensions/cmark-gfm-core-extensions.h
+- ext/markly/extensions/cmark-gfm-extensions_export.h
+- ext/markly/extensions/core-extensions.c
+- ext/markly/extensions/ext_scanners.c
+- ext/markly/extensions/ext_scanners.h
+- ext/markly/extensions/strikethrough.c
+- ext/markly/extensions/strikethrough.h
+- ext/markly/extensions/table.c
+- ext/markly/extensions/table.h
+- ext/markly/extensions/tagfilter.c
+- ext/markly/extensions/tagfilter.h
+- ext/markly/extensions/tasklist.c
+- ext/markly/extensions/tasklist.h
 - ext/markly/footnotes.c
 - ext/markly/footnotes.h
+- ext/markly/front_matter.c
+- ext/markly/front_matter.h
 - ext/markly/houdini.h
 - ext/markly/houdini_href_e.c
 - ext/markly/houdini_html_e.c
@@ -126,16 +136,8 @@ files:
 - ext/markly/scanners.c
 - ext/markly/scanners.h
 - ext/markly/scanners.re
-- ext/markly/strikethrough.c
-- ext/markly/strikethrough.h
 - ext/markly/syntax_extension.c
 - ext/markly/syntax_extension.h
-- ext/markly/table.c
-- ext/markly/table.h
-- ext/markly/tagfilter.c
-- ext/markly/tagfilter.h
-- ext/markly/tasklist.c
-- ext/markly/tasklist.h
 - ext/markly/utf8.c
 - ext/markly/utf8.h
 - ext/markly/xml.c
@@ -150,13 +152,13 @@ files:
 - license.md
 - readme.md
 - releases.md
-homepage: https://github.com/ioquatix/markly
+homepage: https://github.com/socketry/markly
 licenses:
 - MIT
 metadata:
-  documentation_uri: https://ioquatix.github.io/markly/
-  funding_uri: https://github.com/sponsors/ioquatix/
-  source_code_uri: https://github.com/ioquatix/markly.git
+  documentation_uri: https://socketry.github.io/markly/
+  funding_uri: https://github.com/sponsors/socketry/
+  source_code_uri: https://github.com/socketry/markly.git
 rdoc_options: []
 require_paths:
 - lib