markly 0.16.0 → 0.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fda5c52f4ac015dde2e9f22e2a76467ddcb655d197897f7bbd76c7da235f2991
-  data.tar.gz: 936fdce7bd2fde2339e48bf43a9b4f9ae8c4b552844de6cf69bd445965477a3f
+  metadata.gz: a6df3d157ca441e13f840de336bf04408669aae72ff791d35be091ee008da87c
+  data.tar.gz: 682356cc37b69d2a486624ffd0e0c02f75a717b07f32c0a41d838e2032730223
 SHA512:
-  metadata.gz: 74eae720741b8b4aee9e4d01d92d25d53cbd92f46066a4eb341881907a9c5291102b1cb10c4c59c81b2192adc4156bd6eaf619e51836ef661be03dde450f4415
-  data.tar.gz: 1080d1c3a72e238325e017974e34c1ad7ed56174811adcbf1c97d6b860566dd4886ebb71a9a634e8bc05826afd71045b4ef72edb622740ff72af8d6b887534ae
+  metadata.gz: 70315346cac721d22cbc67c0efaee8bd6a035198fec894388a827136c3710d60844c24e29a26a4374a899af01212618412d929acfd840db03ce887f79e2b80ef
+  data.tar.gz: 895682bb5cd75d95306c2e60b9bb446b4459ade9800d8a29e5ecd13b4fb9f8e1caa33518ac1d3f6779143af9f213d50a0c17460ded2fc94eea57872e7aba9c26

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/ext/markly/cmark-gfm-extension_api.h

@@ -264,6 +264,10 @@ typedef void (*cmark_opaque_free_func) (cmark_syntax_extension *extension,
                                         cmark_mem *mem,
                                         cmark_node *node);
 
+typedef void (*cmark_opaque_copy_func)(cmark_syntax_extension *extension,
+                                       cmark_mem *mem, cmark_node *node,
+                                       cmark_node *source);
+
 /** Free a cmark_syntax_extension.
  */
 CMARK_GFM_EXPORT
@@ -406,6 +410,12 @@ CMARK_GFM_EXPORT
 void cmark_syntax_extension_set_opaque_free_func(cmark_syntax_extension *extension,
                                                  cmark_opaque_free_func func);
 
+/** See the documentation for 'cmark_syntax_extension'
+ */
+CMARK_GFM_EXPORT
+void cmark_syntax_extension_set_opaque_copy_func(
+    cmark_syntax_extension *extension, cmark_opaque_copy_func func);
+
 /** See the documentation for 'cmark_syntax_extension'
  */
 CMARK_GFM_EXPORT

data/ext/markly/cmark-gfm.h

@@ -196,6 +196,12 @@ CMARK_GFM_EXPORT cmark_node *cmark_node_new_with_mem_and_ext(cmark_node_type typ
                                                 cmark_mem *mem,
                                                 cmark_syntax_extension *extension);
 
+/** Creates an independent deep copy of 'node' and all its children.
+ * User data is not copied. Returns NULL when extension-specific node data
+ * cannot be copied.
+ */
+CMARK_GFM_EXPORT cmark_node *cmark_node_clone(cmark_node *node);
+
 /** Frees the memory allocated for a node and any children.
  */
 CMARK_GFM_EXPORT void cmark_node_free(cmark_node *node);
@@ -425,6 +431,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);
@@ -776,6 +794,10 @@ char *cmark_render_latex_with_mem(cmark_node *root, int options, int width, cmar
  */
 #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_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("`");
     }
@@ -494,10 +498,13 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node,
 
   case CMARK_NODE_FRONT_MATTER:
     if (entering) {
-      const char *info = cmark_node_get_fence_info(node);
+      const char *front_matter_info = cmark_node_get_fence_info(node);
       BLANKLINE();
       LIT("---");
-      if (info && *info) { LIT(" "); OUT(info, false, LITERAL); }
+      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");

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/extensions/table.c

@@ -842,6 +842,29 @@ static void opaque_free(cmark_syntax_extension *self, cmark_mem *mem, cmark_node
   }
 }
 
+static void opaque_copy(cmark_syntax_extension *self, cmark_mem *mem,
+                        cmark_node *node, cmark_node *source) {
+  if (node->type == CMARK_NODE_TABLE) {
+    node_table *table = (node_table *)node->as.opaque;
+    node_table *source_table = (node_table *)source->as.opaque;
+
+    table->n_columns = source_table->n_columns;
+    table->n_rows = source_table->n_rows;
+    table->n_nonempty_cells = source_table->n_nonempty_cells;
+
+    if (source_table->alignments) {
+      table->alignments = mem->calloc(source_table->n_columns, sizeof(uint8_t));
+      memcpy(table->alignments, source_table->alignments,
+             source_table->n_columns * sizeof(uint8_t));
+    }
+  } else if (node->type == CMARK_NODE_TABLE_ROW) {
+    *(node_table_row *)node->as.opaque = *(node_table_row *)source->as.opaque;
+  } else if (node->type == CMARK_NODE_TABLE_CELL) {
+    mem->free(node->as.opaque);
+    node->as.cell_index = source->as.cell_index;
+  }
+}
+
 static int escape(cmark_syntax_extension *self, cmark_node *node, int c) {
   return
     node->type != CMARK_NODE_TABLE &&
@@ -867,6 +890,7 @@ cmark_syntax_extension *create_table_extension(void) {
   cmark_syntax_extension_set_html_render_func(self, html_render);
   cmark_syntax_extension_set_opaque_alloc_func(self, opaque_alloc);
   cmark_syntax_extension_set_opaque_free_func(self, opaque_free);
+  cmark_syntax_extension_set_opaque_copy_func(self, opaque_copy);
   cmark_syntax_extension_set_commonmark_escape_func(self, escape);
   CMARK_NODE_TABLE = cmark_syntax_extension_add_node(0);
   CMARK_NODE_TABLE_ROW = cmark_syntax_extension_add_node(0);

data/ext/markly/html.c

@@ -18,6 +18,34 @@ static void escape_html(cmark_strbuf *dest, const unsigned char *source,
   houdini_escape_html0(dest, source, length, 0);
 }
 
+static bufsize_t first_code_info_tag(cmark_chunk *info) {
+  bufsize_t first_tag = 0;
+  while (first_tag < info->len && !cmark_isspace(info->data[first_tag])) {
+    first_tag += 1;
+  }
+  return first_tag;
+}
+
+static void render_code_info_attrs(cmark_strbuf *html, cmark_chunk *info,
+                                   int options, bool pre_lang) {
+  bufsize_t first_tag = first_code_info_tag(info);
+
+  if (pre_lang) {
+    cmark_strbuf_puts(html, " lang=\"");
+  } else {
+    cmark_strbuf_puts(html, " class=\"language-");
+  }
+
+  escape_html(html, info->data, first_tag);
+
+  if (first_tag < info->len && (options & CMARK_OPT_FULL_INFO_STRING)) {
+    cmark_strbuf_puts(html, "\" data-meta=\"");
+    escape_html(html, info->data + first_tag + 1, info->len - first_tag - 1);
+  }
+
+  cmark_strbuf_putc(html, '"');
+}
+
 static void filter_html_block(cmark_html_renderer *renderer, uint8_t *data, size_t len) {
   cmark_strbuf *html = renderer->html;
   cmark_llist *it;
@@ -125,7 +153,11 @@ static int S_render_node(cmark_html_renderer *renderer, cmark_node *node,
     case CMARK_NODE_TEXT:
     case CMARK_NODE_CODE:
     case CMARK_NODE_HTML_INLINE:
-      escape_html(html, node->as.literal.data, node->as.literal.len);
+      if (node->type == CMARK_NODE_CODE) {
+        escape_html(html, node->as.code.literal.data, node->as.code.literal.len);
+      } else {
+        escape_html(html, node->as.literal.data, node->as.literal.len);
+      }
       break;
 
     case CMARK_NODE_LINEBREAK:
@@ -220,32 +252,17 @@ static int S_render_node(cmark_html_renderer *renderer, cmark_node *node,
       cmark_html_render_sourcepos(node, html, options);
       cmark_strbuf_puts(html, "><code>");
     } else {
-      bufsize_t first_tag = 0;
-      while (first_tag < node->as.code.info.len &&
-             !cmark_isspace(node->as.code.info.data[first_tag])) {
-        first_tag += 1;
-      }
-
       if (options & CMARK_OPT_GITHUB_PRE_LANG) {
         cmark_strbuf_puts(html, "<pre");
         cmark_html_render_sourcepos(node, html, options);
-        cmark_strbuf_puts(html, " lang=\"");
-        escape_html(html, node->as.code.info.data, first_tag);
-        if (first_tag < node->as.code.info.len && (options & CMARK_OPT_FULL_INFO_STRING)) {
-          cmark_strbuf_puts(html, "\" data-meta=\"");
-          escape_html(html, node->as.code.info.data + first_tag + 1, node->as.code.info.len - first_tag - 1);
-        }
-        cmark_strbuf_puts(html, "\"><code>");
+        render_code_info_attrs(html, &node->as.code.info, options, true);
+        cmark_strbuf_puts(html, "><code>");
       } else {
         cmark_strbuf_puts(html, "<pre");
         cmark_html_render_sourcepos(node, html, options);
-        cmark_strbuf_puts(html, "><code class=\"language-");
-        escape_html(html, node->as.code.info.data, first_tag);
-        if (first_tag < node->as.code.info.len && (options & CMARK_OPT_FULL_INFO_STRING)) {
-          cmark_strbuf_puts(html, "\" data-meta=\"");
-          escape_html(html, node->as.code.info.data + first_tag + 1, node->as.code.info.len - first_tag - 1);
-        }
-        cmark_strbuf_puts(html, "\">");
+        cmark_strbuf_puts(html, "><code");
+        render_code_info_attrs(html, &node->as.code.info, options, false);
+        cmark_strbuf_putc(html, '>');
       }
     }
 
@@ -286,7 +303,7 @@ static int S_render_node(cmark_html_renderer *renderer, cmark_node *node,
 
   case CMARK_NODE_PARAGRAPH:
     parent = cmark_node_parent(node);
-    grandparent = cmark_node_parent(parent);
+    grandparent = parent ? cmark_node_parent(parent) : NULL;
     if (grandparent != NULL && grandparent->type == CMARK_NODE_LIST) {
       tight = grandparent->as.list.tight;
     } else {
@@ -299,7 +316,8 @@ static int S_render_node(cmark_html_renderer *renderer, cmark_node *node,
         cmark_html_render_sourcepos(node, html, options);
         cmark_strbuf_putc(html, '>');
       } else {
-        if (parent->type == CMARK_NODE_FOOTNOTE_DEFINITION && node->next == NULL) {
+        if (parent && parent->type == CMARK_NODE_FOOTNOTE_DEFINITION &&
+            node->next == NULL) {
           cmark_strbuf_putc(html, ' ');
           S_put_footnote_backref(renderer, html, parent);
         }
@@ -327,8 +345,12 @@ static int S_render_node(cmark_html_renderer *renderer, cmark_node *node,
     break;
 
   case CMARK_NODE_CODE:
-    cmark_strbuf_puts(html, "<code>");
-    escape_html(html, node->as.literal.data, node->as.literal.len);
+    cmark_strbuf_puts(html, "<code");
+    if (node->as.code.info.len > 0) {
+      render_code_info_attrs(html, &node->as.code.info, options, false);
+    }
+    cmark_strbuf_putc(html, '>');
+    escape_html(html, node->as.code.literal.data, node->as.code.literal.len);
     cmark_strbuf_puts(html, "</code>");
     break;
 

data/ext/markly/inlines.c

@@ -24,7 +24,6 @@ static const char *RIGHTSINGLEQUOTE = "\xE2\x80\x99";
 
 // Macros for creating various kinds of simple.
 #define make_str(subj, sc, ec, s) make_literal(subj, CMARK_NODE_TEXT, sc, ec, s)
-#define make_code(subj, sc, ec, s) make_literal(subj, CMARK_NODE_CODE, sc, ec, s)
 #define make_raw_html(subj, sc, ec, s) make_literal(subj, CMARK_NODE_HTML_INLINE, sc, ec, s)
 #define make_linebreak(mem) make_simple(mem, CMARK_NODE_LINEBREAK)
 #define make_softbreak(mem) make_simple(mem, CMARK_NODE_SOFTBREAK)
@@ -104,6 +103,18 @@ static CMARK_INLINE cmark_node *make_simple(cmark_mem *mem, cmark_node_type t) {
   return e;
 }
 
+static CMARK_INLINE cmark_node *make_code(subject *subj, int start_column,
+                                          int end_column, cmark_chunk literal) {
+  cmark_node *e = (cmark_node *)subj->mem->calloc(1, sizeof(*e));
+  cmark_strbuf_init(subj->mem, &e->content, 0);
+  e->type = CMARK_NODE_CODE;
+  e->as.code.literal = literal;
+  e->start_line = e->end_line = subj->line;
+  e->start_column = start_column + 1 + subj->column_offset + subj->block_offset;
+  e->end_column = end_column + 1 + subj->column_offset + subj->block_offset;
+  return e;
+}
+
 // Like make_str, but parses entities.
 static cmark_node *make_str_with_entities(subject *subj,
                                           int start_column, int end_column,
@@ -385,6 +396,39 @@ static void S_normalize_code(cmark_strbuf *s) {
 
 }
 
+static bufsize_t scan_inline_code_info_prefix(subject *subj, bufsize_t start) {
+  if (start >= subj->input.len ||
+      !cmark_is_inline_code_info_start_char((char)subj->input.data[start]) ||
+      (start > 0 && cmark_is_inline_code_info_char(
+                        (char)subj->input.data[start - 1]))) {
+    return 0;
+  }
+
+  bufsize_t pos = start + 1;
+  while (pos < subj->input.len && cmark_is_inline_code_info_char(
+                                      (char)subj->input.data[pos])) {
+    pos++;
+  }
+
+  if (pos + 1 < subj->input.len && subj->input.data[pos] == ':' &&
+      subj->input.data[pos + 1] == '`') {
+    return pos;
+  }
+
+  return 0;
+}
+
+static bufsize_t find_inline_code_info_prefix(subject *subj, bufsize_t start,
+                                              bufsize_t limit) {
+  while (start < limit) {
+    if (scan_inline_code_info_prefix(subj, start)) {
+      return start;
+    }
+    start++;
+  }
+
+  return 0;
+}
 
 // Parse backtick code section or raw backticks, return an inline.
 // Assumes that the subject has a backtick at the current position.
@@ -403,12 +447,35 @@ static cmark_node *handle_backticks(subject *subj, int options) {
                      endpos - startpos - openticks.len);
     S_normalize_code(&buf);
 
-    cmark_node *node = make_code(subj, startpos, endpos - openticks.len - 1, cmark_chunk_buf_detach(&buf));
-    adjust_subj_node_newlines(subj, node, endpos - startpos, openticks.len, options);
+    cmark_node *node = make_code(subj, startpos, endpos - openticks.len - 1,
+                                 cmark_chunk_buf_detach(&buf));
+    adjust_subj_node_newlines(subj, node, endpos - startpos, openticks.len,
+                              options);
     return node;
   }
 }
 
+static cmark_node *handle_inline_code_info(subject *subj, int options) {
+  bufsize_t startpos = subj->pos;
+  bufsize_t colonpos = scan_inline_code_info_prefix(subj, startpos);
+  if (colonpos == 0) {
+    return NULL;
+  }
+
+  cmark_chunk info =
+      cmark_chunk_dup(&subj->input, startpos, colonpos - startpos);
+  subj->pos = colonpos + 1;
+
+  cmark_node *node = handle_backticks(subj, options);
+  if (node->type != CMARK_NODE_CODE) {
+    cmark_node_free(node);
+    subj->pos = startpos;
+    return NULL;
+  }
+
+  node->as.code.info = chunk_clone(subj->mem, &info);
+  return node;
+}
 
 // Scan ***, **, or * and return number scanned, or 0.
 // Advances position.
@@ -1458,6 +1525,14 @@ static int parse_inline(cmark_parser *parser, subject *subj, cmark_node *parent,
   if (c == 0) {
     return 0;
   }
+  if (options & CMARK_OPT_INLINE_CODE_INFO) {
+    new_inl = handle_inline_code_info(subj, options);
+  }
+  if (new_inl != NULL) {
+    append_child(parent, new_inl);
+    return 1;
+  }
+
   switch (c) {
   case '\r':
   case '\n':
@@ -1511,6 +1586,13 @@ static int parse_inline(cmark_parser *parser, subject *subj, cmark_node *parent,
       break;
 
     endpos = subject_find_special_char(subj, options);
+    if (options & CMARK_OPT_INLINE_CODE_INFO) {
+      bufsize_t info_start =
+          find_inline_code_info_prefix(subj, subj->pos + 1, endpos);
+      if (info_start > 0 && info_start < endpos) {
+        endpos = info_start;
+      }
+    }
     contents = cmark_chunk_dup(&subj->input, subj->pos, endpos - subj->pos);
     startpos = subj->pos;
     subj->pos = endpos;

data/ext/markly/iterator.c

@@ -139,10 +139,15 @@ void cmark_node_own(cmark_node *root) {
       switch (cur->type) {
       case CMARK_NODE_TEXT:
       case CMARK_NODE_HTML_INLINE:
-      case CMARK_NODE_CODE:
       case CMARK_NODE_HTML_BLOCK:
         cmark_chunk_to_cstr(iter->mem, &cur->as.literal);
         break;
+      case CMARK_NODE_CODE:
+        cmark_chunk_to_cstr(iter->mem, &cur->as.code.literal);
+        if (cur->as.code.info.len > 0) {
+          cmark_chunk_to_cstr(iter->mem, &cur->as.code.info);
+        }
+        break;
       case CMARK_NODE_LINK:
         cmark_chunk_to_cstr(iter->mem, &cur->as.link.url);
         cmark_chunk_to_cstr(iter->mem, &cur->as.link.title);