commonmarker 0.17.7.1 → 0.18.0

data/ext/commonmarker/cmark.c

@@ -4,15 +4,15 @@
 #include "registry.h"
 #include "node.h"
 #include "houdini.h"
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "buffer.h"
 
 cmark_node_type CMARK_NODE_LAST_BLOCK = CMARK_NODE_FOOTNOTE_DEFINITION;
 cmark_node_type CMARK_NODE_LAST_INLINE = CMARK_NODE_FOOTNOTE_REFERENCE;
 
-int cmark_version() { return CMARK_VERSION; }
+int cmark_version() { return CMARK_GFM_VERSION; }
 
-const char *cmark_version_string() { return CMARK_VERSION_STRING; }
+const char *cmark_version_string() { return CMARK_GFM_VERSION_STRING; }
 
 static void *xcalloc(size_t nmem, size_t size) {
   void *ptr = calloc(nmem, size);

data/ext/commonmarker/cmark_ctype.h

@@ -5,25 +5,25 @@
 extern "C" {
 #endif
 
-#include "cmark_export.h"
+#include "cmark-gfm_export.h"
 
 /** Locale-independent versions of functions from ctype.h.
  * We want cmark to behave the same no matter what the system locale.
  */
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_isspace(char c);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_ispunct(char c);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_isalnum(char c);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_isdigit(char c);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int cmark_isalpha(char c);
 
 #ifdef __cplusplus

data/ext/commonmarker/commonmark.c

@@ -5,7 +5,7 @@
 #include <assert.h>
 
 #include "config.h"
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "node.h"
 #include "buffer.h"
 #include "utf8.h"
@@ -35,7 +35,7 @@ static CMARK_INLINE void outc(cmark_renderer *renderer, cmark_node *node,
       c < 0x80 && escape != LITERAL &&
       ((escape == NORMAL &&
         (c == '*' || c == '_' || c == '[' || c == ']' || c == '#' || c == '<' ||
-         c == '>' || c == '\\' || c == '`' || c == '!' ||
+         c == '>' || c == '\\' || c == '`' || c == '~' || c == '!' ||
          (c == '&' && cmark_isalpha(nextc)) || (c == '!' && nextc == '[') ||
          (renderer->begin_content && (c == '-' || c == '+' || c == '=') &&
           // begin_content doesn't get set to false til we've passed digits
@@ -168,6 +168,7 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node,
   int list_number;
   cmark_delim_type list_delim;
   int numticks;
+  bool extra_spaces;
   int i;
   bool entering = (ev_type == CMARK_EVENT_ENTER);
   const char *info, *code, *title;
@@ -369,14 +370,17 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node,
     code = cmark_node_get_literal(node);
     code_len = strlen(code);
     numticks = shortest_unused_backtick_sequence(code);
+    extra_spaces = code_len == 0 ||
+	    code[0] == '`' || code[code_len - 1] == '`' ||
+	    code[0] == ' ' || code[code_len - 1] == ' ';
     for (i = 0; i < numticks; i++) {
       LIT("`");
     }
-    if (code_len == 0 || code[0] == '`') {
+    if (extra_spaces) {
       LIT(" ");
     }
     OUT(cmark_node_get_literal(node), allow_wrap, LITERAL);
-    if (code_len == 0 || code[code_len - 1] == '`') {
+    if (extra_spaces) {
       LIT(" ");
     }
     for (i = 0; i < numticks; i++) {

data/ext/commonmarker/commonmarker.c

@@ -1,11 +1,11 @@
 #include "commonmarker.h"
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "houdini.h"
 #include "node.h"
 #include "registry.h"
 #include "parser.h"
 #include "syntax_extension.h"
-#include "core-extensions.h"
+#include "cmark-gfm-core-extensions.h"
 
 static VALUE rb_mNodeError;
 static VALUE rb_mNode;
@@ -524,7 +524,7 @@ static VALUE rb_node_insert_before(VALUE self, VALUE sibling) {
  *
  * Returns a {String}.
  */
-static VALUE rb_render_html(VALUE n, VALUE rb_options, VALUE rb_extensions) {
+static VALUE rb_render_html(VALUE self, VALUE rb_options, VALUE rb_extensions) {
   int options, extensions_len;
   VALUE rb_ext_name;
   int i;
@@ -537,7 +537,7 @@ static VALUE rb_render_html(VALUE n, VALUE rb_options, VALUE rb_extensions) {
   options = FIX2INT(rb_options);
   extensions_len = RARRAY_LEN(rb_extensions);
 
-  Data_Get_Struct(n, cmark_node, node);
+  Data_Get_Struct(self, cmark_node, node);
 
   for (i = 0; i < extensions_len; ++i) {
     rb_ext_name = RARRAY_PTR(rb_extensions)[i];
@@ -571,15 +571,24 @@ static VALUE rb_render_html(VALUE n, VALUE rb_options, VALUE rb_extensions) {
  *
  * Returns a {String}.
  */
-static VALUE rb_render_commonmark(VALUE n, VALUE rb_options) {
+static VALUE rb_render_commonmark(int argc, VALUE *argv, VALUE self) {
+  VALUE rb_options, rb_width;
+  rb_scan_args(argc, argv, "11", &rb_options, &rb_width);
+
+  int width = 120;
+  if (!NIL_P(rb_width)) {
+    Check_Type(rb_width, T_FIXNUM);
+    width = FIX2INT(rb_width);
+  }
+
   int options;
   cmark_node *node;
   Check_Type(rb_options, T_FIXNUM);
 
   options = FIX2INT(rb_options);
-  Data_Get_Struct(n, cmark_node, node);
+  Data_Get_Struct(self, cmark_node, node);
 
-  char *cmark = cmark_render_commonmark(node, options, 120);
+  char *cmark = cmark_render_commonmark(node, options, width);
   VALUE ruby_cmark = rb_str_new2(cmark);
   free(cmark);
 
@@ -590,15 +599,24 @@ static VALUE rb_render_commonmark(VALUE n, VALUE rb_options) {
  *
  * Returns a {String}.
  */
-static VALUE rb_render_plaintext(VALUE n, VALUE rb_options) {
+static VALUE rb_render_plaintext(int argc, VALUE *argv, VALUE self) {
+  VALUE rb_options, rb_width;
+  rb_scan_args(argc, argv, "11", &rb_options, &rb_width);
+
+  int width = 120;
+  if (!NIL_P(rb_width)) {
+    Check_Type(rb_width, T_FIXNUM);
+    width = FIX2INT(rb_width);
+  }
+
   int options;
   cmark_node *node;
   Check_Type(rb_options, T_FIXNUM);
 
   options = FIX2INT(rb_options);
-  Data_Get_Struct(n, cmark_node, node);
+  Data_Get_Struct(self, cmark_node, node);
 
-  char *text = cmark_render_plaintext(node, options, 120);
+  char *text = cmark_render_plaintext(node, options, width);
   VALUE ruby_text = rb_str_new2(text);
   free(text);
 
@@ -1023,8 +1041,8 @@ static VALUE rb_node_get_table_alignments(VALUE self) {
   VALUE ary;
   Data_Get_Struct(self, cmark_node, node);
 
-  column_count = cmarkextensions_get_table_columns(node);
-  alignments = cmarkextensions_get_table_alignments(node);
+  column_count = cmark_gfm_extensions_get_table_columns(node);
+  alignments = cmark_gfm_extensions_get_table_alignments(node);
 
   if (!column_count || !alignments) {
     rb_raise(rb_mNodeError, "could not get column_count or alignments");
@@ -1148,8 +1166,8 @@ __attribute__((visibility("default"))) void Init_commonmarker() {
   rb_define_method(rb_mNode, "next", rb_node_next, 0);
   rb_define_method(rb_mNode, "insert_before", rb_node_insert_before, 1);
   rb_define_method(rb_mNode, "_render_html", rb_render_html, 2);
-  rb_define_method(rb_mNode, "_render_commonmark", rb_render_commonmark, 1);
-  rb_define_method(rb_mNode, "_render_plaintext", rb_render_plaintext, 1);
+  rb_define_method(rb_mNode, "_render_commonmark", rb_render_commonmark, -1);
+  rb_define_method(rb_mNode, "_render_plaintext", rb_render_plaintext, -1);
   rb_define_method(rb_mNode, "insert_after", rb_node_insert_after, 1);
   rb_define_method(rb_mNode, "prepend_child", rb_node_prepend_child, 1);
   rb_define_method(rb_mNode, "append_child", rb_node_append_child, 1);
@@ -1175,5 +1193,5 @@ __attribute__((visibility("default"))) void Init_commonmarker() {
   rb_define_method(rb_mNode, "html_escape_href", rb_html_escape_href, 1);
   rb_define_method(rb_mNode, "html_escape_html", rb_html_escape_html, 1);
 
-  core_extensions_ensure_registered();
+  cmark_gfm_core_extensions_ensure_registered();
 }

data/ext/commonmarker/commonmarker.h

@@ -5,7 +5,7 @@
 #define __MSXML_LIBRARY_DEFINED__
 #endif
 
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "ruby.h"
 #include "ruby/encoding.h"
 

data/ext/commonmarker/core-extensions.c

@@ -1,4 +1,4 @@
-#include "core-extensions.h"
+#include "cmark-gfm-core-extensions.h"
 #include "autolink.h"
 #include "strikethrough.h"
 #include "table.h"
@@ -15,7 +15,7 @@ static int core_extensions_registration(cmark_plugin *plugin) {
   return 1;
 }
 
-void core_extensions_ensure_registered(void) {
+void cmark_gfm_core_extensions_ensure_registered(void) {
   static int registered = 0;
 
   if (!registered) {

data/ext/commonmarker/ext_scanners.h

@@ -1,5 +1,5 @@
 #include "chunk.h"
-#include "cmark.h"
+#include "cmark-gfm.h"
 
 #ifdef __cplusplus
 extern "C" {

data/ext/commonmarker/footnotes.c

@@ -1,4 +1,4 @@
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "parser.h"
 #include "footnotes.h"
 #include "inlines.h"

data/ext/commonmarker/houdini.h

@@ -31,22 +31,22 @@ extern "C" {
 #define HOUDINI_ESCAPED_SIZE(x) (((x)*12) / 10)
 #define HOUDINI_UNESCAPED_SIZE(x) (x)
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 bufsize_t houdini_unescape_ent(cmark_strbuf *ob, const uint8_t *src,
                                       bufsize_t size);
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int houdini_escape_html(cmark_strbuf *ob, const uint8_t *src,
                                bufsize_t size);
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int houdini_escape_html0(cmark_strbuf *ob, const uint8_t *src,
                                 bufsize_t size, int secure);
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int houdini_unescape_html(cmark_strbuf *ob, const uint8_t *src,
                                  bufsize_t size);
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void houdini_unescape_html_f(cmark_strbuf *ob, const uint8_t *src,
                                     bufsize_t size);
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 int houdini_escape_href(cmark_strbuf *ob, const uint8_t *src,
                                bufsize_t size);
 

data/ext/commonmarker/houdini_href_e.c

@@ -7,7 +7,7 @@
 /*
  * The following characters will not be escaped:
  *
- *		-_.+!*'(),%#@?=;:/,+&$ alphanum
+ *		-_.+!*'(),%#@?=;:/,+&$~ alphanum
  *
  * Note that this character set is the addition of:
  *
@@ -35,7 +35,7 @@ static const char HREF_SAFE[] = {
     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1,
     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1,
     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

data/ext/commonmarker/html.c

@@ -4,7 +4,7 @@
 #include <assert.h>
 #include "cmark_ctype.h"
 #include "config.h"
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "houdini.h"
 #include "scanners.h"
 #include "syntax_extension.h"
@@ -203,12 +203,20 @@ static int S_render_node(cmark_html_renderer *renderer, cmark_node *node,
         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>");
       } 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, "\">");
       }
     }
@@ -219,7 +227,7 @@ static int S_render_node(cmark_html_renderer *renderer, cmark_node *node,
 
   case CMARK_NODE_HTML_BLOCK:
     cmark_html_render_cr(html);
-    if (options & CMARK_OPT_SAFE) {
+    if (!(options & CMARK_OPT_UNSAFE)) {
       cmark_strbuf_puts(html, "<!-- raw HTML omitted -->");
     } else if (renderer->filter_extensions) {
       filter_html_block(renderer, node->as.literal.data, node->as.literal.len);
@@ -297,7 +305,7 @@ static int S_render_node(cmark_html_renderer *renderer, cmark_node *node,
     break;
 
   case CMARK_NODE_HTML_INLINE:
-    if (options & CMARK_OPT_SAFE) {
+    if (!(options & CMARK_OPT_UNSAFE)) {
       cmark_strbuf_puts(html, "<!-- raw HTML omitted -->");
     } else {
       filtered = false;
@@ -346,7 +354,7 @@ static int S_render_node(cmark_html_renderer *renderer, cmark_node *node,
   case CMARK_NODE_LINK:
     if (entering) {
       cmark_strbuf_puts(html, "<a href=\"");
-      if (!((options & CMARK_OPT_SAFE) &&
+      if (!(!(options & CMARK_OPT_UNSAFE) &&
             scan_dangerous_url(&node->as.link.url, 0))) {
         houdini_escape_href(html, node->as.link.url.data,
                             node->as.link.url.len);
@@ -364,7 +372,7 @@ static int S_render_node(cmark_html_renderer *renderer, cmark_node *node,
   case CMARK_NODE_IMAGE:
     if (entering) {
       cmark_strbuf_puts(html, "<img src=\"");
-      if (!((options & CMARK_OPT_SAFE) &&
+      if (!(!(options & CMARK_OPT_UNSAFE) &&
             scan_dangerous_url(&node->as.link.url, 0))) {
         houdini_escape_href(html, node->as.link.url.data,
                             node->as.link.url.len);
@@ -406,9 +414,9 @@ static int S_render_node(cmark_html_renderer *renderer, cmark_node *node,
       cmark_strbuf_put(html, node->as.literal.data, node->as.literal.len);
       cmark_strbuf_puts(html, "\" id=\"fnref");
       cmark_strbuf_put(html, node->as.literal.data, node->as.literal.len);
-      cmark_strbuf_puts(html, "\">[");
+      cmark_strbuf_puts(html, "\">");
       cmark_strbuf_put(html, node->as.literal.data, node->as.literal.len);
-      cmark_strbuf_puts(html, "]</a></sup>");
+      cmark_strbuf_puts(html, "</a></sup>");
     }
     break;
 

data/ext/commonmarker/inlines.c

@@ -7,7 +7,7 @@
 #include "node.h"
 #include "parser.h"
 #include "references.h"
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "houdini.h"
 #include "utf8.h"
 #include "scanners.h"
@@ -321,6 +321,37 @@ static bufsize_t scan_to_closing_backticks(subject *subj,
   return 0;
 }
 
+// Destructively modify string, converting newlines to
+// spaces, then removing a single leading + trailing space.
+static void S_normalize_code(cmark_strbuf *s) {
+  bufsize_t r, w;
+
+  for (r = 0, w = 0; r < s->size; ++r) {
+    switch (s->ptr[r]) {
+    case '\r':
+      if (s->ptr[r + 1] != '\n') {
+	s->ptr[w++] = ' ';
+      }
+      break;
+    case '\n':
+      s->ptr[w++] = ' ';
+      break;
+    default:
+      s->ptr[w++] = s->ptr[r];
+    }
+  }
+
+  // begins and ends with space?
+  if (s->ptr[0] == ' ' && s->ptr[w - 1] == ' ') {
+    cmark_strbuf_drop(s, 1);
+    cmark_strbuf_truncate(s, w - 2);
+  } else {
+    cmark_strbuf_truncate(s, w);
+  }
+
+}
+
+
 // Parse backtick code section or raw backticks, return an inline.
 // Assumes that the subject has a backtick at the current position.
 static cmark_node *handle_backticks(subject *subj, int options) {
@@ -336,8 +367,7 @@ static cmark_node *handle_backticks(subject *subj, int options) {
 
     cmark_strbuf_set(&buf, subj->input.data + startpos,
                      endpos - startpos - openticks.len);
-    cmark_strbuf_trim(&buf);
-    cmark_strbuf_normalize_whitespace(&buf);
+    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);
@@ -345,6 +375,7 @@ static cmark_node *handle_backticks(subject *subj, int options) {
   }
 }
 
+
 // Scan ***, **, or * and return number scanned, or 0.
 // Advances position.
 static int scan_delims(subject *subj, unsigned char c, bool *can_open,
@@ -972,7 +1003,7 @@ static bufsize_t manual_scan_link_url(cmark_chunk *input, bufsize_t offset,
         break;
       } else if (input->data[i] == '\\')
         i += 2;
-      else if (cmark_isspace(input->data[i]) || input->data[i] == '<')
+      else if (input->data[i] == '\n' || input->data[i] == '<')
         return manual_scan_link_url_2(input, offset, output);
       else
         ++i;
@@ -1410,7 +1441,7 @@ bufsize_t cmark_parse_reference_inline(cmark_mem *mem, cmark_chunk *input,
   // parse optional link_title
   beforetitle = subj.pos;
   spnl(&subj);
-  matchlen = scan_link_title(&subj.input, subj.pos);
+  matchlen = subj.pos == beforetitle ? 0 : scan_link_title(&subj.input, subj.pos);
   if (matchlen) {
     title = cmark_chunk_dup(&subj.input, subj.pos, matchlen);
     subj.pos += matchlen;

data/ext/commonmarker/inlines.h

@@ -10,7 +10,7 @@ extern "C" {
 cmark_chunk cmark_clean_url(cmark_mem *mem, cmark_chunk *url);
 cmark_chunk cmark_clean_title(cmark_mem *mem, cmark_chunk *title);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_parse_inlines(cmark_parser *parser,
                          cmark_node *parent,
                          cmark_map *refmap,

data/ext/commonmarker/iterator.c

@@ -3,7 +3,7 @@
 
 #include "config.h"
 #include "node.h"
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "iterator.h"
 
 cmark_iter *cmark_iter_new(cmark_node *root) {

data/ext/commonmarker/iterator.h

@@ -5,7 +5,7 @@
 extern "C" {
 #endif
 
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "memory.h"
 
 typedef struct {

data/ext/commonmarker/latex.c

@@ -4,7 +4,7 @@
 #include <assert.h>
 
 #include "config.h"
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "node.h"
 #include "buffer.h"
 #include "utf8.h"

data/ext/commonmarker/linked_list.c

@@ -1,6 +1,6 @@
 #include <stdlib.h>
 
-#include "cmark.h"
+#include "cmark-gfm.h"
 
 cmark_llist *cmark_llist_append(cmark_mem *mem, cmark_llist *head, void *data) {
   cmark_llist *tmp;

data/ext/commonmarker/man.c

@@ -4,7 +4,7 @@
 #include <assert.h>
 
 #include "config.h"
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "node.h"
 #include "buffer.h"
 #include "utf8.h"

data/ext/commonmarker/node.c

@@ -69,10 +69,11 @@ static bool S_can_contain(cmark_node *node, cmark_node *child) {
   return cmark_node_can_contain_type(node, (cmark_node_type) child->type);
 }
 
-cmark_node *cmark_node_new_with_mem(cmark_node_type type, cmark_mem *mem) {
+cmark_node *cmark_node_new_with_mem_and_ext(cmark_node_type type, cmark_mem *mem, cmark_syntax_extension *extension) {
   cmark_node *node = (cmark_node *)mem->calloc(1, sizeof(*node));
   cmark_strbuf_init(mem, &node->content, 0);
   node->type = (uint16_t)type;
+  node->extension = extension;
 
   switch (node->type) {
   case CMARK_NODE_HEADING:
@@ -91,12 +92,25 @@ cmark_node *cmark_node_new_with_mem(cmark_node_type type, cmark_mem *mem) {
     break;
   }
 
+  if (node->extension && node->extension->opaque_alloc_func) {
+    node->extension->opaque_alloc_func(node->extension, mem, node);
+  }
+
   return node;
 }
 
-cmark_node *cmark_node_new(cmark_node_type type) {
+cmark_node *cmark_node_new_with_ext(cmark_node_type type, cmark_syntax_extension *extension) {
   extern cmark_mem CMARK_DEFAULT_MEM_ALLOCATOR;
-  return cmark_node_new_with_mem(type, &CMARK_DEFAULT_MEM_ALLOCATOR);
+  return cmark_node_new_with_mem_and_ext(type, &CMARK_DEFAULT_MEM_ALLOCATOR, extension);
+}
+
+cmark_node *cmark_node_new_with_mem(cmark_node_type type, cmark_mem *mem)
+{
+  return cmark_node_new_with_mem_and_ext(type, mem, NULL);
+}
+
+cmark_node *cmark_node_new(cmark_node_type type) {
+  return cmark_node_new_with_ext(type, NULL);
 }
 
 static void free_node_as(cmark_node *node) {

data/ext/commonmarker/node.h

@@ -8,8 +8,8 @@ extern "C" {
 #include <stdio.h>
 #include <stdint.h>
 
-#include "cmark.h"
-#include "cmark_extension_api.h"
+#include "cmark-gfm.h"
+#include "cmark-gfm-extension_api.h"
 #include "buffer.h"
 #include "chunk.h"
 
@@ -89,7 +89,7 @@ struct cmark_node {
 static CMARK_INLINE cmark_mem *cmark_node_mem(cmark_node *node) {
   return node->content.mem;
 }
-CMARK_EXPORT int cmark_node_check(cmark_node *node, FILE *out);
+CMARK_GFM_EXPORT int cmark_node_check(cmark_node *node, FILE *out);
 
 static CMARK_INLINE bool CMARK_NODE_TYPE_BLOCK_P(cmark_node_type node_type) {
 	return (node_type & CMARK_NODE_TYPE_MASK) == CMARK_NODE_TYPE_BLOCK;
@@ -107,7 +107,7 @@ static CMARK_INLINE bool CMARK_NODE_INLINE_P(cmark_node *node) {
 	return node != NULL && CMARK_NODE_TYPE_INLINE_P((cmark_node_type) node->type);
 }
 
-CMARK_EXPORT bool cmark_node_can_contain_type(cmark_node *node, cmark_node_type child_type);
+CMARK_GFM_EXPORT bool cmark_node_can_contain_type(cmark_node *node, cmark_node_type child_type);
 
 #ifdef __cplusplus
 }

data/ext/commonmarker/plugin.h

@@ -5,8 +5,8 @@
 extern "C" {
 #endif
 
-#include "cmark.h"
-#include "cmark_extension_api.h"
+#include "cmark-gfm.h"
+#include "cmark-gfm-extension_api.h"
 
 /**
  * cmark_plugin:

data/ext/commonmarker/references.c

@@ -1,4 +1,4 @@
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "parser.h"
 #include "references.h"
 #include "inlines.h"

data/ext/commonmarker/registry.c

@@ -3,7 +3,7 @@
 #include <string.h>
 
 #include "config.h"
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "syntax_extension.h"
 #include "registry.h"
 #include "plugin.h"

data/ext/commonmarker/registry.h

@@ -5,16 +5,16 @@
 extern "C" {
 #endif
 
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "plugin.h"
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_register_plugin(cmark_plugin_init_func reg_fn);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 void cmark_release_plugins(void);
 
-CMARK_EXPORT
+CMARK_GFM_EXPORT
 cmark_llist *cmark_list_syntax_extensions(cmark_mem *mem);
 
 #ifdef __cplusplus

data/ext/commonmarker/render.c

@@ -1,7 +1,7 @@
 #include <stdlib.h>
 #include "buffer.h"
 #include "chunk.h"
-#include "cmark.h"
+#include "cmark-gfm.h"
 #include "utf8.h"
 #include "render.h"
 #include "node.h"