commonmarker 0.14.3 → 0.14.4

data/ext/commonmarker/cmark/extensions/table.c

@@ -482,13 +482,13 @@ static void commonmark_render(cmark_syntax_extension *extension,
   } else if (node->type == CMARK_NODE_TABLE_ROW) {
     if (entering) {
       renderer->cr(renderer);
-      renderer->out(renderer, "|", false, LITERAL);
+      renderer->out(renderer, node, "|", false, LITERAL);
     }
   } else if (node->type == CMARK_NODE_TABLE_CELL) {
     if (entering) {
-      renderer->out(renderer, " ", false, LITERAL);
+      renderer->out(renderer, node, " ", false, LITERAL);
     } else {
-      renderer->out(renderer, " |", false, LITERAL);
+      renderer->out(renderer, node, " |", false, LITERAL);
       if (((node_table_row *)node->parent->as.opaque)->is_header &&
           !node->next) {
         int i;
@@ -496,13 +496,13 @@ static void commonmark_render(cmark_syntax_extension *extension,
         uint16_t n_cols =
             ((node_table *)node->parent->parent->as.opaque)->n_columns;
         renderer->cr(renderer);
-        renderer->out(renderer, "|", false, LITERAL);
+        renderer->out(renderer, node, "|", false, LITERAL);
         for (i = 0; i < n_cols; i++) {
           switch (alignments[i]) {
-          case 0:   renderer->out(renderer, " --- |", false, LITERAL); break;
-          case 'l': renderer->out(renderer, " :-- |", false, LITERAL); break;
-          case 'c': renderer->out(renderer, " :-: |", false, LITERAL); break;
-          case 'r': renderer->out(renderer, " --: |", false, LITERAL); break;
+          case 0:   renderer->out(renderer, node, " --- |", false, LITERAL); break;
+          case 'l': renderer->out(renderer, node, " :-- |", false, LITERAL); break;
+          case 'c': renderer->out(renderer, node, " :-: |", false, LITERAL); break;
+          case 'r': renderer->out(renderer, node, " --: |", false, LITERAL); break;
           }
         }
         renderer->cr(renderer);
@@ -525,31 +525,31 @@ static void latex_render(cmark_syntax_extension *extension,
       uint8_t *alignments = get_table_alignments(node);
 
       renderer->cr(renderer);
-      renderer->out(renderer, "\\begin{table}", false, LITERAL);
+      renderer->out(renderer, node, "\\begin{table}", false, LITERAL);
       renderer->cr(renderer);
-      renderer->out(renderer, "\\begin{tabular}{", false, LITERAL);
+      renderer->out(renderer, node, "\\begin{tabular}{", false, LITERAL);
 
       n_cols = ((node_table *)node->as.opaque)->n_columns;
       for (i = 0; i < n_cols; i++) {
         switch(alignments[i]) {
         case 0:
         case 'l':
-          renderer->out(renderer, "l", false, LITERAL);
+          renderer->out(renderer, node, "l", false, LITERAL);
           break;
         case 'c':
-          renderer->out(renderer, "c", false, LITERAL);
+          renderer->out(renderer, node, "c", false, LITERAL);
           break;
         case 'r':
-          renderer->out(renderer, "r", false, LITERAL);
+          renderer->out(renderer, node, "r", false, LITERAL);
           break;
         }
       }
-      renderer->out(renderer, "}", false, LITERAL);
+      renderer->out(renderer, node, "}", false, LITERAL);
       renderer->cr(renderer);
     } else {
-      renderer->out(renderer, "\\end{tabular}", false, LITERAL);
+      renderer->out(renderer, node, "\\end{tabular}", false, LITERAL);
       renderer->cr(renderer);
-      renderer->out(renderer, "\\end{table}", false, LITERAL);
+      renderer->out(renderer, node, "\\end{table}", false, LITERAL);
       renderer->cr(renderer);
     }
   } else if (node->type == CMARK_NODE_TABLE_ROW) {
@@ -559,9 +559,9 @@ static void latex_render(cmark_syntax_extension *extension,
   } else if (node->type == CMARK_NODE_TABLE_CELL) {
     if (!entering) {
       if (node->next) {
-        renderer->out(renderer, " & ", false, LITERAL);
+        renderer->out(renderer, node, " & ", false, LITERAL);
       } else {
-        renderer->out(renderer, " \\\\", false, LITERAL);
+        renderer->out(renderer, node, " \\\\", false, LITERAL);
       }
     }
   } else {
@@ -581,9 +581,9 @@ static void man_render(cmark_syntax_extension *extension,
       uint8_t *alignments = get_table_alignments(node);
 
       renderer->cr(renderer);
-      renderer->out(renderer, ".TS", false, LITERAL);
+      renderer->out(renderer, node, ".TS", false, LITERAL);
       renderer->cr(renderer);
-      renderer->out(renderer, "tab(@);", false, LITERAL);
+      renderer->out(renderer, node, "tab(@);", false, LITERAL);
       renderer->cr(renderer);
 
       n_cols = ((node_table *)node->as.opaque)->n_columns;
@@ -591,24 +591,24 @@ static void man_render(cmark_syntax_extension *extension,
       for (i = 0; i < n_cols; i++) {
         switch (alignments[i]) {
         case 'l':
-          renderer->out(renderer, "l", false, LITERAL);
+          renderer->out(renderer, node, "l", false, LITERAL);
           break;
         case 0:
         case 'c':
-          renderer->out(renderer, "c", false, LITERAL);
+          renderer->out(renderer, node, "c", false, LITERAL);
           break;
         case 'r':
-          renderer->out(renderer, "r", false, LITERAL);
+          renderer->out(renderer, node, "r", false, LITERAL);
           break;
         }
       }
 
       if (n_cols) {
-        renderer->out(renderer, ".", false, LITERAL);
+        renderer->out(renderer, node, ".", false, LITERAL);
         renderer->cr(renderer);
       }
     } else {
-      renderer->out(renderer, ".TE", false, LITERAL);
+      renderer->out(renderer, node, ".TE", false, LITERAL);
       renderer->cr(renderer);
     }
   } else if (node->type == CMARK_NODE_TABLE_ROW) {
@@ -617,7 +617,7 @@ static void man_render(cmark_syntax_extension *extension,
     }
   } else if (node->type == CMARK_NODE_TABLE_CELL) {
     if (!entering && node->next) {
-      renderer->out(renderer, "@", false, LITERAL);
+      renderer->out(renderer, node, "@", false, LITERAL);
     }
   } else {
     assert(false);
@@ -719,6 +719,10 @@ static void opaque_free(cmark_syntax_extension *ext, cmark_mem *mem, cmark_node
   }
 }
 
+static int escape(cmark_syntax_extension *ext, cmark_node *node, int c) {
+  return c == '|';
+}
+
 cmark_syntax_extension *create_table_extension(void) {
   cmark_syntax_extension *ext = cmark_syntax_extension_new("table");
 
@@ -732,6 +736,7 @@ cmark_syntax_extension *create_table_extension(void) {
   cmark_syntax_extension_set_man_render_func(ext, man_render);
   cmark_syntax_extension_set_html_render_func(ext, html_render);
   cmark_syntax_extension_set_opaque_free_func(ext, opaque_free);
+  cmark_syntax_extension_set_commonmark_escape_func(ext, escape);
   CMARK_NODE_TABLE = cmark_syntax_extension_add_node(0);
   CMARK_NODE_TABLE_ROW = cmark_syntax_extension_add_node(0);
   CMARK_NODE_TABLE_CELL = cmark_syntax_extension_add_node(0);

data/ext/commonmarker/cmark/src/CMakeLists.txt

@@ -58,6 +58,9 @@ set(PROGRAM_SOURCES
   )
 
 include_directories(. ${CMAKE_CURRENT_BINARY_DIR})
+include_directories(
+  ${PROJECT_BINARY_DIR}/extensions
+)
 
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmark_version.h.in
   ${CMAKE_CURRENT_BINARY_DIR}/cmark_version.h)
@@ -74,7 +77,7 @@ target_link_libraries(${PROGRAM} libcmarkextensions_static)
 
 # Disable the PUBLIC declarations when compiling the executable:
 set_target_properties(${PROGRAM} PROPERTIES
-  COMPILE_FLAGS -DCMARK_STATIC_DEFINE)
+  COMPILE_FLAGS "-DCMARK_STATIC_DEFINE -DCMARKEXTENSIONS_STATIC_DEFINE")
 
 # Check integrity of node structure when compiled as debug:
 set(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -DCMARK_DEBUG_NODES -DDEBUG")

data/ext/commonmarker/cmark/src/blocks.c

@@ -1317,20 +1317,20 @@ cmark_node *cmark_parser_finish(cmark_parser *parser) {
   }
 #endif
 
-  res = parser->root;
-  parser->root = NULL;
-
-  cmark_parser_reset(parser);
-
   for (extensions = parser->syntax_extensions; extensions; extensions = extensions->next) {
     cmark_syntax_extension *ext = (cmark_syntax_extension *) extensions->data;
     if (ext->postprocess_func) {
-      cmark_node *processed = ext->postprocess_func(ext, res);
+      cmark_node *processed = ext->postprocess_func(ext, parser, parser->root);
       if (processed)
-        res = processed;
+        parser->root = processed;
     }
   }
 
+  res = parser->root;
+  parser->root = NULL;
+
+  cmark_parser_reset(parser);
+
   return res;
 }
 
@@ -1390,3 +1390,7 @@ void cmark_parser_set_backslash_ispunct_func(cmark_parser *parser,
                                              cmark_ispunct_func func) {
   parser->backslash_ispunct = func;
 }
+
+cmark_llist *cmark_parser_get_syntax_extensions(cmark_parser *parser) {
+  return parser->syntax_extensions;
+}

data/ext/commonmarker/cmark/src/cmark_extension_api.h

@@ -234,6 +234,10 @@ typedef void (*cmark_common_render_func) (cmark_syntax_extension *extension,
                                           cmark_event_type ev_type,
                                           int options);
 
+typedef int (*cmark_commonmark_escape_func) (cmark_syntax_extension *extension,
+                                              cmark_node *node,
+                                              int c);
+
 typedef void (*cmark_html_render_func) (cmark_syntax_extension *extension,
                                         cmark_html_renderer *renderer,
                                         cmark_node *node,
@@ -245,6 +249,7 @@ typedef int (*cmark_html_filter_func) (cmark_syntax_extension *extension,
                                        size_t tag_len);
 
 typedef cmark_node *(*cmark_postprocess_func) (cmark_syntax_extension *extension,
+                                               cmark_parser *parser,
                                                cmark_node *root);
 
 typedef int (*cmark_ispunct_func) (char c);
@@ -344,6 +349,12 @@ CMARK_EXPORT
 void cmark_syntax_extension_set_html_filter_func(cmark_syntax_extension *extension,
                                                  cmark_html_filter_func func);
 
+/** See the documentation for 'cmark_syntax_extension'
+ */
+CMARK_EXPORT
+void cmark_syntax_extension_set_commonmark_escape_func(cmark_syntax_extension *extension,
+                                                       cmark_commonmark_escape_func func);
+
 /** See the documentation for 'cmark_syntax_extension'
  */
 CMARK_EXPORT
@@ -672,6 +683,9 @@ int cmark_inline_parser_scan_delimiters(cmark_inline_parser *parser,
 CMARK_EXPORT
 void cmark_manage_extensions_special_characters(cmark_parser *parser, bool add);
 
+CMARK_EXPORT
+cmark_llist *cmark_parser_get_syntax_extensions(cmark_parser *parser);
+
 #ifdef __cplusplus
 }
 #endif

data/ext/commonmarker/cmark/src/commonmark.c

@@ -12,8 +12,8 @@
 #include "render.h"
 #include "syntax_extension.h"
 
-#define OUT(s, wrap, escaping) renderer->out(renderer, s, wrap, escaping)
-#define LIT(s) renderer->out(renderer, s, false, LITERAL)
+#define OUT(s, wrap, escaping) renderer->out(renderer, node, s, wrap, escaping)
+#define LIT(s) renderer->out(renderer, node, s, false, LITERAL)
 #define CR() renderer->cr(renderer)
 #define BLANKLINE() renderer->blankline(renderer)
 #define ENCODED_SIZE 20
@@ -21,7 +21,8 @@
 
 // Functions to convert cmark_nodes to commonmark strings.
 
-static CMARK_INLINE void outc(cmark_renderer *renderer, cmark_escaping escape,
+static CMARK_INLINE void outc(cmark_renderer *renderer, cmark_node *node, 
+                              cmark_escaping escape,
                               int32_t c, unsigned char nextc) {
   bool needs_escaping = false;
   bool follows_digit =
@@ -32,8 +33,9 @@ static CMARK_INLINE void outc(cmark_renderer *renderer, cmark_escaping escape,
   needs_escaping =
       c < 0x80 && escape != LITERAL &&
       ((escape == NORMAL &&
-        (c == '*' || c == '_' || c == '[' || c == ']' || c == '#' || c == '<' ||
-         c == '>' || c == '\\' || c == '`' || c == '!' || c == '|' ||
+        ((node->parent && node->parent->extension && node->parent->extension->commonmark_escape_func && node->parent->extension->commonmark_escape_func(node->extension, node->parent, 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

data/ext/commonmarker/cmark/src/inlines.c

@@ -626,12 +626,7 @@ static delimiter *S_insert_emph(subject *subj, delimiter *opener,
   cmark_node *tmp, *tmpnext, *emph;
 
   // calculate the actual number of characters used from this closer
-  if (closer_num_chars < 3 || opener_num_chars < 3) {
-    use_delims = closer_num_chars <= opener_num_chars ? closer_num_chars
-                                                      : opener_num_chars;
-  } else { // closer and opener both have >= 3 characters
-    use_delims = closer_num_chars % 2 == 0 ? 2 : 1;
-  }
+  use_delims = (closer_num_chars >= 2 && opener_num_chars >=2) ? 2 : 1;
 
   // remove used characters from associated inlines.
   opener_num_chars -= use_delims;

data/ext/commonmarker/cmark/src/latex.c

@@ -12,13 +12,14 @@
 #include "render.h"
 #include "syntax_extension.h"
 
-#define OUT(s, wrap, escaping) renderer->out(renderer, s, wrap, escaping)
-#define LIT(s) renderer->out(renderer, s, false, LITERAL)
+#define OUT(s, wrap, escaping) renderer->out(renderer, node, s, wrap, escaping)
+#define LIT(s) renderer->out(renderer, node, s, false, LITERAL)
 #define CR() renderer->cr(renderer)
 #define BLANKLINE() renderer->blankline(renderer)
 #define LIST_NUMBER_STRING_SIZE 20
 
-static CMARK_INLINE void outc(cmark_renderer *renderer, cmark_escaping escape,
+static CMARK_INLINE void outc(cmark_renderer *renderer, cmark_node *node,
+                              cmark_escaping escape,
                               int32_t c, unsigned char nextc) {
   if (escape == LITERAL) {
     cmark_render_code_point(renderer, c);

data/ext/commonmarker/cmark/src/man.c

@@ -11,14 +11,15 @@
 #include "render.h"
 #include "syntax_extension.h"
 
-#define OUT(s, wrap, escaping) renderer->out(renderer, s, wrap, escaping)
-#define LIT(s) renderer->out(renderer, s, false, LITERAL)
+#define OUT(s, wrap, escaping) renderer->out(renderer, node, s, wrap, escaping)
+#define LIT(s) renderer->out(renderer, node, s, false, LITERAL)
 #define CR() renderer->cr(renderer)
 #define BLANKLINE() renderer->blankline(renderer)
 #define LIST_NUMBER_SIZE 20
 
 // Functions to convert cmark_nodes to groff man strings.
-static void S_outc(cmark_renderer *renderer, cmark_escaping escape, int32_t c,
+static void S_outc(cmark_renderer *renderer, cmark_node *node, 
+                   cmark_escaping escape, int32_t c,
                    unsigned char nextc) {
   (void)(nextc);
 

data/ext/commonmarker/cmark/src/render.c

@@ -18,7 +18,8 @@ static CMARK_INLINE void S_blankline(cmark_renderer *renderer) {
   }
 }
 
-static void S_out(cmark_renderer *renderer, const char *source, bool wrap,
+static void S_out(cmark_renderer *renderer, cmark_node *node,
+                  const char *source, bool wrap,
                   cmark_escaping escape) {
   int length = (int)strlen(source);
   unsigned char nextc;
@@ -97,7 +98,7 @@ static void S_out(cmark_renderer *renderer, const char *source, bool wrap,
       renderer->begin_content =
           renderer->begin_content && cmark_isdigit((char)c) == 1;
     } else {
-      (renderer->outc)(renderer, escape, c, nextc);
+      (renderer->outc)(renderer, node, escape, c, nextc);
       renderer->begin_line = false;
       renderer->begin_content =
           renderer->begin_content && cmark_isdigit((char)c) == 1;
@@ -143,7 +144,8 @@ void cmark_render_code_point(cmark_renderer *renderer, uint32_t c) {
 }
 
 char *cmark_render(cmark_mem *mem, cmark_node *root, int options, int width,
-                   void (*outc)(cmark_renderer *, cmark_escaping, int32_t,
+                   void (*outc)(cmark_renderer *, cmark_node *,
+                                cmark_escaping, int32_t,
                                 unsigned char),
                    int (*render_node)(cmark_renderer *renderer,
                                       cmark_node *node,

data/ext/commonmarker/cmark/src/render.h

@@ -24,10 +24,10 @@ struct cmark_renderer {
   bool begin_content;
   bool no_linebreaks;
   bool in_tight_list_item;
-  void (*outc)(struct cmark_renderer *, cmark_escaping, int32_t, unsigned char);
+  void (*outc)(struct cmark_renderer *, cmark_node *, cmark_escaping, int32_t, unsigned char);
   void (*cr)(struct cmark_renderer *);
   void (*blankline)(struct cmark_renderer *);
-  void (*out)(struct cmark_renderer *, const char *, bool, cmark_escaping);
+  void (*out)(struct cmark_renderer *, cmark_node *, const char *, bool, cmark_escaping);
 };
 
 typedef struct cmark_renderer cmark_renderer;
@@ -46,7 +46,8 @@ void cmark_render_ascii(cmark_renderer *renderer, const char *s);
 void cmark_render_code_point(cmark_renderer *renderer, uint32_t c);
 
 char *cmark_render(cmark_mem *mem, cmark_node *root, int options, int width,
-                   void (*outc)(cmark_renderer *, cmark_escaping, int32_t,
+                   void (*outc)(cmark_renderer *, cmark_node *,
+                                cmark_escaping, int32_t,
                                 unsigned char),
                    int (*render_node)(cmark_renderer *renderer,
                                       cmark_node *node,

data/ext/commonmarker/cmark/src/syntax_extension.c

@@ -117,3 +117,8 @@ void cmark_syntax_extension_set_opaque_free_func(cmark_syntax_extension *extensi
                                                  cmark_opaque_free_func func) {
   extension->opaque_free_func = func;
 }
+
+void cmark_syntax_extension_set_commonmark_escape_func(cmark_syntax_extension *extension,
+                                                       cmark_commonmark_escape_func func) {
+  extension->commonmark_escape_func = func;
+}

data/ext/commonmarker/cmark/src/syntax_extension.h

@@ -23,6 +23,7 @@ struct cmark_syntax_extension {
   cmark_html_filter_func          html_filter_func;
   cmark_postprocess_func          postprocess_func;
   cmark_opaque_free_func          opaque_free_func;
+  cmark_commonmark_escape_func    commonmark_escape_func;
 };
 
 #endif

data/ext/commonmarker/cmark/test/CMakeLists.txt

@@ -63,14 +63,15 @@ IF (PYTHONINTERP_FOUND)
     )
 
   add_test(extensions_executable
-    ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/spec_tests.py" "--no-normalize" "--spec" "${CMAKE_CURRENT_SOURCE_DIR}/extensions.txt" "--program" "${CMAKE_CURRENT_BINARY_DIR}/../src/cmark -e table -e strikethrough -e autolink -e tagfilter"
+    ${PYTHON_EXECUTABLE} "${CMAKE_CURRENT_SOURCE_DIR}/spec_tests.py" "--no-normalize" "--spec" "${CMAKE_CURRENT_SOURCE_DIR}/extensions.txt" "--program" "${CMAKE_CURRENT_BINARY_DIR}/../src/cmark" "--extensions" "table strikethrough autolink tagfilter"
     )
 
   add_test(roundtrip_extensions_executable
     ${PYTHON_EXECUTABLE}
     "${CMAKE_CURRENT_SOURCE_DIR}/roundtrip_tests.py"
     "--spec" "${CMAKE_CURRENT_SOURCE_DIR}/extensions.txt"
-    "--program" "${CMAKE_CURRENT_BINARY_DIR}/../src/cmark -e table -e strikethrough -e autolink -e tagfilter"
+    "--program" "${CMAKE_CURRENT_BINARY_DIR}/../src/cmark"
+    "--extensions" "table strikethrough autolink tagfilter"
     )
 
   add_test(regressiontest_executable

data/ext/commonmarker/cmark/test/cmark.py

@@ -11,50 +11,96 @@ def pipe_through_prog(prog, text):
     [result, err] = p1.communicate(input=text.encode('utf-8'))
     return [p1.returncode, result.decode('utf-8'), err]
 
-def to_html(lib, text):
-    markdown = lib.cmark_markdown_to_html
-    markdown.restype = c_char_p
-    markdown.argtypes = [c_char_p, c_size_t, c_int]
+def parse(lib, extlib, text, extensions):
+    register_plugin = lib.cmark_register_plugin
+    register_plugin.argtypes = [c_void_p]
+
+    core_extensions_registration = extlib.core_extensions_registration
+
+    find_syntax_extension = lib.cmark_find_syntax_extension
+    find_syntax_extension.restype = c_void_p
+    find_syntax_extension.argtypes = [c_char_p]
+
+    parser_attach_syntax_extension = lib.cmark_parser_attach_syntax_extension
+    parser_attach_syntax_extension.argtypes = [c_void_p, c_void_p]
+
+    parser_new = lib.cmark_parser_new
+    parser_new.restype = c_void_p
+    parser_new.argtypes = [c_int]
+    
+    parser_feed = lib.cmark_parser_feed
+    parser_feed.argtypes = [c_void_p, c_char_p, c_int]
+
+    parser_finish = lib.cmark_parser_finish
+    parser_finish.restype = c_void_p
+    parser_finish.argtypes = [c_void_p]
+
+    register_plugin(core_extensions_registration)
+
+    parser = parser_new(0)
+    for e in set(extensions):
+        ext = find_syntax_extension(bytes(e, 'utf-8'))
+        if not ext:
+            raise Exception("Extension not found: '{}'".format(e))
+        parser_attach_syntax_extension(parser, ext)
+
     textbytes = text.encode('utf-8')
     textlen = len(textbytes)
-    result = markdown(textbytes, textlen, 0).decode('utf-8')
+    parser_feed(parser, textbytes, textlen)
+
+    return [parser_finish(parser), parser]
+
+def to_html(lib, extlib, text, extensions):
+    document, parser = parse(lib, extlib, text, extensions)
+    parser_get_syntax_extensions = lib.cmark_parser_get_syntax_extensions
+    parser_get_syntax_extensions.restype = c_void_p
+    parser_get_syntax_extensions.argtypes = [c_void_p]
+    syntax_extensions = parser_get_syntax_extensions(parser)
+
+    render_html = lib.cmark_render_html
+    render_html.restype = c_char_p
+    render_html.argtypes = [c_void_p, c_int, c_void_p]
+    result = render_html(document, 0, syntax_extensions).decode('utf-8')
     return [0, result, '']
 
-def to_commonmark(lib, text):
-    textbytes = text.encode('utf-8')
-    textlen = len(textbytes)
-    parse_document = lib.cmark_parse_document
-    parse_document.restype = c_void_p
-    parse_document.argtypes = [c_char_p, c_size_t, c_int]
+def to_commonmark(lib, extlib, text, extensions):
+    document, _ = parse(lib, extlib, text, extensions)
+
     render_commonmark = lib.cmark_render_commonmark
     render_commonmark.restype = c_char_p
     render_commonmark.argtypes = [c_void_p, c_int, c_int]
-    node = parse_document(textbytes, textlen, 0)
-    result = render_commonmark(node, 0, 0).decode('utf-8')
+    result = render_commonmark(document, 0, 0).decode('utf-8')
     return [0, result, '']
 
 class CMark:
-    def __init__(self, prog=None, library_dir=None):
+    def __init__(self, prog=None, library_dir=None, extensions=None):
         self.prog = prog
+        self.extensions = []
+        if extensions:
+            self.extensions = extensions.split()
+
         if prog:
-            self.to_html = lambda x: pipe_through_prog(prog, x)
-            self.to_commonmark = lambda x: pipe_through_prog(prog + ' -t commonmark', x)
+            extsfun = lambda exts: ''.join([' -e ' + e for e in set(exts)])
+            self.to_html = lambda x, exts=[]: pipe_through_prog(prog + extsfun(exts + self.extensions), x)
+            self.to_commonmark = lambda x, exts=[]: pipe_through_prog(prog + ' -t commonmark' + extsfun(exts + self.extensions), x)
         else:
             sysname = platform.system()
             if sysname == 'Darwin':
-                libnames = [ "libcmark.dylib" ]
+                libnames = [ ["lib", ".dylib" ] ]
             elif sysname == 'Windows':
-                libnames = [ "cmark.dll", "libcmark.dll" ]
+                libnames = [ ["", ".dll"], ["lib", ".dll"] ]
             else:
-                libnames = [ "libcmark.so" ]
+                libnames = [ ["lib", ".so"] ]
             if not library_dir:
                 library_dir = os.path.join("build", "src")
-            for libname in libnames:
-                candidate = os.path.join(library_dir, libname)
+            for prefix, suffix in libnames:
+                candidate = os.path.join(library_dir, prefix + "cmark" + suffix)
                 if os.path.isfile(candidate):
                     libpath = candidate
                     break
             cmark = CDLL(libpath)
-            self.to_html = lambda x: to_html(cmark, x)
-            self.to_commonmark = lambda x: to_commonmark(cmark, x)
+            extlib = CDLL(os.path.join(
+                library_dir, "..", "extensions", prefix + "cmarkextensions" + suffix))
+            self.to_html = lambda x, exts=[]: to_html(cmark, extlib, x, exts + self.extensions)
+            self.to_commonmark = lambda x, exts=[]: to_commonmark(cmark, extlib, x, exts + self.extensions)