commonmarker 0.0.1

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

@@ -0,0 +1,36 @@
+#ifndef CMARK_DEBUG_H
+#define CMARK_DEBUG_H
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+
+#ifdef NDEBUG
+#define debug(M, ...)
+#else
+#define debug(M, ...) \
+  fprintf(stderr, "DEBUG %s:%d: " M "\n", __FILE__, __LINE__, ##__VA_ARGS__)
+#endif
+
+#define clean_errno() (errno == 0 ? "None" : strerror(errno))
+
+#define log_err(M, ...) \
+  fprintf(stderr, "[ERROR] (%s:%d: errno: %s) " M "\n", __FILE__, __LINE__, \
+           clean_errno(), ##__VA_ARGS__)
+
+#define log_warn(M, ...) \
+  fprintf(stderr, "[WARN] (%s:%d: errno: %s) " M "\n", __FILE__, __LINE__, \
+           clean_errno(), ##__VA_ARGS__)
+
+#define log_info(M, ...) fprintf(stderr, "[INFO] (%s:%d) " M "\n", __FILE__, \
+            __LINE__, ##__VA_ARGS__)
+
+#define check(A, M, ...) \
+  if(!(A)) { log_err(M, ##__VA_ARGS__); errno=0; goto error; }
+
+#define sentinel(M, ...) \
+   { log_err(M, ##__VA_ARGS__); errno=0; goto error; }
+
+#define check_debug(A, M, ...) \
+  if(!(A)) { debug(M, ##__VA_ARGS__); errno=0; goto error; }
+
+#endif

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

@@ -0,0 +1,52 @@
+#ifndef CMARK_HOUDINI_H
+#define CMARK_HOUDINI_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include "config.h"
+#include "buffer.h"
+
+#ifdef HAVE___BUILTIN_EXPECT
+#	define likely(x)	__builtin_expect((x),1)
+#	define unlikely(x)	__builtin_expect((x),0)
+#else
+#	define likely(x)	(x)
+#	define unlikely(x)	(x)
+#endif
+
+#ifdef HOUDINI_USE_LOCALE
+#	define _isxdigit(c) isxdigit(c)
+#	define _isdigit(c) isdigit(c)
+#else
+/*
+ * Helper _isdigit methods -- do not trust the current locale
+ * */
+#	define _isxdigit(c) (strchr("0123456789ABCDEFabcdef", (c)) != NULL)
+#	define _isdigit(c) ((c) >= '0' && (c) <= '9')
+#endif
+
+#define HOUDINI_ESCAPED_SIZE(x) (((x) * 12) / 10)
+#define HOUDINI_UNESCAPED_SIZE(x) (x)
+
+extern size_t houdini_unescape_ent(cmark_strbuf *ob, const uint8_t *src, size_t size);
+extern int houdini_escape_html(cmark_strbuf *ob, const uint8_t *src, size_t size);
+extern int houdini_escape_html0(cmark_strbuf *ob, const uint8_t *src, size_t size, int secure);
+extern int houdini_unescape_html(cmark_strbuf *ob, const uint8_t *src, size_t size);
+extern void houdini_unescape_html_f(cmark_strbuf *ob, const uint8_t *src, size_t size);
+extern int houdini_escape_xml(cmark_strbuf *ob, const uint8_t *src, size_t size);
+extern int houdini_escape_uri(cmark_strbuf *ob, const uint8_t *src, size_t size);
+extern int houdini_escape_url(cmark_strbuf *ob, const uint8_t *src, size_t size);
+extern int houdini_escape_href(cmark_strbuf *ob, const uint8_t *src, size_t size);
+extern int houdini_unescape_uri(cmark_strbuf *ob, const uint8_t *src, size_t size);
+extern int houdini_unescape_url(cmark_strbuf *ob, const uint8_t *src, size_t size);
+extern int houdini_escape_js(cmark_strbuf *ob, const uint8_t *src, size_t size);
+extern int houdini_unescape_js(cmark_strbuf *ob, const uint8_t *src, size_t size);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

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

@@ -0,0 +1,107 @@
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "houdini.h"
+
+/*
+ * The following characters will not be escaped:
+ *
+ *		-_.+!*'(),%#@?=;:/,+&$ alphanum
+ *
+ * Note that this character set is the addition of:
+ *
+ *	- The characters which are safe to be in an URL
+ *	- The characters which are *not* safe to be in
+ *	an URL because they are RESERVED characters.
+ *
+ * We asume (lazily) that any RESERVED char that
+ * appears inside an URL is actually meant to
+ * have its native function (i.e. as an URL
+ * component/separator) and hence needs no escaping.
+ *
+ * There are two exceptions: the chacters & (amp)
+ * and ' (single quote) do not appear in the table.
+ * They are meant to appear in the URL as components,
+ * yet they require special HTML-entity escaping
+ * to generate valid HTML markup.
+ *
+ * All other characters will be escaped to %XX.
+ *
+ */
+static const char HREF_SAFE[] = {
+	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, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1,
+	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,
+	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, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+};
+
+int
+houdini_escape_href(cmark_strbuf *ob, const uint8_t *src, size_t size)
+{
+	static const uint8_t hex_chars[] = "0123456789ABCDEF";
+	size_t  i = 0, org;
+	uint8_t hex_str[3];
+
+	hex_str[0] = '%';
+
+	while (i < size) {
+		org = i;
+		while (i < size && HREF_SAFE[src[i]] != 0)
+			i++;
+
+		if (likely(i > org))
+			cmark_strbuf_put(ob, src + org, i - org);
+
+		/* escaping */
+		if (i >= size)
+			break;
+
+		switch (src[i]) {
+		/* amp appears all the time in URLs, but needs
+		 * HTML-entity escaping to be inside an href */
+		case '&':
+			cmark_strbuf_puts(ob, "&amp;");
+			break;
+
+		/* the single quote is a valid URL character
+		 * according to the standard; it needs HTML
+		 * entity escaping too */
+		case '\'':
+			cmark_strbuf_puts(ob, "&#x27;");
+			break;
+
+			/* the space can be escaped to %20 or a plus
+			 * sign. we're going with the generic escape
+			 * for now. the plus thing is more commonly seen
+			 * when building GET strings */
+#if 0
+		case ' ':
+			cmark_strbuf_putc(ob, '+');
+			break;
+#endif
+
+		/* every other character goes with a %XX escaping */
+		default:
+			hex_str[1] = hex_chars[(src[i] >> 4) & 0xF];
+			hex_str[2] = hex_chars[src[i] & 0xF];
+			cmark_strbuf_put(ob, hex_str, 3);
+		}
+
+		i++;
+	}
+
+	return 1;
+}

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

@@ -0,0 +1,81 @@
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "houdini.h"
+
+/**
+ * According to the OWASP rules:
+ *
+ * & --> &amp;
+ * < --> &lt;
+ * > --> &gt;
+ * " --> &quot;
+ * ' --> &#x27;     &apos; is not recommended
+ * / --> &#x2F;     forward slash is included as it helps end an HTML entity
+ *
+ */
+static const char HTML_ESCAPE_TABLE[] = {
+	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, 1, 0, 0, 0, 2, 3, 0, 0, 0, 0, 0, 0, 0, 4,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 6, 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, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+};
+
+static const char *HTML_ESCAPES[] = {
+	"",
+	"&quot;",
+	"&amp;",
+	"&#39;",
+	"&#47;",
+	"&lt;",
+	"&gt;"
+};
+
+int
+houdini_escape_html0(cmark_strbuf *ob, const uint8_t *src, size_t size, int secure)
+{
+	size_t  i = 0, org, esc = 0;
+
+	while (i < size) {
+		org = i;
+		while (i < size && (esc = HTML_ESCAPE_TABLE[src[i]]) == 0)
+			i++;
+
+		if (i > org)
+			cmark_strbuf_put(ob, src + org, i - org);
+
+		/* escaping */
+		if (unlikely(i >= size))
+			break;
+
+		/* The forward slash is only escaped in secure mode */
+		if ((src[i] == '/' || src[i] == '\'') && !secure) {
+			cmark_strbuf_putc(ob, src[i]);
+		} else {
+			cmark_strbuf_puts(ob, HTML_ESCAPES[esc]);
+		}
+
+		i++;
+	}
+
+	return 1;
+}
+
+int
+houdini_escape_html(cmark_strbuf *ob, const uint8_t *src, size_t size)
+{
+	return houdini_escape_html0(ob, src, size, 1);
+}

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

@@ -0,0 +1,116 @@
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "buffer.h"
+#include "houdini.h"
+#include "utf8.h"
+#include "html_unescape.h"
+
+size_t
+houdini_unescape_ent(cmark_strbuf *ob, const uint8_t *src, size_t size)
+{
+	size_t i = 0;
+
+	if (size > 3 && src[0] == '#') {
+		int codepoint = 0;
+
+		if (_isdigit(src[1])) {
+			for (i = 1; i < size && _isdigit(src[i]); ++i) {
+				int cp = (codepoint * 10) + (src[i] - '0');
+
+				if (cp < codepoint)
+					return 0;
+
+				codepoint = cp;
+			}
+		}
+
+		else if (src[1] == 'x' || src[1] == 'X') {
+			for (i = 2; i < size && _isxdigit(src[i]); ++i) {
+				int cp = (codepoint * 16) + ((src[i] | 32) % 39 - 9);
+
+				if (cp < codepoint)
+					return 0;
+
+				codepoint = cp;
+			}
+		}
+
+		if (i < size && src[i] == ';' && codepoint) {
+			utf8proc_encode_char(codepoint, ob);
+			return i + 1;
+		}
+	}
+
+	else {
+		if (size > MAX_WORD_LENGTH)
+			size = MAX_WORD_LENGTH;
+
+		for (i = MIN_WORD_LENGTH; i < size; ++i) {
+			if (src[i] == ' ')
+				break;
+
+			if (src[i] == ';') {
+				const struct html_ent *entity = find_entity((char *)src, i);
+
+				if (entity != NULL) {
+					int len = 0;
+					while (len < 4 && entity->utf8[len] != '\0') {
+						++len;
+					}
+					cmark_strbuf_put(ob, entity->utf8, len);
+					return i + 1;
+				}
+
+				break;
+			}
+		}
+	}
+
+	return 0;
+}
+
+int
+houdini_unescape_html(cmark_strbuf *ob, const uint8_t *src, size_t size)
+{
+	size_t  i = 0, org, ent;
+
+	while (i < size) {
+		org = i;
+		while (i < size && src[i] != '&')
+			i++;
+
+		if (likely(i > org)) {
+			if (unlikely(org == 0)) {
+				if (i >= size)
+					return 0;
+
+				cmark_strbuf_grow(ob, HOUDINI_UNESCAPED_SIZE(size));
+			}
+
+			cmark_strbuf_put(ob, src + org, i - org);
+		}
+
+		/* escaping */
+		if (i >= size)
+			break;
+
+		i++;
+
+		ent = houdini_unescape_ent(ob, src + i, size - i);
+		i += ent;
+
+		/* not really an entity */
+		if (ent == 0)
+			cmark_strbuf_putc(ob, '&');
+	}
+
+	return 1;
+}
+
+void houdini_unescape_html_f(cmark_strbuf *ob, const uint8_t *src, size_t size)
+{
+	if (!houdini_unescape_html(ob, src, size))
+		cmark_strbuf_put(ob, src, size);
+}

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

@@ -0,0 +1,322 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+#include "config.h"
+#include "cmark.h"
+#include "node.h"
+#include "buffer.h"
+#include "houdini.h"
+
+// Functions to convert cmark_nodes to HTML strings.
+
+static void escape_html(cmark_strbuf *dest, const unsigned char *source, int length)
+{
+	if (length < 0)
+		length = strlen((char *)source);
+
+	houdini_escape_html0(dest, source, (size_t)length, 0);
+}
+
+static void escape_href(cmark_strbuf *dest, const unsigned char *source, int length)
+{
+	if (length < 0)
+		length = strlen((char *)source);
+
+	houdini_escape_href(dest, source, (size_t)length);
+}
+
+static inline void cr(cmark_strbuf *html)
+{
+	if (html->size && html->ptr[html->size - 1] != '\n')
+		cmark_strbuf_putc(html, '\n');
+}
+
+struct render_state {
+	cmark_strbuf* html;
+	cmark_node *plain;
+};
+
+static void
+S_render_sourcepos(cmark_node *node, cmark_strbuf *html, int options)
+{
+	if (CMARK_OPT_SOURCEPOS & options) {
+		cmark_strbuf_printf(html, " data-sourcepos=\"%d:%d-%d:%d\"",
+		                    cmark_node_get_start_line(node),
+		                    cmark_node_get_start_column(node),
+		                    cmark_node_get_end_line(node),
+		                    cmark_node_get_end_column(node));
+	}
+}
+
+static int
+S_render_node(cmark_node *node, cmark_event_type ev_type,
+              struct render_state *state, int options)
+{
+	cmark_node *parent;
+	cmark_node *grandparent;
+	cmark_strbuf *html = state->html;
+	char start_header[] = "<h0";
+	char end_header[] = "</h0";
+	bool tight;
+
+	bool entering = (ev_type == CMARK_EVENT_ENTER);
+
+	if (state->plain == node) { // back at original node
+		state->plain = NULL;
+	}
+
+	if (state->plain != NULL) {
+		switch(node->type) {
+		case CMARK_NODE_TEXT:
+		case CMARK_NODE_CODE:
+		case CMARK_NODE_INLINE_HTML:
+			escape_html(html, node->as.literal.data,
+			            node->as.literal.len);
+			break;
+
+		case CMARK_NODE_LINEBREAK:
+		case CMARK_NODE_SOFTBREAK:
+			cmark_strbuf_putc(html, ' ');
+			break;
+
+		default:
+			break;
+		}
+		return 1;
+	}
+
+	switch (node->type) {
+	case CMARK_NODE_DOCUMENT:
+		break;
+
+	case CMARK_NODE_BLOCK_QUOTE:
+		if (entering) {
+			cr(html);
+			cmark_strbuf_puts(html, "<blockquote");
+			S_render_sourcepos(node, html, options);
+			cmark_strbuf_puts(html, ">\n");
+		} else {
+			cr(html);
+			cmark_strbuf_puts(html, "</blockquote>\n");
+		}
+		break;
+
+	case CMARK_NODE_LIST: {
+		cmark_list_type list_type = node->as.list.list_type;
+		int start = node->as.list.start;
+
+		if (entering) {
+			cr(html);
+			if (list_type == CMARK_BULLET_LIST) {
+				cmark_strbuf_puts(html, "<ul");
+				S_render_sourcepos(node, html, options);
+				cmark_strbuf_puts(html, ">\n");
+			} else if (start == 1) {
+				cmark_strbuf_puts(html, "<ol");
+				S_render_sourcepos(node, html, options);
+				cmark_strbuf_puts(html, ">\n");
+			} else {
+				cmark_strbuf_printf(html,
+				                    "<ol start=\"%d\"",
+				                    start);
+				S_render_sourcepos(node, html, options);
+				cmark_strbuf_puts(html, ">\n");
+			}
+		} else {
+			cmark_strbuf_puts(html,
+			                  list_type == CMARK_BULLET_LIST ?
+			                  "</ul>\n" : "</ol>\n");
+		}
+		break;
+	}
+
+	case CMARK_NODE_ITEM:
+		if (entering) {
+			cr(html);
+			cmark_strbuf_puts(html, "<li");
+			S_render_sourcepos(node, html, options);
+			cmark_strbuf_putc(html, '>');
+		} else {
+			cmark_strbuf_puts(html, "</li>\n");
+		}
+		break;
+
+	case CMARK_NODE_HEADER:
+		if (entering) {
+			cr(html);
+			start_header[2] = '0' + node->as.header.level;
+			cmark_strbuf_puts(html, start_header);
+			S_render_sourcepos(node, html, options);
+			cmark_strbuf_putc(html, '>');
+		} else {
+			end_header[3] = '0' + node->as.header.level;
+			cmark_strbuf_puts(html, end_header);
+			cmark_strbuf_puts(html, ">\n");
+		}
+		break;
+
+	case CMARK_NODE_CODE_BLOCK:
+		cr(html);
+
+		if (!node->as.code.fenced || node->as.code.info.len == 0) {
+			cmark_strbuf_puts(html, "<pre");
+			S_render_sourcepos(node, html, options);
+			cmark_strbuf_puts(html, "><code>");
+		} else {
+			int first_tag = 0;
+			while (first_tag < node->as.code.info.len &&
+			       node->as.code.info.data[first_tag] != ' ') {
+				first_tag += 1;
+			}
+
+			cmark_strbuf_puts(html, "<pre");
+			S_render_sourcepos(node, html, options);
+			cmark_strbuf_puts(html, "><code class=\"language-");
+			escape_html(html, node->as.code.info.data, first_tag);
+			cmark_strbuf_puts(html, "\">");
+		}
+
+		escape_html(html, node->as.code.literal.data,
+		            node->as.code.literal.len);
+		cmark_strbuf_puts(html, "</code></pre>\n");
+		break;
+
+	case CMARK_NODE_HTML:
+		cr(html);
+		cmark_strbuf_put(html, node->as.literal.data, node->as.literal.len);
+		break;
+
+	case CMARK_NODE_HRULE:
+		cr(html);
+		cmark_strbuf_puts(html, "<hr");
+		S_render_sourcepos(node, html, options);
+		cmark_strbuf_puts(html, " />\n");
+		break;
+
+	case CMARK_NODE_PARAGRAPH:
+		parent = cmark_node_parent(node);
+		grandparent = cmark_node_parent(parent);
+		if (grandparent != NULL &&
+		    grandparent->type == CMARK_NODE_LIST) {
+			tight = grandparent->as.list.tight;
+		} else {
+			tight = false;
+		}
+		if (!tight) {
+			if (entering) {
+				cr(html);
+				cmark_strbuf_puts(html, "<p");
+				S_render_sourcepos(node, html, options);
+				cmark_strbuf_putc(html, '>');
+			} else {
+				cmark_strbuf_puts(html, "</p>\n");
+			}
+		}
+		break;
+
+	case CMARK_NODE_TEXT:
+		escape_html(html, node->as.literal.data, node->as.literal.len);
+		break;
+
+	case CMARK_NODE_LINEBREAK:
+		cmark_strbuf_puts(html, "<br />\n");
+		break;
+
+	case CMARK_NODE_SOFTBREAK:
+		if (options & CMARK_OPT_HARDBREAKS) {
+			cmark_strbuf_puts(html, "<br />\n");
+		} else {
+			cmark_strbuf_putc(html, '\n');
+		}
+		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>");
+		break;
+
+	case CMARK_NODE_INLINE_HTML:
+		cmark_strbuf_put(html, node->as.literal.data, node->as.literal.len);
+		break;
+
+	case CMARK_NODE_STRONG:
+		if (entering) {
+			cmark_strbuf_puts(html, "<strong>");
+		} else {
+			cmark_strbuf_puts(html, "</strong>");
+		}
+		break;
+
+	case CMARK_NODE_EMPH:
+		if (entering) {
+			cmark_strbuf_puts(html, "<em>");
+		} else {
+			cmark_strbuf_puts(html, "</em>");
+		}
+		break;
+
+	case CMARK_NODE_LINK:
+		if (entering) {
+			cmark_strbuf_puts(html, "<a href=\"");
+			if (node->as.link.url)
+				escape_href(html, node->as.link.url, -1);
+
+			if (node->as.link.title) {
+				cmark_strbuf_puts(html, "\" title=\"");
+				escape_html(html, node->as.link.title, -1);
+			}
+
+			cmark_strbuf_puts(html, "\">");
+		} else {
+			cmark_strbuf_puts(html, "</a>");
+		}
+		break;
+
+	case CMARK_NODE_IMAGE:
+		if (entering) {
+			cmark_strbuf_puts(html, "<img src=\"");
+			if (node->as.link.url)
+				escape_href(html, node->as.link.url, -1);
+
+			cmark_strbuf_puts(html, "\" alt=\"");
+			state->plain = node;
+		} else {
+			if (node->as.link.title) {
+				cmark_strbuf_puts(html, "\" title=\"");
+				escape_html(html, node->as.link.title, -1);
+			}
+
+			cmark_strbuf_puts(html, "\" />");
+		}
+		break;
+
+	default:
+		assert(false);
+		break;
+	}
+
+	// cmark_strbuf_putc(html, 'x');
+	return 1;
+}
+
+char *cmark_render_html(cmark_node *root, int options)
+{
+	char *result;
+	cmark_strbuf html = GH_BUF_INIT;
+	cmark_event_type ev_type;
+	cmark_node *cur;
+	struct render_state state = { &html, NULL };
+	cmark_iter *iter = cmark_iter_new(root);
+
+	while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) {
+		cur = cmark_iter_get_node(iter);
+		S_render_node(cur, ev_type, &state, options);
+	}
+	result = (char *)cmark_strbuf_detach(&html);
+
+	cmark_iter_free(iter);
+	return result;
+}