commonmarker 0.2.1 → 0.3.0

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

@@ -9,13 +9,13 @@ set(HEADERS
   iterator.h
   chunk.h
   references.h
-  debug.h
   bench.h
   utf8.h
   scanners.h
   inlines.h
   houdini.h
   cmark_ctype.h
+  render.h
   )
 set(LIBRARY_SOURCES
   cmark.c
@@ -28,10 +28,12 @@ set(LIBRARY_SOURCES
   utf8.c
   buffer.c
   references.c
+  render.c
   man.c
   xml.c
   html.c
   commonmark.c
+  latex.c
   houdini_href_e.c
   houdini_html_e.c
   houdini_html_u.c
@@ -86,7 +88,8 @@ set_target_properties(${LIBRARY} PROPERTIES
   SOVERSION ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}
   VERSION ${PROJECT_VERSION})
 set_target_properties(${STATICLIBRARY} PROPERTIES
-  COMPILE_FLAGS -DCMARK_STATIC_DEFINE)
+  COMPILE_FLAGS -DCMARK_STATIC_DEFINE
+  POSITION_INDEPENDENT_CODE ON)
 
 if (MSVC)
   set_target_properties(${STATICLIBRARY} PROPERTIES

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

@@ -13,7 +13,6 @@
 #include "inlines.h"
 #include "houdini.h"
 #include "buffer.h"
-#include "debug.h"
 
 #define CODE_INDENT 4
 #define TAB_STOP 4
@@ -401,11 +400,16 @@ static bufsize_t parse_list_marker(cmark_chunk *input, bufsize_t pos, cmark_list
 		}
 	} else if (cmark_isdigit(c)) {
 		int start = 0;
+		int digits = 0;
 
 		do {
 			start = (10 * start) + (peek_at(input, pos) - '0');
 			pos++;
-		} while (cmark_isdigit(peek_at(input, pos)));
+			digits++;
+			// We limit to 9 digits to avoid overflow,
+			// assuming max int is 2^31 - 1
+			// This also seems to be the limit for 'start' in some browsers.
+		} while (digits < 9 && cmark_isdigit(peek_at(input, pos)));
 
 		c = peek_at(input, pos);
 		if (c == '.' || c == ')') {
@@ -560,8 +564,9 @@ static void chop_trailing_hashtags(cmark_chunk *ch)
 	while (n >= 0 && peek_at(ch, n) == '#')
 		n--;
 
-	// Check for a be a space before the final #s:
-	if (n != orig_n && n >= 0 && peek_at(ch, n) == ' ') {
+	// Check for a space before the final #s:
+	if (n != orig_n && n >= 0 &&
+	    (peek_at(ch, n) == ' ' || peek_at(ch, n) == '\t')) {
 		ch->len = n;
 		cmark_chunk_rtrim(ch);
 	}
@@ -722,8 +727,26 @@ S_process_line(cmark_parser *parser, const unsigned char *buffer, bufsize_t byte
 
 		} else if (container->type == NODE_HTML) {
 
-			if (parser->blank) {
-				all_matched = false;
+			switch (container->as.html_block_type) {
+			case 1:
+			case 2:
+			case 3:
+			case 4:
+			case 5:
+				// these types of blocks can accept blanks
+				break;
+			case 6:
+			case 7:
+				if (parser->blank) {
+					all_matched = false;
+				}
+				break;
+			default:
+				fprintf(stderr,
+				        "Error (%s:%d): Unknown HTML block type %d\n",
+				        __FILE__, __LINE__,
+				        container->as.html_block_type);
+				exit(1);
 			}
 
 		} else if (container->type == NODE_PARAGRAPH) {
@@ -789,9 +812,13 @@ S_process_line(cmark_parser *parser, const unsigned char *buffer, bufsize_t byte
 			container->as.code.info = cmark_chunk_literal("");
 			S_advance_offset(parser, &input, parser->first_nonspace + matched - parser->offset, false);
 
-		} else if (!indented && (matched = scan_html_block_tag(&input, parser->first_nonspace))) {
+		} else if (!indented &&
+		           ((matched = scan_html_block_start(&input, parser->first_nonspace)) ||
+		            (container->type != NODE_PARAGRAPH &&
+		             (matched = scan_html_block_start_7(&input, parser->first_nonspace))))) {
 
 			container = add_child(parser, container, NODE_HTML, parser->first_nonspace + 1);
+			container->as.html_block_type = matched;
 			// note, we don't adjust parser->offset because the tag is part of the text
 
 		} else if (!indented &&
@@ -923,11 +950,51 @@ S_process_line(cmark_parser *parser, const unsigned char *buffer, bufsize_t byte
 			assert(parser->current != NULL);
 		}
 
-		if (container->type == NODE_CODE_BLOCK ||
-		    container->type == NODE_HTML) {
+		if (container->type == NODE_CODE_BLOCK) {
+
+			add_line(container, &input, parser->offset);
+
+		} else if (container->type == NODE_HTML) {
 
 			add_line(container, &input, parser->offset);
 
+			int matches_end_condition;
+			switch (container->as.html_block_type) {
+			case 1:
+				// </script>, </style>, </pre>
+				matches_end_condition =
+				    scan_html_block_end_1(&input, parser->first_nonspace);
+				break;
+			case 2:
+				// -->
+				matches_end_condition =
+				    scan_html_block_end_2(&input, parser->first_nonspace);
+				break;
+			case 3:
+				// ?>
+				matches_end_condition =
+				    scan_html_block_end_3(&input, parser->first_nonspace);
+				break;
+			case 4:
+				// >
+				matches_end_condition =
+				    scan_html_block_end_4(&input, parser->first_nonspace);
+				break;
+			case 5:
+				// ]]>
+				matches_end_condition =
+				    scan_html_block_end_5(&input, parser->first_nonspace);
+				break;
+			default:
+				matches_end_condition = 0;
+				break;
+			}
+
+			if (matches_end_condition) {
+				container = finalize(parser, container);
+				assert(parser->current != NULL);
+			}
+
 		} else if (parser->blank) {
 
 			// ??? do nothing

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

@@ -6,8 +6,15 @@
 #include "cmark.h"
 #include "buffer.h"
 
-const int cmark_version = CMARK_VERSION;
-const char cmark_version_string[] = CMARK_VERSION_STRING;
+int cmark_version()
+{
+	return CMARK_VERSION;
+}
+
+const char *cmark_version_string()
+{
+	return CMARK_VERSION_STRING;
+}
 
 char *cmark_markdown_to_html(const char *text, size_t len, int options)
 {

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

@@ -479,13 +479,18 @@ char *cmark_render_html(cmark_node *root, int options);
 /** Render a 'node' tree as a groff man page, without the header.
  */
 CMARK_EXPORT
-char *cmark_render_man(cmark_node *root, int options);
+char *cmark_render_man(cmark_node *root, int options, int width);
 
 /** Render a 'node' tree as a commonmark document.
  */
 CMARK_EXPORT
 char *cmark_render_commonmark(cmark_node *root, int options, int width);
 
+/** Render a 'node' tree as a LaTeX document.
+ */
+CMARK_EXPORT
+char *cmark_render_latex(cmark_node *root, int options, int width);
+
 /** Default writer options.
  */
 #define CMARK_OPT_DEFAULT 0
@@ -511,6 +516,14 @@ char *cmark_render_commonmark(cmark_node *root, int options, int width);
  */
 #define CMARK_OPT_VALIDATE_UTF8 16
 
+/** Suppress raw HTML and unsafe links (`javascript:`, `vbscript:`,
+ * `file:`, and `data:`, except for `image/png`, `image/gif`,
+ * `image/jpeg`, or `image/webp` mime types).  Raw HTML is replaced
+ * by a placeholder HTML comment. Unsafe links are replaced by
+ * empty strings.
+ */
+#define CMARK_OPT_SAFE 32
+
 /**
  * ## Version information
  */
@@ -525,13 +538,13 @@ char *cmark_render_commonmark(cmark_node *root, int options, int width);
  * In hexadecimal format, the number 0x010203 represents version 1.2.3.
  */
 CMARK_EXPORT
-extern const int cmark_version;
+int cmark_version();
 
 /** The library version string for runtime checks. Also available as
  * macro CMARK_VERSION_STRING for compile time checks.
  */
 CMARK_EXPORT
-extern const char cmark_version_string[];
+const char *cmark_version_string();
 
 /** # AUTHORS
  *

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

@@ -10,192 +10,63 @@
 #include "buffer.h"
 #include "utf8.h"
 #include "scanners.h"
+#include "render.h"
 
-// Functions to convert cmark_nodes to commonmark strings.
-
-struct render_state {
-	int options;
-	cmark_strbuf* buffer;
-	cmark_strbuf* prefix;
-	int column;
-	int width;
-	int need_cr;
-	bufsize_t last_breakable;
-	bool begin_line;
-	bool no_wrap;
-	bool in_tight_list_item;
-};
-
-static inline void cr(struct render_state *state)
-{
-	if (state->need_cr < 1) {
-		state->need_cr = 1;
-	}
-}
+#define safe_strlen(s) cmark_strbuf_safe_strlen(s)
+#define OUT(s, wrap, escaping) renderer->out(renderer, s, wrap, escaping)
+#define LIT(s) renderer->out(renderer, s, false, LITERAL)
+#define CR() renderer->cr(renderer)
+#define BLANKLINE() renderer->blankline(renderer)
 
-static inline void blankline(struct render_state *state)
-{
-	if (state->need_cr < 2) {
-		state->need_cr = 2;
-	}
-}
-
-typedef enum  {
-	LITERAL,
-	NORMAL,
-	TITLE,
-	URL
-} escaping;
-
-static inline bool
-needs_escaping(escaping escape,
-               int32_t c,
-               unsigned char next_c,
-               struct render_state *state)
-{
-	if (escape == NORMAL) {
-		return (c == '*' || c == '_' || c == '[' || c == ']' ||
-		        c == '<' || c == '>' || c == '\\' || c == '`' ||
-		        (c == '&' && isalpha(next_c)) ||
-		        (c == '!' && next_c == '[') ||
-		        (state->begin_line &&
-		         (c == '-' || c == '+' || c == '#' || c == '=')) ||
-		        (c == '#' && (isspace(next_c) || next_c == '\0')) ||
-		        ((c == '.' || c == ')') &&
-		         isdigit(state->buffer->ptr[state->buffer->size - 1])));
-	} else if (escape == TITLE) {
-		return (c == '`' || c == '<' || c == '>' || c == '"' ||
-		        c == '\\');
-	} else if (escape == URL) {
-		return (c == '`' || c == '<' || c == '>' || isspace(c) ||
-		        c == '\\' || c == ')' || c == '(');
-	} else {
-		return false;
-	}
-}
+// Functions to convert cmark_nodes to commonmark strings.
 
-static inline void out(struct render_state *state,
-                       cmark_chunk str,
-                       bool wrap,
-                       escaping escape)
+static inline void outc(cmark_renderer *renderer,
+                        cmark_escaping escape,
+                        int32_t c,
+                        unsigned char nextc)
 {
-	unsigned char* source = str.data;
-	int length = str.len;
-	unsigned char nextc;
-	int32_t c;
-	int i = 0;
-	int len;
-	cmark_chunk remainder = cmark_chunk_literal("");
-	int k = state->buffer->size - 1;
-
-	wrap = wrap && !state->no_wrap;
-
-	if (state->in_tight_list_item && state->need_cr > 1) {
-		state->need_cr = 1;
-	}
-	while (state->need_cr) {
-		if (k < 0 || state->buffer->ptr[k] == '\n') {
-			k -= 1;
+	bool needs_escaping = false;
+	needs_escaping =
+	    escape != LITERAL &&
+	    ((escape == NORMAL &&
+	      (c == '*' || c == '_' || c == '[' || c == ']' || c == '#' ||
+	       c == '<' || c == '>' || c == '\\' || c == '`' || c == '!' ||
+	       (c == '&' && isalpha(nextc)) ||
+	       (c == '!' && nextc == '[') ||
+	       (renderer->begin_line &&
+	        (c == '-' || c == '+' || c == '=')) ||
+	       ((c == '.' || c == ')') &&
+	        isdigit(renderer->buffer->ptr[renderer->buffer->size - 1])))) ||
+	     (escape == URL &&
+	      (c == '`' || c == '<' || c == '>' || isspace(c) ||
+	       c == '\\' || c == ')' || c == '(')) ||
+	     (escape == TITLE &&
+	      (c == '`' || c == '<' || c == '>' || c == '"' ||
+	       c == '\\')));
+
+	if (needs_escaping) {
+		if (isspace(c)) {
+			// use percent encoding for spaces
+			cmark_strbuf_printf(renderer->buffer, "%%%2x", c);
+			renderer->column += 3;
 		} else {
-			cmark_strbuf_putc(state->buffer, '\n');
-			if (state->need_cr > 1) {
-				cmark_strbuf_put(state->buffer, state->prefix->ptr,
-				                 state->prefix->size);
-			}
-		}
-		state->column = 0;
-		state->begin_line = true;
-		state->need_cr -= 1;
-	}
-
-	while (i < length) {
-		if (state->begin_line) {
-			cmark_strbuf_put(state->buffer, state->prefix->ptr,
-			                 state->prefix->size);
-			// note: this assumes prefix is ascii:
-			state->column = state->prefix->size;
-		}
-
-		len = utf8proc_iterate(source + i, length - i, &c);
-		if (len == -1) { // error condition
-			return;  // return without rendering rest of string
+			cmark_render_ascii(renderer, "\\");
+			cmark_render_code_point(renderer, c);
 		}
-		nextc = source[i + len];
-		if (c == 32 && wrap) {
-			if (!state->begin_line) {
-				cmark_strbuf_putc(state->buffer, ' ');
-				state->column += 1;
-				state->begin_line = false;
-				state->last_breakable = state->buffer->size -
-				                        1;
-				// skip following spaces
-				while (source[i + 1] == ' ') {
-					i++;
-				}
-			}
-
-		} else if (c == 10) {
-			cmark_strbuf_putc(state->buffer, '\n');
-			state->column = 0;
-			state->begin_line = true;
-			state->last_breakable = 0;
-		} else if (needs_escaping(escape, c, nextc, state)) {
-			if (isspace(c)) {
-				// use percent encoding for spaces
-				cmark_strbuf_printf(state->buffer, "%%%2x", c);
-				state->column += 3;
-			} else {
-				cmark_strbuf_putc(state->buffer, '\\');
-				utf8proc_encode_char(c, state->buffer);
-				state->column += 2;
-			}
-			state->begin_line = false;
-		} else {
-			utf8proc_encode_char(c, state->buffer);
-			state->column += 1;
-			state->begin_line = false;
-		}
-
-		// If adding the character went beyond width, look for an
-		// earlier place where the line could be broken:
-		if (state->width > 0 &&
-		    state->column > state->width &&
-		    !state->begin_line &&
-		    state->last_breakable > 0) {
-
-			// copy from last_breakable to remainder
-			cmark_chunk_set_cstr(&remainder, (char *) state->buffer->ptr + state->last_breakable + 1);
-			// truncate at last_breakable
-			cmark_strbuf_truncate(state->buffer, state->last_breakable);
-			// add newline, prefix, and remainder
-			cmark_strbuf_putc(state->buffer, '\n');
-			cmark_strbuf_put(state->buffer, state->prefix->ptr,
-			                 state->prefix->size);
-			cmark_strbuf_put(state->buffer, remainder.data, remainder.len);
-			state->column = state->prefix->size + remainder.len;
-			cmark_chunk_free(&remainder);
-			state->last_breakable = 0;
-			state->begin_line = false;
-		}
-
-		i += len;
+	} else {
+		cmark_render_code_point(renderer, c);
 	}
 }
 
-static void lit(struct render_state *state, char *s, bool wrap)
-{
-	cmark_chunk str = cmark_chunk_literal(s);
-	out(state, str, wrap, LITERAL);
-}
-
 static int
-longest_backtick_sequence(cmark_chunk *code)
+longest_backtick_sequence(const char *code)
 {
 	int longest = 0;
 	int current = 0;
-	int i = 0;
-	while (i <= code->len) {
-		if (code->data[i] == '`') {
+	size_t i = 0;
+	size_t code_len = safe_strlen(code);
+	while (i <= code_len) {
+		if (code[i] == '`') {
 			current++;
 		} else {
 			if (current > longest) {
@@ -209,13 +80,14 @@ longest_backtick_sequence(cmark_chunk *code)
 }
 
 static int
-shortest_unused_backtick_sequence(cmark_chunk *code)
+shortest_unused_backtick_sequence(const char *code)
 {
 	int32_t used = 1;
 	int current = 0;
-	int i = 0;
-	while (i <= code->len) {
-		if (code->data[i] == '`') {
+	size_t i = 0;
+	size_t code_len = safe_strlen(code);
+	while (i <= code_len) {
+		if (code[i] == '`') {
 			current++;
 		} else {
 			if (current) {
@@ -240,6 +112,8 @@ is_autolink(cmark_node *node)
 	cmark_chunk *title;
 	cmark_chunk *url;
 	cmark_node *link_text;
+	char *realurl;
+	int realurllen;
 
 	if (node->type != CMARK_NODE_LINK) {
 		return false;
@@ -258,8 +132,14 @@ is_autolink(cmark_node *node)
 
 	link_text = node->first_child;
 	cmark_consolidate_text_nodes(link_text);
-	return (url->len == link_text->as.literal.len &&
-	        strncmp((char*)url->data,
+	realurl = (char*)url->data;
+	realurllen = url->len;
+	if (strncmp(realurl, "mailto:", 7) == 0) {
+		realurl += 7;
+		realurllen -= 7;
+	}
+	return (realurllen == link_text->as.literal.len &&
+	        strncmp(realurl,
 	                (char*)link_text->as.literal.data,
 	                link_text->as.literal.len) == 0);
 }
@@ -278,18 +158,19 @@ get_containing_block(cmark_node *node)
 }
 
 static int
-S_render_node(cmark_node *node, cmark_event_type ev_type,
-              struct render_state *state)
+S_render_node(cmark_renderer *renderer,
+              cmark_node *node,
+              cmark_event_type ev_type,
+              int options)
 {
 	cmark_node *tmp;
-	cmark_chunk *code;
 	int list_number;
 	cmark_delim_type list_delim;
 	int numticks;
 	int i;
 	bool entering = (ev_type == CMARK_EVENT_ENTER);
-	cmark_chunk *info;
-	cmark_chunk *title;
+	const char *info, *code, *title;
+	size_t info_len, code_len;
 	cmark_strbuf listmarker = GH_BUF_INIT;
 	char *emph_delim;
 	bufsize_t marker_width;
@@ -300,7 +181,7 @@ S_render_node(cmark_node *node, cmark_event_type ev_type,
 	if (!(node->type == CMARK_NODE_ITEM && node->prev == NULL &&
 	      entering)) {
 		tmp = get_containing_block(node);
-		state->in_tight_list_item =
+		renderer->in_tight_list_item =
 		    (tmp->type == CMARK_NODE_ITEM &&
 		     cmark_node_get_list_tight(tmp->parent)) ||
 		    (tmp &&
@@ -311,19 +192,16 @@ S_render_node(cmark_node *node, cmark_event_type ev_type,
 
 	switch (node->type) {
 	case CMARK_NODE_DOCUMENT:
-		if (!entering) {
-			cmark_strbuf_putc(state->buffer, '\n');
-		}
 		break;
 
 	case CMARK_NODE_BLOCK_QUOTE:
 		if (entering) {
-			lit(state, "> ", false);
-			cmark_strbuf_puts(state->prefix, "> ");
+			LIT("> ");
+			cmark_strbuf_puts(renderer->prefix, "> ");
 		} else {
-			cmark_strbuf_truncate(state->prefix,
-			                      state->prefix->size - 2);
-			blankline(state);
+			cmark_strbuf_truncate(renderer->prefix,
+			                      renderer->prefix->size - 2);
+			BLANKLINE();
 		}
 		break;
 
@@ -333,8 +211,7 @@ S_render_node(cmark_node *node, cmark_event_type ev_type,
 		     node->next->type == CMARK_NODE_LIST)) {
 			// this ensures 2 blank lines after list,
 			// if before code block or list:
-			lit(state, "\n", false);
-			state->need_cr = 0;
+			LIT("\n");
 		}
 		break;
 
@@ -363,19 +240,19 @@ S_render_node(cmark_node *node, cmark_event_type ev_type,
 		if (entering) {
 			if (cmark_node_get_list_type(node->parent) ==
 			    CMARK_BULLET_LIST) {
-				lit(state, "* ", false);
-				cmark_strbuf_puts(state->prefix, "  ");
+				LIT("* ");
+				cmark_strbuf_puts(renderer->prefix, "  ");
 			} else {
-				lit(state, (char *)listmarker.ptr, false);
+				LIT((char *)listmarker.ptr);
 				for (i = marker_width; i--;) {
-					cmark_strbuf_putc(state->prefix, ' ');
+					cmark_strbuf_putc(renderer->prefix, ' ');
 				}
 			}
 		} else {
-			cmark_strbuf_truncate(state->prefix,
-			                      state->prefix->size -
+			cmark_strbuf_truncate(renderer->prefix,
+			                      renderer->prefix->size -
 			                      marker_width);
-			cr(state);
+			CR();
 		}
 		cmark_strbuf_free(&listmarker);
 		break;
@@ -383,119 +260,123 @@ S_render_node(cmark_node *node, cmark_event_type ev_type,
 	case CMARK_NODE_HEADER:
 		if (entering) {
 			for (int i = cmark_node_get_header_level(node); i > 0; i--) {
-				lit(state, "#", false);
+				LIT("#");
 			}
-			lit(state, " ", false);
-			state->no_wrap = true;
+			LIT(" ");
+			renderer->no_wrap = true;
 		} else {
-			state->no_wrap = false;
-			blankline(state);
+			renderer->no_wrap = false;
+			BLANKLINE();
 		}
 		break;
 
 	case CMARK_NODE_CODE_BLOCK:
-		blankline(state);
-		info = &node->as.code.info;
-		code = &node->as.code.literal;
+		BLANKLINE();
+		info = cmark_node_get_fence_info(node);
+		info_len = safe_strlen(info);
+		code = cmark_node_get_literal(node);
+		code_len = safe_strlen(code);
 		// use indented form if no info, and code doesn't
 		// begin or end with a blank line, and code isn't
 		// first thing in a list item
-		if (info->len == 0 &&
-		    (code->len > 2 &&
-		     !isspace(code->data[0]) &&
-		     !(isspace(code->data[code->len - 1]) &&
-		       isspace(code->data[code->len - 2]))) &&
+		if (info_len == 0 &&
+		    (code_len > 2 &&
+		     !isspace(code[0]) &&
+		     !(isspace(code[code_len - 1]) &&
+		       isspace(code[code_len - 2]))) &&
 		    !(node->prev == NULL && node->parent &&
 		      node->parent->type == CMARK_NODE_ITEM)) {
-			lit(state, "    ", false);
-			cmark_strbuf_puts(state->prefix, "    ");
-			out(state, node->as.code.literal, false, LITERAL);
-			cmark_strbuf_truncate(state->prefix,
-			                      state->prefix->size - 4);
+			LIT("    ");
+			cmark_strbuf_puts(renderer->prefix, "    ");
+			OUT(cmark_node_get_literal(node), false, LITERAL);
+			cmark_strbuf_truncate(renderer->prefix,
+			                      renderer->prefix->size - 4);
 		} else {
 			numticks = longest_backtick_sequence(code) + 1;
 			if (numticks < 3) {
 				numticks = 3;
 			}
 			for (i = 0; i < numticks; i++) {
-				lit(state, "`", false);
+				LIT("`");
 			}
-			lit(state, " ", false);
-			out(state, *info, false, LITERAL);
-			cr(state);
-			out(state, node->as.code.literal, false, LITERAL);
-			cr(state);
+			LIT(" ");
+			OUT(info, false, LITERAL);
+			CR();
+			OUT(cmark_node_get_literal(node), false, LITERAL);
+			CR();
 			for (i = 0; i < numticks; i++) {
-				lit(state, "`", false);
+				LIT("`");
 			}
 		}
-		blankline(state);
+		BLANKLINE();
 		break;
 
 	case CMARK_NODE_HTML:
-		blankline(state);
-		out(state, node->as.literal, false, LITERAL);
-		blankline(state);
+		BLANKLINE();
+		OUT(cmark_node_get_literal(node), false, LITERAL);
+		BLANKLINE();
 		break;
 
 	case CMARK_NODE_HRULE:
-		blankline(state);
-		lit(state, "-----", false);
-		blankline(state);
+		BLANKLINE();
+		LIT("-----");
+		BLANKLINE();
 		break;
 
 	case CMARK_NODE_PARAGRAPH:
 		if (!entering) {
-			blankline(state);
+			BLANKLINE();
 		}
 		break;
 
 	case CMARK_NODE_TEXT:
-		out(state, node->as.literal, true, NORMAL);
+		OUT(cmark_node_get_literal(node), true, NORMAL);
 		break;
 
 	case CMARK_NODE_LINEBREAK:
-		if (!(CMARK_OPT_HARDBREAKS & state->options)) {
-			lit(state, "\\", false);
+		if (!(CMARK_OPT_HARDBREAKS & options)) {
+			LIT("\\");
 		}
-		cr(state);
+		CR();
 		break;
 
 	case CMARK_NODE_SOFTBREAK:
-		if (state->width == 0) {
-			cr(state);
+		if (renderer->width == 0 &&
+		    !(CMARK_OPT_HARDBREAKS & options)) {
+			CR();
 		} else {
-			lit(state, " ", true);
+			OUT(" ", true, LITERAL);
 		}
 		break;
 
 	case CMARK_NODE_CODE:
-		code = &node->as.literal;
+		code = cmark_node_get_literal(node);
+		code_len = safe_strlen(code);
 		numticks = shortest_unused_backtick_sequence(code);
 		for (i = 0; i < numticks; i++) {
-			lit(state, "`", false);
+			LIT("`");
 		}
-		if (code->len == 0 || code->data[0] == '`') {
-			lit(state, " ", false);
+		if (code_len == 0 || code[0] == '`') {
+			LIT(" ");
 		}
-		out(state, node->as.literal, true, LITERAL);
-		if (code->len == 0 || code->data[code->len - 1] == '`') {
-			lit(state, " ", false);
+		OUT(cmark_node_get_literal(node), true, LITERAL);
+		if (code_len == 0 || code[code_len - 1] == '`') {
+			LIT(" ");
 		}
 		for (i = 0; i < numticks; i++) {
-			lit(state, "`", false);
+			LIT("`");
 		}
 		break;
 
 	case CMARK_NODE_INLINE_HTML:
-		out(state, node->as.literal, false, LITERAL);
+		OUT(cmark_node_get_literal(node), false, LITERAL);
 		break;
 
 	case CMARK_NODE_STRONG:
 		if (entering) {
-			lit(state, "**", false);
+			LIT("**");
 		} else {
-			lit(state, "**", false);
+			LIT("**");
 		}
 		break;
 
@@ -509,62 +390,56 @@ S_render_node(cmark_node *node, cmark_event_type ev_type,
 			emph_delim = "*";
 		}
 		if (entering) {
-			lit(state, emph_delim, false);
+			LIT(emph_delim);
 		} else {
-			lit(state, emph_delim, false);
+			LIT(emph_delim);
 		}
 		break;
 
 	case CMARK_NODE_LINK:
 		if (is_autolink(node)) {
 			if (entering) {
-				lit(state, "<", false);
+				LIT("<");
 				if (strncmp(cmark_node_get_url(node),
 				            "mailto:", 7) == 0) {
-					lit(state,
-					    (char *)cmark_node_get_url(node) + 7,
-					    false);
+					LIT((char *)cmark_node_get_url(node) + 7);
 				} else {
-					lit(state,
-					    (char *)cmark_node_get_url(node),
-					    false);
+					LIT((char *)cmark_node_get_url(node));
 				}
-				lit(state, ">", false);
+				LIT(">");
 				// return signal to skip contents of node...
 				return 0;
 			}
 		} else {
 			if (entering) {
-				lit(state, "[", false);
+				LIT("[");
 			} else {
-				lit(state, "](", false);
-				out(state,
-				    cmark_chunk_literal(cmark_node_get_url(node)),
-				    false, URL);
-				title = &node->as.link.title;
-				if (title->len > 0) {
-					lit(state, " \"", true);
-					out(state, *title, false, TITLE);
-					lit(state, "\"", false);
+				LIT("](");
+				OUT(cmark_node_get_url(node), false, URL);
+				title = cmark_node_get_title(node);
+				if (safe_strlen(title) > 0) {
+					LIT(" \"");
+					OUT(title, false, TITLE);
+					LIT("\"");
 				}
-				lit(state, ")", false);
+				LIT(")");
 			}
 		}
 		break;
 
 	case CMARK_NODE_IMAGE:
 		if (entering) {
-			lit(state, "![", false);
+			LIT("![");
 		} else {
-			lit(state, "](", false);
-			out(state, cmark_chunk_literal(cmark_node_get_url(node)), false, URL);
-			title = &node->as.link.title;
-			if (title->len > 0) {
-				lit(state, " \"", true);
-				out(state, *title, false, TITLE);
-				lit(state, "\"", false);
+			LIT("](");
+			OUT(cmark_node_get_url(node), false, URL);
+			title = cmark_node_get_title(node);
+			if (safe_strlen(title) > 0) {
+				OUT(" \"", true, LITERAL);
+				OUT(title, false, TITLE);
+				LIT("\"");
 			}
-			lit(state, ")", false);
+			LIT(")");
 		}
 		break;
 
@@ -578,32 +453,10 @@ S_render_node(cmark_node *node, cmark_event_type ev_type,
 
 char *cmark_render_commonmark(cmark_node *root, int options, int width)
 {
-	char *result;
-	cmark_strbuf commonmark = GH_BUF_INIT;
-	cmark_strbuf prefix = GH_BUF_INIT;
-	if (CMARK_OPT_HARDBREAKS & options) {
+	if (options & CMARK_OPT_HARDBREAKS) {
+		// disable breaking on width, since it has
+		// a different meaning with OPT_HARDBREAKS
 		width = 0;
 	}
-	struct render_state state = {
-		options, &commonmark, &prefix, 0, width,
-		0, 0, true, false, false
-	};
-	cmark_node *cur;
-	cmark_event_type ev_type;
-	cmark_iter *iter = cmark_iter_new(root);
-
-	while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) {
-		cur = cmark_iter_get_node(iter);
-		if (!S_render_node(cur, ev_type, &state)) {
-			// a false value causes us to skip processing
-			// the node's contents.  this is used for
-			// autolinks.
-			cmark_iter_reset(iter, cur, CMARK_EVENT_EXIT);
-		}
-	}
-	result = (char *)cmark_strbuf_detach(&commonmark);
-
-	cmark_strbuf_free(&prefix);
-	cmark_iter_free(iter);
-	return result;
+	return cmark_render(root, options, width, outc, S_render_node);
 }