markly 0.15.3 → 0.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 76b9702e08b93aa97c2fe8b02d0ac1faea07b8037cf093c48d87b4b7e260806a
-  data.tar.gz: b3cad63b1de5e67e2160c72731f28cea94d02fbe999c5b2f2201f3e94b6c84b7
+  metadata.gz: b86cb2d3095458e69fe2d6fc2b9d6eb7dbee37b15edf5cc7064104ef12b5cb98
+  data.tar.gz: 1ddb2cac9ff79ee9fd2012e67949ddd5886930f6c5ecb28b54edf2eeffbbf110
 SHA512:
-  metadata.gz: 701981fe8e9c6a229cc93042a40b4600e9d627903dd5f50e80089e2766c506ceb780c9feb3cb0ca3cdb1621be0e58db5cff0795925c8b42324d4b763312abaf0
-  data.tar.gz: 5500f4778efd6753dd6ffc9a5717c372c4a0d422db38695466bb2ddd9bb16a3a1ba138c34382f9ed3278c4a69ff75a29172ce581ce0138a20e4ab3b6c9b2be8a
+  metadata.gz: fbc478782839f1c5d20abd6f9697da6e870f4620873d1b1450b96e7f8e21c31f345d0461fbc6536da9f3a0b33b19ef7dd69a70c5f1edd40bc7e08b42cab66ac1
+  data.tar.gz: ef38f140dd12fbd5788e17f124f280fe25cb1a3af67963d0b8e1780b851adf75609f9da6f38e682ca4ff2a6f59d7d756dc5a7469ffaf76e99c9ea6a9f03b115f

data/context/getting-started.md

@@ -42,7 +42,9 @@ Markly accepts integer flags which control how the Markdown is parsed and render
 | ------------------------------------ | -----------
 | `Markly::DEFAULT`                    | The default parsing system.
 | `Markly::UNSAFE`                     | Allow raw/custom HTML and unsafe links.
+| `Markly::FRONT_MATTER`               | Parse front matter at the start of the document.
 | `Markly::FOOTNOTES`                  | Parse footnotes.
+| `Markly::INLINE_CODE_INFO`           | Parse language prefixes such as `ruby:` on inline code spans.
 | `Markly::LIBERAL_HTML_TAG`           | Support liberal parsing of inline HTML tags.
 | `Markly::SMART`                      | Use smart punctuation (curly quotes, etc.).
 | `Markly::STRIKETHROUGH_DOUBLE_TILDE` | Parse strikethroughs by double tildes (compatibility with [redcarpet](https://github.com/vmg/redcarpet))
@@ -76,6 +78,40 @@ To have multiple options applied, `|` (or) the flags together:
 Markly.render_html("\"'Shelob' is my name.\"", flags: Markly::HARD_BREAKS|Markly::SOURCE_POSITION)
 ```
 
+Inline code language prefixes are opt-in. The language is available through
+`Node#code_info` and is rendered as a `language-...` class:
+
+``` ruby
+document = Markly.parse("ruby:`Object.new`", flags: Markly::INLINE_CODE_INFO)
+code = document.first_child.first_child
+
+code.code_info
+# => "ruby"
+
+code.code_language
+# => "ruby"
+
+document.to_html
+# => <p><code class="language-ruby">Object.new</code></p>
+```
+
+`Node#code_info` is also the general info-string accessor for fenced code
+blocks and front matter. `Node#code_language` returns the first token of that
+info string, while `Node#fence_info` remains available for compatibility on
+those block nodes.
+
+For a fenced code block, `Node#fence` returns a `Node::Fence` structure with
+the fence character, length, and indentation:
+
+``` ruby
+block = Markly.parse("  ~~~~ ruby\n  Object.new\n  ~~~~").first_child
+
+block.fence
+# => #<struct Markly::Node::Fence character="~", length=4, indent=2>
+```
+
+Indented code blocks and other node types return `nil`.
+
 ## Extensions
 
 Both `render_html` and `parse` take an optional `extensions:` argument defining the extensions you want enabled as your CommonMark document is being processed:

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,
@@ -424,6 +425,18 @@ CMARK_GFM_EXPORT int cmark_node_get_item_index(cmark_node *node);
  */
 CMARK_GFM_EXPORT int cmark_node_set_item_index(cmark_node *node, int idx);
 
+/** Returns the info string from a code block or the language identifier from
+ * an inline code span.
+ */
+CMARK_GFM_EXPORT const char *cmark_node_get_code_info(cmark_node *node);
+
+/** Sets the info string in a code block or the language identifier on an
+ * inline code span, returning 1 on success and 0 on failure. Inline code
+ * language identifiers must begin with an alphanumeric character and may
+ * additionally contain '_', '-', '+', '#', and '.'.
+ */
+CMARK_GFM_EXPORT int cmark_node_set_code_info(cmark_node *node, const char *info);
+
 /** Returns the info string from a fenced code block.
  */
 CMARK_GFM_EXPORT const char *cmark_node_get_fence_info(cmark_node *node);
@@ -768,6 +781,17 @@ 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)
+
+/** Parse inline code language prefixes, e.g. ruby:`code`.
+ */
+#define CMARK_OPT_INLINE_CODE_INFO (1 << 19)
+
 /**
  * ## Version information
  */

data/ext/markly/cmark-gfm_export.h

@@ -33,6 +33,7 @@
 #  define CMARK_GFM_DEPRECATED_NO_EXPORT CMARK_GFM_NO_EXPORT CMARK_GFM_DEPRECATED
 #endif
 
+/* NOLINTNEXTLINE(readability-avoid-unconditional-preprocessor-if) */
 #if 0 /* DEFINE_NO_DEPRECATED */
 #  ifndef CMARK_GFM_NO_DEPRECATED
 #    define CMARK_GFM_NO_DEPRECATED

data/ext/markly/cmark-gfm_version.h

@@ -1,7 +1,7 @@
 #ifndef CMARK_GFM_VERSION_H
 #define CMARK_GFM_VERSION_H
 
-#define CMARK_GFM_VERSION ((0 << 24) | (29 << 16) | (0 << 8) | 2)
-#define CMARK_GFM_VERSION_STRING "0.29.0.gfm.2"
+#define CMARK_GFM_VERSION ((0 << 24) | (29 << 16) | (0 << 8) | 13)
+#define CMARK_GFM_VERSION_STRING "0.29.0.gfm.13"
 
 #endif

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/cmark_ctype.c

@@ -42,3 +42,12 @@ int cmark_isalnum(char c) {
 int cmark_isdigit(char c) { return cmark_ctype_class[(uint8_t)c] == 3; }
 
 int cmark_isalpha(char c) { return cmark_ctype_class[(uint8_t)c] == 4; }
+
+int cmark_is_inline_code_info_start_char(char c) {
+  return cmark_isalnum(c);
+}
+
+int cmark_is_inline_code_info_char(char c) {
+  return cmark_is_inline_code_info_start_char(c) || c == '_' || c == '-' ||
+         c == '+' || c == '#' || c == '.';
+}

data/ext/markly/cmark_ctype.h

@@ -26,6 +26,11 @@ int cmark_isdigit(char c);
 CMARK_GFM_EXPORT
 int cmark_isalpha(char c);
 
+/* Character classes for inline code info identifiers. */
+int cmark_is_inline_code_info_start_char(char c);
+
+int cmark_is_inline_code_info_char(char c);
+
 #ifdef __cplusplus
 }
 #endif

data/ext/markly/commonmark.c

@@ -271,7 +271,7 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node,
     if (!first_in_list_item) {
       BLANKLINE();
     }
-    info = cmark_node_get_fence_info(node);
+    info = cmark_node_get_code_info(node);
     info_len = strlen(info);
     fencechar[0] = strchr(info, '`') == NULL ? '`' : '~';
     code = cmark_node_get_literal(node);
@@ -363,6 +363,10 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node,
     extra_spaces = code_len == 0 ||
 	    code[0] == '`' || code[code_len - 1] == '`' ||
 	    code[0] == ' ' || code[code_len - 1] == ' ';
+    if (node->as.code.info.len > 0) {
+      OUT(cmark_node_get_code_info(node), false, LITERAL);
+      LIT(":");
+    }
     for (i = 0; i < numticks; i++) {
       LIT("`");
     }
@@ -492,6 +496,22 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node,
     }
     break;
 
+  case CMARK_NODE_FRONT_MATTER:
+    if (entering) {
+      const char *front_matter_info = cmark_node_get_fence_info(node);
+      BLANKLINE();
+      LIT("---");
+      if (front_matter_info && *front_matter_info) {
+        LIT(" ");
+        OUT(front_matter_info, false, LITERAL);
+      }
+      LIT("\n");
+      OUT(cmark_node_get_literal(node), false, LITERAL);
+      LIT("---\n");
+      BLANKLINE();
+    }
+    break;
+
   default:
     assert(false);
     break;

data/ext/markly/config.h

@@ -5,9 +5,7 @@
 extern "C" {
 #endif
 
-#ifndef HAVE_STDBOOL_H
 #define HAVE_STDBOOL_H
-#endif
 
 #ifdef HAVE_STDBOOL_H
   #include <stdbool.h>
@@ -71,8 +69,6 @@ CMARK_INLINE int c99_snprintf(char *outBuf, size_t size, const char *format, ...
 
 #endif
 
-#define CMARK_DEBUG_NODES 0
-
 #ifdef __cplusplus
 }
 #endif

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;