redcarpet 1.17.2 → 2.0.0

data/ext/redcarpet/markdown.c

@@ -18,48 +18,58 @@
  */
 
 #include "markdown.h"
-#include "array.h"
+#include "stack.h"
 
 #include <assert.h>
 #include <string.h>
-//#include <strings.h> /* for strncasecmp */
 #include <ctype.h>
 #include <stdio.h>
 
+#define REF_TABLE_SIZE 8
+
 #define BUFFER_BLOCK 0
 #define BUFFER_SPAN 1
 
 #define MKD_LI_END 8	/* internal list flag */
 
+#define gperf_case_strncmp(s1, s2, n) strncasecmp(s1, s2, n)
+#define GPERF_DOWNCASE 1
+#define GPERF_CASE_STRNCMP 1
+#include "html_blocks.h"
+
 /***************
  * LOCAL TYPES *
  ***************/
 
-/* link_ref • reference to a link */
+/* link_ref: reference to a link */
 struct link_ref {
-	struct buf *id;
+	unsigned int id;
+
 	struct buf *link;
 	struct buf *title;
+
+	struct link_ref *next;
 };
 
-/* char_trigger • function pointer to render active chars */
+/* char_trigger: function pointer to render active chars */
 /*   returns the number of chars taken care of */
 /*   data is the pointer of the beginning of the span */
 /*   offset is the number of valid chars before data */
-struct render;
+struct sd_markdown;
 typedef size_t
-(*char_trigger)(struct buf *ob, struct render *rndr, char *data, size_t offset, size_t size);
-
-static size_t char_emphasis(struct buf *ob, struct render *rndr, char *data, size_t offset, size_t size);
-static size_t char_linebreak(struct buf *ob, struct render *rndr, char *data, size_t offset, size_t size);
-static size_t char_codespan(struct buf *ob, struct render *rndr, char *data, size_t offset, size_t size);
-static size_t char_escape(struct buf *ob, struct render *rndr, char *data, size_t offset, size_t size);
-static size_t char_entity(struct buf *ob, struct render *rndr, char *data, size_t offset, size_t size);
-static size_t char_langle_tag(struct buf *ob, struct render *rndr, char *data, size_t offset, size_t size);
-static size_t char_autolink_url(struct buf *ob, struct render *rndr, char *data, size_t offset, size_t size);
-static size_t char_autolink_email(struct buf *ob, struct render *rndr, char *data, size_t offset, size_t size);
-static size_t char_autolink_www(struct buf *ob, struct render *rndr, char *data, size_t offset, size_t size);
-static size_t char_link(struct buf *ob, struct render *rndr, char *data, size_t offset, size_t size);
+(*char_trigger)(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size);
+
+static size_t char_emphasis(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size);
+static size_t char_linebreak(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size);
+static size_t char_codespan(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size);
+static size_t char_escape(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size);
+static size_t char_entity(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size);
+static size_t char_langle_tag(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size);
+static size_t char_autolink_url(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size);
+static size_t char_autolink_email(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size);
+static size_t char_autolink_www(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size);
+static size_t char_link(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size);
+static size_t char_superscript(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size);
 
 enum markdown_char_t {
 	MD_CHAR_NONE = 0,
@@ -72,7 +82,8 @@ enum markdown_char_t {
 	MD_CHAR_ENTITITY,
 	MD_CHAR_AUTOLINK_URL,
 	MD_CHAR_AUTOLINK_EMAIL,
-	MD_CHAR_AUTOLINK_WWW
+	MD_CHAR_AUTOLINK_WWW,
+	MD_CHAR_SUPERSCRIPT,
 };
 
 static char_trigger markdown_char_ptrs[] = {
@@ -87,84 +98,51 @@ static char_trigger markdown_char_ptrs[] = {
 	&char_autolink_url,
 	&char_autolink_email,
 	&char_autolink_www,
+	&char_superscript,
 };
 
 /* render • structure containing one particular render */
-struct render {
-	struct mkd_renderer	make;
-	struct array refs;
-	char active_char[256];
-	struct parray work_bufs[2];
+struct sd_markdown {
+	struct sd_callbacks	cb;
+	void *opaque;
+
+	struct link_ref *refs[REF_TABLE_SIZE];
+	uint8_t active_char[256];
+	struct stack work_bufs[2];
 	unsigned int ext_flags;
 	size_t max_nesting;
+	int in_link_body;
 };
 
-/* html_tag • structure for quick HTML tag search (inspired from discount) */
-struct html_tag {
-	const char *text;
-	size_t size;
-};
+/***************************
+ * HELPER FUNCTIONS *
+ ***************************/
 
 static inline struct buf *
-rndr_newbuf(struct render *rndr, int type)
+rndr_newbuf(struct sd_markdown *rndr, int type)
 {
 	static const size_t buf_size[2] = {256, 64};
 	struct buf *work = NULL;
-	struct parray *queue = &rndr->work_bufs[type];
+	struct stack *pool = &rndr->work_bufs[type];
 
-	if (queue->size < queue->asize) {
-		work = queue->item[queue->size++];
+	if (pool->size < pool->asize &&
+		pool->item[pool->size] != NULL) {
+		work = pool->item[pool->size++];
 		work->size = 0;
 	} else {
 		work = bufnew(buf_size[type]);
-		parr_push(queue, work);
+		stack_push(pool, work);
 	}
 
 	return work;
 }
 
 static inline void
-rndr_popbuf(struct render *rndr, int type)
+rndr_popbuf(struct sd_markdown *rndr, int type)
 {
 	rndr->work_bufs[type].size--;
 }
 
-/********************
- * GLOBAL VARIABLES *
- ********************/
-
-/* block_tags • recognised block tags, sorted by cmp_html_tag */
-static struct html_tag block_tags[] = {
-/*0*/	{ "p",		1 },
-	{ "dl",		2 },
-	{ "h1",		2 },
-	{ "h2",		2 },
-	{ "h3",		2 },
-	{ "h4",		2 },
-	{ "h5",		2 },
-	{ "h6",		2 },
-	{ "ol",		2 },
-	{ "ul",		2 },
-/*10*/	{ "del",	3 },
-	{ "div",	3 },
-/*12*/	{ "ins",	3 },
-	{ "pre",	3 },
-	{ "form",	4 },
-	{ "math",	4 },
-	{ "table",	5 },
-	{ "iframe",	6 },
-	{ "script",	6 },
-	{ "fieldset",	8 },
-	{ "noscript",	8 },
-	{ "blockquote",	10 }
-};
-
-#define INS_TAG (block_tags + 12)
-#define DEL_TAG (block_tags + 10)
-
-/***************************
- * HELPER FUNCTIONS *
- ***************************/
 static void
 unscape_text(struct buf *ob, struct buf *src)
 {
@@ -185,54 +163,87 @@ unscape_text(struct buf *ob, struct buf *src)
 	}
 }
 
-/* cmp_link_ref • comparison function for link_ref sorted arrays */
-static int
-cmp_link_ref(void *key, void *array_entry)
+static unsigned int
+hash_link_ref(const uint8_t *link_ref, size_t length)
 {
-	struct link_ref *lr = array_entry;
-	return bufcasecmp(key, lr->id);
+	size_t i;
+	unsigned int hash = 0;
+
+	for (i = 0; i < length; ++i)
+		hash = tolower(link_ref[i]) + (hash << 6) + (hash << 16) - hash;
+
+	return hash;
 }
 
-/* cmp_link_ref_sort • comparison function for link_ref qsort */
-static int
-cmp_link_ref_sort(const void *a, const void *b)
+static struct link_ref *
+add_link_ref(
+	struct link_ref **references,
+	const uint8_t *name, size_t name_size)
 {
-	const struct link_ref *lra = a;
-	const struct link_ref *lrb = b;
-	return bufcasecmp(lra->id, lrb->id);
+	struct link_ref *ref = calloc(1, sizeof(struct link_ref));
+
+	if (!ref)
+		return NULL;
+
+	ref->id = hash_link_ref(name, name_size);
+	ref->next = references[ref->id % REF_TABLE_SIZE];
+
+	references[ref->id % REF_TABLE_SIZE] = ref;
+	return ref;
 }
 
-/* cmp_html_tag • comparison function for bsearch() (stolen from discount) */
-static int
-cmp_html_tag(const void *a, const void *b)
+static struct link_ref *
+find_link_ref(struct link_ref **references, uint8_t *name, size_t length)
 {
-	const struct html_tag *hta = a;
-	const struct html_tag *htb = b;
-	if (hta->size != htb->size) return (int)(hta->size - htb->size);
-	return strncasecmp(hta->text, htb->text, hta->size);
-}
+	unsigned int hash = hash_link_ref(name, length);
+	struct link_ref *ref = NULL;
+
+	ref = references[hash % REF_TABLE_SIZE];
 
+	while (ref != NULL) {
+		if (ref->id == hash)
+			return ref;
 
-/* find_block_tag • returns the current block tag */
-static struct html_tag *
-find_block_tag(char *data, size_t size)
+		ref = ref->next;
+	}
+
+	return NULL;
+}
+
+static void
+free_link_refs(struct link_ref **references)
 {
-	size_t i = 0;
-	struct html_tag key;
+	size_t i;
 
-	/* looking for the word end */
-	while (i < size && ((data[i] >= '0' && data[i] <= '9')
-				|| (data[i] >= 'A' && data[i] <= 'Z')
-				|| (data[i] >= 'a' && data[i] <= 'z')))
-		i += 1;
-	if (i >= size) return 0;
+	for (i = 0; i < REF_TABLE_SIZE; ++i) {
+		struct link_ref *r = references[i];
+		struct link_ref *next;
+
+		while (r) {
+			next = r->next;
+			bufrelease(r->link);
+			bufrelease(r->title);
+			free(r);
+			r = next;
+		}
+	}
+}
+
+/*
+ * Check whether a char is a Markdown space.
 
-	/* binary search of the tag */
-	key.text = data;
-	key.size = i;
-	return bsearch(&key, block_tags,
-				sizeof block_tags / sizeof block_tags[0],
-				sizeof block_tags[0], cmp_html_tag);
+ * Right now we only consider spaces the actual
+ * space and a newline: tabs and carriage returns
+ * are filtered out during the preprocessing phase.
+ *
+ * If we wanted to actually be UTF-8 compliant, we
+ * should instead extract an Unicode codepoint from
+ * this character and check for space properties.
+ */
+static inline int
+_isspace(int c)
+{
+	return c == ' ' || c == '\n';
 }
 
 /****************************
@@ -242,7 +253,7 @@ find_block_tag(char *data, size_t size)
 /* is_mail_autolink • looks for the address part of a mail autolink and '>' */
 /* this is less strict than the original markdown e-mail address matching */
 static size_t
-is_mail_autolink(char *data, size_t size)
+is_mail_autolink(uint8_t *data, size_t size)
 {
 	size_t i = 0, nb = 0;
 
@@ -273,7 +284,7 @@ is_mail_autolink(char *data, size_t size)
 
 /* tag_length • returns the length of the given tag, or 0 is it's not valid */
 static size_t
-tag_length(char *data, size_t size, enum mkd_autolink *autolink)
+tag_length(uint8_t *data, size_t size, enum mkd_autolink *autolink)
 {
 	size_t i, j;
 
@@ -316,8 +327,9 @@ tag_length(char *data, size_t size, enum mkd_autolink *autolink)
 		while (i < size) {
 			if (data[i] == '\\') i += 2;
 			else if (data[i] == '>' || data[i] == '\'' ||
-					data[i] == '"' || isspace(data[i])) break;
-			else i += 1;
+					data[i] == '"' || data[i] == ' ' || data[i] == '\n')
+					break;
+			else i++;
 		}
 
 		if (i >= size) return 0;
@@ -327,33 +339,33 @@ tag_length(char *data, size_t size, enum mkd_autolink *autolink)
 	}
 
 	/* looking for sometinhg looking like a tag end */
-	while (i < size && data[i] != '>') i += 1;
+	while (i < size && data[i] != '>') i++;
 	if (i >= size) return 0;
 	return i + 1;
 }
 
 /* parse_inline • parses inline markdown elements */
 static void
-parse_inline(struct buf *ob, struct render *rndr, char *data, size_t size)
+parse_inline(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size)
 {
 	size_t i = 0, end = 0;
-	char action = 0;
-	struct buf work = { 0, 0, 0, 0, 0 };
+	uint8_t action = 0;
+	struct buf work = { 0, 0, 0, 0 };
 
 	if (rndr->work_bufs[BUFFER_SPAN].size +
-		rndr->work_bufs[BUFFER_BLOCK].size > (int)rndr->max_nesting)
+		rndr->work_bufs[BUFFER_BLOCK].size > rndr->max_nesting)
 		return;
 
 	while (i < size) {
 		/* copying inactive chars into the output */
-		while (end < size && (action = rndr->active_char[(unsigned char)data[end]]) == 0) {
+		while (end < size && (action = rndr->active_char[data[end]]) == 0) {
 			end++;
 		}
 
-		if (rndr->make.normal_text) {
+		if (rndr->cb.normal_text) {
 			work.data = data + i;
 			work.size = end - i;
-			rndr->make.normal_text(ob, &work, rndr->make.opaque);
+			rndr->cb.normal_text(ob, &work, rndr->opaque);
 		}
 		else
 			bufput(ob, data + i, end - i);
@@ -361,78 +373,117 @@ parse_inline(struct buf *ob, struct render *rndr, char *data, size_t size)
 		if (end >= size) break;
 		i = end;
 
-		/* calling the trigger */
 		end = markdown_char_ptrs[(int)action](ob, rndr, data + i, i, size - i);
 		if (!end) /* no action from the callback */
 			end = i + 1;
-		else { 
+		else {
 			i += end;
 			end = i;
-		} 
+		}
 	}
 }
 
-/* find_emph_char • looks for the next emph char, skipping other constructs */
+/* find_emph_char • looks for the next emph uint8_t, skipping other constructs */
 static size_t
-find_emph_char(char *data, size_t size, char c)
+find_emph_char(uint8_t *data, size_t size, uint8_t c)
 {
 	size_t i = 1;
 
 	while (i < size) {
-		while (i < size && data[i] != c
-		&& data[i] != '`' && data[i] != '[')
-			i += 1;
-		if (data[i] == c) return i;
+		while (i < size && data[i] != c && data[i] != '`' && data[i] != '[')
+			i++;
+
+		if (i == size)
+			return 0;
+
+		if (data[i] == c)
+			return i;
 
 		/* not counting escaped chars */
-		if (i && data[i - 1] == '\\') { i += 1; continue; }
+		if (i && data[i - 1] == '\\') {
+			i++; continue;
+		}
 
-		/* skipping a code span */
 		if (data[i] == '`') {
+			size_t span_nb = 0, bt;
 			size_t tmp_i = 0;
-			i += 1;
-			while (i < size && data[i] != '`') {
+
+			/* counting the number of opening backticks */
+			while (i < size && data[i] == '`') {
+				i++; span_nb++;
+			}
+
+			if (i >= size) return 0;
+
+			/* finding the matching closing sequence */
+			bt = 0;
+			while (i < size && bt < span_nb) {
 				if (!tmp_i && data[i] == c) tmp_i = i;
-				i += 1; }
-			if (i >= size) return tmp_i;
-			i += 1; }
+				if (data[i] == '`') bt++;
+				else bt = 0;
+				i++;
+			}
 
+			if (i >= size) return tmp_i;
+		}
 		/* skipping a link */
 		else if (data[i] == '[') {
 			size_t tmp_i = 0;
-			char cc;
-			i += 1;
+			uint8_t cc;
+
+			i++;
 			while (i < size && data[i] != ']') {
 				if (!tmp_i && data[i] == c) tmp_i = i;
-				i += 1; }
-			i += 1;
-			while (i < size && (data[i] == ' '
-			|| data[i] == '\t' || data[i] == '\n'))
-				i += 1;
-			if (i >= size) return tmp_i;
-			if (data[i] != '[' && data[i] != '(') { /* not a link*/
-				if (tmp_i) return tmp_i;
-				else continue; }
-			cc = data[i];
-			i += 1;
+				i++;
+			}
+
+			i++;
+			while (i < size && (data[i] == ' ' || data[i] == '\n'))
+				i++;
+
+			if (i >= size)
+				return tmp_i;
+
+			switch (data[i]) {
+			case '[':
+				cc = ']'; break;
+
+			case '(':
+				cc = ')'; break;
+
+			default:
+				if (tmp_i)
+					return tmp_i;
+				else
+					continue;
+			}
+
+			i++;
 			while (i < size && data[i] != cc) {
 				if (!tmp_i && data[i] == c) tmp_i = i;
-				i += 1; }
-			if (i >= size) return tmp_i;
-			i += 1; } }
+				i++;
+			}
+
+			if (i >= size)
+				return tmp_i;
+
+			i++;
+		}
+	}
+
 	return 0;
 }
 
 /* parse_emph1 • parsing single emphase */
 /* closed by a symbol not preceded by whitespace and not followed by symbol */
 static size_t
-parse_emph1(struct buf *ob, struct render *rndr, char *data, size_t size, char c)
+parse_emph1(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size, uint8_t c)
 {
 	size_t i = 0, len;
 	struct buf *work = 0;
 	int r;
 
-	if (!rndr->make.emphasis) return 0;
+	if (!rndr->cb.emphasis) return 0;
 
 	/* skipping one symbol if coming from emph3 */
 	if (size > 1 && data[0] == c && data[1] == c) i = 1;
@@ -443,21 +494,16 @@ parse_emph1(struct buf *ob, struct render *rndr, char *data, size_t size, char c
 		i += len;
 		if (i >= size) return 0;
 
-		if (i + 1 < size && data[i + 1] == c) {
-			i += 1;
-			continue;
-		}
-
-		if (data[i] == c && !isspace(data[i - 1])) {
+		if (data[i] == c && !_isspace(data[i - 1])) {
 
 			if (rndr->ext_flags & MKDEXT_NO_INTRA_EMPHASIS) {
-				if (!(i + 1 == size || isspace(data[i + 1]) || ispunct(data[i + 1])))
+				if (!(i + 1 == size || _isspace(data[i + 1]) || ispunct(data[i + 1])))
 					continue;
 			}
 
 			work = rndr_newbuf(rndr, BUFFER_SPAN);
 			parse_inline(work, rndr, data, i);
-			r = rndr->make.emphasis(ob, work, rndr->make.opaque);
+			r = rndr->cb.emphasis(ob, work, rndr->opaque);
 			rndr_popbuf(rndr, BUFFER_SPAN);
 			return r ? i + 1 : 0;
 		}
@@ -468,27 +514,27 @@ parse_emph1(struct buf *ob, struct render *rndr, char *data, size_t size, char c
 
 /* parse_emph2 • parsing single emphase */
 static size_t
-parse_emph2(struct buf *ob, struct render *rndr, char *data, size_t size, char c)
+parse_emph2(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size, uint8_t c)
 {
-	int (*render_method)(struct buf *ob, struct buf *text, void *opaque);
+	int (*render_method)(struct buf *ob, const struct buf *text, void *opaque);
 	size_t i = 0, len;
 	struct buf *work = 0;
 	int r;
 
-	render_method = (c == '~') ? rndr->make.strikethrough : rndr->make.double_emphasis;
+	render_method = (c == '~') ? rndr->cb.strikethrough : rndr->cb.double_emphasis;
 
 	if (!render_method)
 		return 0;
-	
+
 	while (i < size) {
 		len = find_emph_char(data + i, size - i, c);
 		if (!len) return 0;
 		i += len;
 
-		if (i + 1 < size && data[i] == c && data[i + 1] == c && i && !isspace(data[i - 1])) {
+		if (i + 1 < size && data[i] == c && data[i + 1] == c && i && !_isspace(data[i - 1])) {
 			work = rndr_newbuf(rndr, BUFFER_SPAN);
 			parse_inline(work, rndr, data, i);
-			r = render_method(ob, work, rndr->make.opaque);
+			r = render_method(ob, work, rndr->opaque);
 			rndr_popbuf(rndr, BUFFER_SPAN);
 			return r ? i + 2 : 0;
 		}
@@ -500,7 +546,7 @@ parse_emph2(struct buf *ob, struct render *rndr, char *data, size_t size, char c
 /* parse_emph3 • parsing single emphase */
 /* finds the first closing tag, and delegates to the other emph */
 static size_t
-parse_emph3(struct buf *ob, struct render *rndr, char *data, size_t size, char c)
+parse_emph3(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size, uint8_t c)
 {
 	size_t i = 0, len;
 	int r;
@@ -511,15 +557,15 @@ parse_emph3(struct buf *ob, struct render *rndr, char *data, size_t size, char c
 		i += len;
 
 		/* skip whitespace preceded symbols */
-		if (data[i] != c || isspace(data[i - 1]))
+		if (data[i] != c || _isspace(data[i - 1]))
 			continue;
 
-		if (i + 2 < size && data[i + 1] == c && data[i + 2] == c && rndr->make.triple_emphasis) {
+		if (i + 2 < size && data[i + 1] == c && data[i + 2] == c && rndr->cb.triple_emphasis) {
 			/* triple symbol found */
 			struct buf *work = rndr_newbuf(rndr, BUFFER_SPAN);
 
 			parse_inline(work, rndr, data, i);
-			r = rndr->make.triple_emphasis(ob, work, rndr->make.opaque);
+			r = rndr->cb.triple_emphasis(ob, work, rndr->opaque);
 			rndr_popbuf(rndr, BUFFER_SPAN);
 			return r ? i + 3 : 0;
 
@@ -536,46 +582,46 @@ parse_emph3(struct buf *ob, struct render *rndr, char *data, size_t size, char c
 			else return len - 1;
 		}
 	}
-	return 0; 
+	return 0;
 }
 
 /* char_emphasis • single and double emphasis parsing */
 static size_t
-char_emphasis(struct buf *ob, struct render *rndr, char *data, size_t offset, size_t size)
+char_emphasis(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size)
 {
-	char c = data[0];
+	uint8_t c = data[0];
 	size_t ret;
 
 	if (size > 2 && data[1] != c) {
 		/* whitespace cannot follow an opening emphasis;
 		 * strikethrough only takes two characters '~~' */
-		if (c == '~' || isspace(data[1]) || (ret = parse_emph1(ob, rndr, data + 1, size - 1, c)) == 0)
+		if (c == '~' || _isspace(data[1]) || (ret = parse_emph1(ob, rndr, data + 1, size - 1, c)) == 0)
 			return 0;
 
 		return ret + 1;
 	}
 
 	if (size > 3 && data[1] == c && data[2] != c) {
-		if (isspace(data[2]) || (ret = parse_emph2(ob, rndr, data + 2, size - 2, c)) == 0)
+		if (_isspace(data[2]) || (ret = parse_emph2(ob, rndr, data + 2, size - 2, c)) == 0)
 			return 0;
 
 		return ret + 2;
 	}
 
 	if (size > 4 && data[1] == c && data[2] == c && data[3] != c) {
-		if (c == '~' || isspace(data[3]) || (ret = parse_emph3(ob, rndr, data + 3, size - 3, c)) == 0)
+		if (c == '~' || _isspace(data[3]) || (ret = parse_emph3(ob, rndr, data + 3, size - 3, c)) == 0)
 			return 0;
 
 		return ret + 3;
 	}
 
-	return 0; 
+	return 0;
 }
 
 
 /* char_linebreak • '\n' preceded by two spaces (assuming linebreak != 0) */
 static size_t
-char_linebreak(struct buf *ob, struct render *rndr, char *data, size_t offset, size_t size)
+char_linebreak(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size)
 {
 	if (offset < 2 || data[-1] != ' ' || data[-2] != ' ')
 		return 0;
@@ -584,13 +630,13 @@ char_linebreak(struct buf *ob, struct render *rndr, char *data, size_t offset, s
 	while (ob->size && ob->data[ob->size - 1] == ' ')
 		ob->size--;
 
-	return rndr->make.linebreak(ob, rndr->make.opaque) ? 1 : 0;
+	return rndr->cb.linebreak(ob, rndr->opaque) ? 1 : 0;
 }
 
 
 /* char_codespan • '`' parsing a code span (assuming codespan != 0) */
 static size_t
-char_codespan(struct buf *ob, struct render *rndr, char *data, size_t offset, size_t size)
+char_codespan(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size)
 {
 	size_t end, nb = 0, i, f_begin, f_end;
 
@@ -610,20 +656,20 @@ char_codespan(struct buf *ob, struct render *rndr, char *data, size_t offset, si
 
 	/* trimming outside whitespaces */
 	f_begin = nb;
-	while (f_begin < end && (data[f_begin] == ' ' || data[f_begin] == '\t'))
+	while (f_begin < end && data[f_begin] == ' ')
 		f_begin++;
 
 	f_end = end - nb;
-	while (f_end > nb && (data[f_end-1] == ' ' || data[f_end-1] == '\t'))
+	while (f_end > nb && data[f_end-1] == ' ')
 		f_end--;
 
 	/* real code span */
 	if (f_begin < f_end) {
-		struct buf work = { data + f_begin, f_end - f_begin, 0, 0, 0 };
-		if (!rndr->make.codespan(ob, &work, rndr->make.opaque))
+		struct buf work = { data + f_begin, f_end - f_begin, 0, 0 };
+		if (!rndr->cb.codespan(ob, &work, rndr->opaque))
 			end = 0;
 	} else {
-		if (!rndr->make.codespan(ob, 0, rndr->make.opaque))
+		if (!rndr->cb.codespan(ob, 0, rndr->opaque))
 			end = 0;
 	}
 
@@ -633,19 +679,19 @@ char_codespan(struct buf *ob, struct render *rndr, char *data, size_t offset, si
 
 /* char_escape • '\\' backslash escape */
 static size_t
-char_escape(struct buf *ob, struct render *rndr, char *data, size_t offset, size_t size)
+char_escape(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size)
 {
-	static const char *escape_chars = "\\`*_{}[]()#+-.!:|&<>";
-	struct buf work = { 0, 0, 0, 0, 0 };
+	static const char *escape_chars = "\\`*_{}[]()#+-.!:|&<>^~";
+	struct buf work = { 0, 0, 0, 0 };
 
 	if (size > 1) {
 		if (strchr(escape_chars, data[1]) == NULL)
 			return 0;
 
-		if (rndr->make.normal_text) {
+		if (rndr->cb.normal_text) {
 			work.data = data + 1;
 			work.size = 1;
-			rndr->make.normal_text(ob, &work, rndr->make.opaque);
+			rndr->cb.normal_text(ob, &work, rndr->opaque);
 		}
 		else bufputc(ob, data[1]);
 	}
@@ -656,10 +702,10 @@ char_escape(struct buf *ob, struct render *rndr, char *data, size_t offset, size
 /* char_entity • '&' escaped when it doesn't belong to an entity */
 /* valid entities are assumed to be anything matching &#?[A-Za-z0-9]+; */
 static size_t
-char_entity(struct buf *ob, struct render *rndr, char *data, size_t offset, size_t size)
+char_entity(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size)
 {
 	size_t end = 1;
-	struct buf work;
+	struct buf work = { 0, 0, 0, 0 };
 
 	if (end < size && data[end] == '#')
 		end++;
@@ -668,14 +714,14 @@ char_entity(struct buf *ob, struct render *rndr, char *data, size_t offset, size
 		end++;
 
 	if (end < size && data[end] == ';')
-		end += 1; /* real entity */
+		end++; /* real entity */
 	else
 		return 0; /* lone '&' */
 
-	if (rndr->make.entity) {
+	if (rndr->cb.entity) {
 		work.data = data;
 		work.size = end;
-		rndr->make.entity(ob, &work, rndr->make.opaque);
+		rndr->cb.entity(ob, &work, rndr->opaque);
 	}
 	else bufput(ob, data, end);
 
@@ -684,24 +730,24 @@ char_entity(struct buf *ob, struct render *rndr, char *data, size_t offset, size
 
 /* char_langle_tag • '<' when tags or autolinks are allowed */
 static size_t
-char_langle_tag(struct buf *ob, struct render *rndr, char *data, size_t offset, size_t size)
+char_langle_tag(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size)
 {
 	enum mkd_autolink altype = MKDA_NOT_AUTOLINK;
 	size_t end = tag_length(data, size, &altype);
-	struct buf work = { data, end, 0, 0, 0 };
+	struct buf work = { data, end, 0, 0 };
 	int ret = 0;
 
 	if (end > 2) {
-		if (rndr->make.autolink && altype != MKDA_NOT_AUTOLINK) {
+		if (rndr->cb.autolink && altype != MKDA_NOT_AUTOLINK) {
 			struct buf *u_link = rndr_newbuf(rndr, BUFFER_SPAN);
 			work.data = data + 1;
 			work.size = end - 2;
 			unscape_text(u_link, &work);
-			ret = rndr->make.autolink(ob, u_link, altype, rndr->make.opaque);
+			ret = rndr->cb.autolink(ob, u_link, altype, rndr->opaque);
 			rndr_popbuf(rndr, BUFFER_SPAN);
 		}
-		else if (rndr->make.raw_html_tag)
-			ret = rndr->make.raw_html_tag(ob, &work, rndr->make.opaque);
+		else if (rndr->cb.raw_html_tag)
+			ret = rndr->cb.raw_html_tag(ob, &work, rndr->opaque);
 	}
 
 	if (!ret) return 0;
@@ -709,23 +755,30 @@ char_langle_tag(struct buf *ob, struct render *rndr, char *data, size_t offset,
 }
 
 static size_t
-char_autolink_www(struct buf *ob, struct render *rndr, char *data, size_t offset, size_t size)
+char_autolink_www(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size)
 {
-	struct buf *link, *link_url;
+	struct buf *link, *link_url, *link_text;
 	size_t link_len, rewind;
 
-	if (!rndr->make.link)
+	if (!rndr->cb.link || rndr->in_link_body)
 		return 0;
 
 	link = rndr_newbuf(rndr, BUFFER_SPAN);
 
-	if ((link_len = ups_autolink__www(&rewind, link, data, offset, size)) > 0) {
+	if ((link_len = sd_autolink__www(&rewind, link, data, offset, size)) > 0) {
 		link_url = rndr_newbuf(rndr, BUFFER_SPAN);
 		BUFPUTSL(link_url, "http://");
 		bufput(link_url, link->data, link->size);
 
 		ob->size -= rewind;
-		rndr->make.link(ob, link_url, NULL, link, rndr->make.opaque);
+		if (rndr->cb.normal_text) {
+			link_text = rndr_newbuf(rndr, BUFFER_SPAN);
+			rndr->cb.normal_text(link_text, link, rndr->opaque);
+			rndr->cb.link(ob, link_url, NULL, link_text, rndr->opaque);
+			rndr_popbuf(rndr, BUFFER_SPAN);
+		} else {
+			rndr->cb.link(ob, link_url, NULL, link, rndr->opaque);
+		}
 		rndr_popbuf(rndr, BUFFER_SPAN);
 	}
 
@@ -734,19 +787,19 @@ char_autolink_www(struct buf *ob, struct render *rndr, char *data, size_t offset
 }
 
 static size_t
-char_autolink_email(struct buf *ob, struct render *rndr, char *data, size_t offset, size_t size)
+char_autolink_email(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size)
 {
 	struct buf *link;
 	size_t link_len, rewind;
 
-	if (!rndr->make.autolink)
+	if (!rndr->cb.autolink || rndr->in_link_body)
 		return 0;
 
 	link = rndr_newbuf(rndr, BUFFER_SPAN);
 
-	if ((link_len = ups_autolink__email(&rewind, link, data, offset, size)) > 0) {
+	if ((link_len = sd_autolink__email(&rewind, link, data, offset, size)) > 0) {
 		ob->size -= rewind;
-		rndr->make.autolink(ob, link, MKDA_EMAIL, rndr->make.opaque);
+		rndr->cb.autolink(ob, link, MKDA_EMAIL, rndr->opaque);
 	}
 
 	rndr_popbuf(rndr, BUFFER_SPAN);
@@ -754,19 +807,19 @@ char_autolink_email(struct buf *ob, struct render *rndr, char *data, size_t offs
 }
 
 static size_t
-char_autolink_url(struct buf *ob, struct render *rndr, char *data, size_t offset, size_t size)
+char_autolink_url(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size)
 {
 	struct buf *link;
 	size_t link_len, rewind;
 
-	if (!rndr->make.autolink)
+	if (!rndr->cb.autolink || rndr->in_link_body)
 		return 0;
 
 	link = rndr_newbuf(rndr, BUFFER_SPAN);
 
-	if ((link_len = ups_autolink__url(&rewind, link, data, offset, size)) > 0) {
+	if ((link_len = sd_autolink__url(&rewind, link, data, offset, size)) > 0) {
 		ob->size -= rewind;
-		rndr->make.autolink(ob, link, MKDA_NORMAL, rndr->make.opaque);
+		rndr->cb.autolink(ob, link, MKDA_NORMAL, rndr->opaque);
 	}
 
 	rndr_popbuf(rndr, BUFFER_SPAN);
@@ -775,7 +828,7 @@ char_autolink_url(struct buf *ob, struct render *rndr, char *data, size_t offset
 
 /* char_link • '[': parsing a link or an image */
 static size_t
-char_link(struct buf *ob, struct render *rndr, char *data, size_t offset, size_t size)
+char_link(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size)
 {
 	int is_img = (offset && data[-1] == '!'), level;
 	size_t i = 1, txt_e, link_b = 0, link_e = 0, title_b = 0, title_e = 0;
@@ -785,13 +838,14 @@ char_link(struct buf *ob, struct render *rndr, char *data, size_t offset, size_t
 	struct buf *u_link = 0;
 	size_t org_work_size = rndr->work_bufs[BUFFER_SPAN].size;
 	int text_has_nl = 0, ret = 0;
+	int in_title = 0, qtype = 0;
 
 	/* checking whether the correct renderer exists */
-	if ((is_img && !rndr->make.image) || (!is_img && !rndr->make.link))
+	if ((is_img && !rndr->cb.image) || (!is_img && !rndr->cb.link))
 		goto cleanup;
 
 	/* looking for the matching closing bracket */
-	for (level = 1; i < size; i += 1) {
+	for (level = 1; i < size; i++) {
 		if (data[i] == '\n')
 			text_has_nl = 1;
 
@@ -812,19 +866,19 @@ char_link(struct buf *ob, struct render *rndr, char *data, size_t offset, size_t
 		goto cleanup;
 
 	txt_e = i;
-	i += 1;
+	i++;
 
 	/* skip any amount of whitespace or newline */
 	/* (this is much more laxist than original markdown syntax) */
-	while (i < size && isspace(data[i]))
+	while (i < size && _isspace(data[i]))
 		i++;
 
 	/* inline style link */
 	if (i < size && data[i] == '(') {
 		/* skipping initial whitespace */
-		i += 1;
+		i++;
 
-		while (i < size && isspace(data[i]))
+		while (i < size && _isspace(data[i]))
 			i++;
 
 		link_b = i;
@@ -833,7 +887,7 @@ char_link(struct buf *ob, struct render *rndr, char *data, size_t offset, size_t
 		while (i < size) {
 			if (data[i] == '\\') i += 2;
 			else if (data[i] == ')' || data[i] == '\'' || data[i] == '"') break;
-			else i += 1;
+			else i++;
 		}
 
 		if (i >= size) goto cleanup;
@@ -841,20 +895,23 @@ char_link(struct buf *ob, struct render *rndr, char *data, size_t offset, size_t
 
 		/* looking for title end if present */
 		if (data[i] == '\'' || data[i] == '"') {
+			qtype = data[i];
+			in_title = 1;
 			i++;
 			title_b = i;
 
 			while (i < size) {
 				if (data[i] == '\\') i += 2;
-				else if (data[i] == ')') break;
-				else i += 1;
+				else if (data[i] == qtype) {in_title = 0; i++;}
+				else if ((data[i] == ')') && !in_title) break;
+				else i++;
 			}
 
 			if (i >= size) goto cleanup;
 
 			/* skipping whitespaces after title */
 			title_e = i - 1;
-			while (title_e > title_b && isspace(data[title_e]))
+			while (title_e > title_b && _isspace(data[title_e]))
 				title_e--;
 
 			/* checking for closing quote presence */
@@ -865,7 +922,7 @@ char_link(struct buf *ob, struct render *rndr, char *data, size_t offset, size_t
 		}
 
 		/* remove whitespace at the end of the link */
-		while (link_e > link_b && isspace(data[link_e - 1]))
+		while (link_e > link_b && _isspace(data[link_e - 1]))
 			link_e--;
 
 		/* remove optional angle brackets around the link */
@@ -888,11 +945,11 @@ char_link(struct buf *ob, struct render *rndr, char *data, size_t offset, size_t
 
 	/* reference style link */
 	else if (i < size && data[i] == '[') {
-		struct buf id = { 0, 0, 0, 0, 0 };
+		struct buf id = { 0, 0, 0, 0 };
 		struct link_ref *lr;
 
 		/* looking for the id */
-		i += 1;
+		i++;
 		link_b = i;
 		while (i < size && data[i] != ']') i++;
 		if (i >= size) goto cleanup;
@@ -922,18 +979,19 @@ char_link(struct buf *ob, struct render *rndr, char *data, size_t offset, size_t
 			id.size = link_e - link_b;
 		}
 
-		lr = arr_sorted_find(&rndr->refs, &id, cmp_link_ref);
-		if (!lr) goto cleanup;
+		lr = find_link_ref(rndr->refs, id.data, id.size);
+		if (!lr)
+			goto cleanup;
 
 		/* keeping link and title from link_ref */
 		link = lr->link;
 		title = lr->title;
-		i += 1;
+		i++;
 	}
 
 	/* shortcut reference style link */
 	else {
-		struct buf id = { 0, 0, 0, 0, 0 };
+		struct buf id = { 0, 0, 0, 0 };
 		struct link_ref *lr;
 
 		/* crafting the id */
@@ -956,8 +1014,9 @@ char_link(struct buf *ob, struct render *rndr, char *data, size_t offset, size_t
 		}
 
 		/* finding the link_ref */
-		lr = arr_sorted_find(&rndr->refs, &id, cmp_link_ref);
-		if (!lr) goto cleanup;
+		lr = find_link_ref(rndr->refs, id.data, id.size);
+		if (!lr)
+			goto cleanup;
 
 		/* keeping link and title from link_ref */
 		link = lr->link;
@@ -970,8 +1029,15 @@ char_link(struct buf *ob, struct render *rndr, char *data, size_t offset, size_t
 	/* building content: img alt is escaped, link content is parsed */
 	if (txt_e > 1) {
 		content = rndr_newbuf(rndr, BUFFER_SPAN);
-		if (is_img) bufput(content, data + 1, txt_e - 1);
-		else parse_inline(content, rndr, data + 1, txt_e - 1);
+		if (is_img) {
+			bufput(content, data + 1, txt_e - 1);
+		} else {
+			/* disable autolinking when parsing inline the
+			 * content of a link */
+			rndr->in_link_body = 1;
+			parse_inline(content, rndr, data + 1, txt_e - 1);
+			rndr->in_link_body = 0;
+		}
 	}
 
 	if (link) {
@@ -984,9 +1050,9 @@ char_link(struct buf *ob, struct render *rndr, char *data, size_t offset, size_t
 		if (ob->size && ob->data[ob->size - 1] == '!')
 			ob->size -= 1;
 
-		ret = rndr->make.image(ob, u_link, title, content, rndr->make.opaque);
+		ret = rndr->cb.image(ob, u_link, title, content, rndr->opaque);
 	} else {
-		ret = rndr->make.link(ob, u_link, title, content, rndr->make.opaque);
+		ret = rndr->cb.link(ob, u_link, title, content, rndr->opaque);
 	}
 
 	/* cleanup */
@@ -995,7 +1061,43 @@ cleanup:
 	return ret ? i : 0;
 }
 
+static size_t
+char_superscript(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t offset, size_t size)
+{
+	size_t sup_start, sup_len;
+	struct buf *sup;
+
+	if (!rndr->cb.superscript)
+		return 0;
+
+	if (size < 2)
+		return 0;
+
+	if (data[1] == '(') {
+		sup_start = sup_len = 2;
 
+		while (sup_len < size && data[sup_len] != ')' && data[sup_len - 1] != '\\')
+			sup_len++;
+
+		if (sup_len == size)
+			return 0;
+	} else {
+		sup_start = sup_len = 1;
+
+		while (sup_len < size && !_isspace(data[sup_len]))
+			sup_len++;
+	}
+
+	if (sup_len - sup_start == 0)
+		return (sup_start == 2) ? 3 : 0;
+
+	sup = rndr_newbuf(rndr, BUFFER_SPAN);
+	parse_inline(sup, rndr, data + sup_start, sup_len - sup_start);
+	rndr->cb.superscript(ob, sup, rndr->opaque);
+	rndr_popbuf(rndr, BUFFER_SPAN);
+
+	return (sup_start == 2) ? sup_len + 1 : sup_len;
+}
 
 /*********************************
  * BLOCK-LEVEL PARSING FUNCTIONS *
@@ -1003,28 +1105,31 @@ cleanup:
 
 /* is_empty • returns the line length when it is empty, 0 otherwise */
 static size_t
-is_empty(char *data, size_t size)
+is_empty(uint8_t *data, size_t size)
 {
 	size_t i;
-	for (i = 0; i < size && data[i] != '\n'; i += 1)
-		if (data[i] != ' ' && data[i] != '\t') return 0;
+
+	for (i = 0; i < size && data[i] != '\n'; i++)
+		if (data[i] != ' ')
+			return 0;
+
 	return i + 1;
 }
 
 /* is_hrule • returns whether a line is a horizontal rule */
 static int
-is_hrule(char *data, size_t size)
+is_hrule(uint8_t *data, size_t size)
 {
 	size_t i = 0, n = 0;
-	char c;
+	uint8_t c;
 
 	/* skipping initial spaces */
 	if (size < 3) return 0;
-	if (data[0] == ' ') { i += 1;
-	if (data[1] == ' ') { i += 1;
-	if (data[2] == ' ') { i += 1; } } }
+	if (data[0] == ' ') { i++;
+	if (data[1] == ' ') { i++;
+	if (data[2] == ' ') { i++; } } }
 
-	/* looking at the hrule char */
+	/* looking at the hrule uint8_t */
 	if (i + 2 >= size
 	|| (data[i] != '*' && data[i] != '-' && data[i] != '_'))
 		return 0;
@@ -1032,34 +1137,36 @@ is_hrule(char *data, size_t size)
 
 	/* the whole line must be the char or whitespace */
 	while (i < size && data[i] != '\n') {
-		if (data[i] == c) n += 1;
-		else if (data[i] != ' ' && data[i] != '\t')
+		if (data[i] == c) n++;
+		else if (data[i] != ' ')
 			return 0;
-		i += 1; }
+
+		i++;
+	}
 
 	return n >= 3;
 }
 
 /* check if a line is a code fence; return its size if it is */
 static size_t
-is_codefence(char *data, size_t size, struct buf *syntax)
+is_codefence(uint8_t *data, size_t size, struct buf *syntax)
 {
 	size_t i = 0, n = 0;
-	char c;
+	uint8_t c;
 
 	/* skipping initial spaces */
 	if (size < 3) return 0;
-	if (data[0] == ' ') { i += 1;
-	if (data[1] == ' ') { i += 1;
-	if (data[2] == ' ') { i += 1; } } }
+	if (data[0] == ' ') { i++;
+	if (data[1] == ' ') { i++;
+	if (data[2] == ' ') { i++; } } }
 
-	/* looking at the hrule char */
+	/* looking at the hrule uint8_t */
 	if (i + 2 >= size || !(data[i] == '~' || data[i] == '`'))
 		return 0;
 
 	c = data[i];
 
-	/* the whole line must be the char or whitespace */
+	/* the whole line must be the uint8_t or whitespace */
 	while (i < size && data[i] == c) {
 		n++; i++;
 	}
@@ -1070,7 +1177,7 @@ is_codefence(char *data, size_t size, struct buf *syntax)
 	if (syntax != NULL) {
 		size_t syn = 0;
 
-		while (i < size && (data[i] == ' ' || data[i] == '\t'))
+		while (i < size && data[i] == ' ')
 			i++;
 
 		syntax->data = data + i;
@@ -1087,16 +1194,16 @@ is_codefence(char *data, size_t size, struct buf *syntax)
 
 			/* strip all whitespace at the beginning and the end
 			 * of the {} block */
-			while (syn > 0 && isspace(syntax->data[0])) {
+			while (syn > 0 && _isspace(syntax->data[0])) {
 				syntax->data++; syn--;
 			}
 
-			while (syn > 0 && isspace(syntax->data[syn - 1]))
+			while (syn > 0 && _isspace(syntax->data[syn - 1]))
 				syn--;
 
 			i++;
 		} else {
-			while (i < size && !isspace(data[i])) {
+			while (i < size && !_isspace(data[i])) {
 				syn++; i++;
 			}
 		}
@@ -1105,7 +1212,7 @@ is_codefence(char *data, size_t size, struct buf *syntax)
 	}
 
 	while (i < size && data[i] != '\n') {
-		if (!isspace(data[i]))
+		if (!_isspace(data[i]))
 			return 0;
 
 		i++;
@@ -1116,7 +1223,7 @@ is_codefence(char *data, size_t size, struct buf *syntax)
 
 /* is_atxheader • returns whether the line is a hash-prefixed header */
 static int
-is_atxheader(struct render *rndr, char *data, size_t size)
+is_atxheader(struct sd_markdown *rndr, uint8_t *data, size_t size)
 {
 	if (data[0] != '#')
 		return 0;
@@ -1127,7 +1234,7 @@ is_atxheader(struct render *rndr, char *data, size_t size)
 		while (level < size && level < 6 && data[level] == '#')
 			level++;
 
-		if (level < size && data[level] != ' ' && data[level] != '\t')
+		if (level < size && data[level] != ' ')
 			return 0;
 	}
 
@@ -1136,92 +1243,126 @@ is_atxheader(struct render *rndr, char *data, size_t size)
 
 /* is_headerline • returns whether the line is a setext-style hdr underline */
 static int
-is_headerline(char *data, size_t size)
+is_headerline(uint8_t *data, size_t size)
 {
 	size_t i = 0;
 
 	/* test of level 1 header */
 	if (data[i] == '=') {
-		for (i = 1; i < size && data[i] == '='; i += 1);
-		while (i < size && (data[i] == ' ' || data[i] == '\t')) i += 1;
+		for (i = 1; i < size && data[i] == '='; i++);
+		while (i < size && data[i] == ' ') i++;
 		return (i >= size || data[i] == '\n') ? 1 : 0; }
 
 	/* test of level 2 header */
 	if (data[i] == '-') {
-		for (i = 1; i < size && data[i] == '-'; i += 1);
-		while (i < size && (data[i] == ' ' || data[i] == '\t')) i += 1;
+		for (i = 1; i < size && data[i] == '-'; i++);
+		while (i < size && data[i] == ' ') i++;
 		return (i >= size || data[i] == '\n') ? 2 : 0; }
 
 	return 0;
 }
 
+static int
+is_next_headerline(uint8_t *data, size_t size)
+{
+	size_t i = 0;
+
+	while (i < size && data[i] != '\n')
+		i++;
+
+	if (++i >= size)
+		return 0;
+
+	return is_headerline(data + i, size - i);
+}
+
 /* prefix_quote • returns blockquote prefix length */
 static size_t
-prefix_quote(char *data, size_t size)
+prefix_quote(uint8_t *data, size_t size)
 {
 	size_t i = 0;
-	if (i < size && data[i] == ' ') i += 1;
-	if (i < size && data[i] == ' ') i += 1;
-	if (i < size && data[i] == ' ') i += 1;
+	if (i < size && data[i] == ' ') i++;
+	if (i < size && data[i] == ' ') i++;
+	if (i < size && data[i] == ' ') i++;
+
 	if (i < size && data[i] == '>') {
-		if (i + 1 < size && (data[i + 1] == ' ' || data[i+1] == '\t'))
+		if (i + 1 < size && data[i + 1] == ' ')
 			return i + 2;
-		else return i + 1; }
-	else return 0;
+
+		return i + 1;
+	}
+
+	return 0;
 }
 
 /* prefix_code • returns prefix length for block code*/
 static size_t
-prefix_code(char *data, size_t size)
+prefix_code(uint8_t *data, size_t size)
 {
-	if (size > 0 && data[0] == '\t') return 1;
 	if (size > 3 && data[0] == ' ' && data[1] == ' '
-			&& data[2] == ' ' && data[3] == ' ') return 4;
+		&& data[2] == ' ' && data[3] == ' ') return 4;
+
 	return 0;
 }
 
 /* prefix_oli • returns ordered list item prefix */
 static size_t
-prefix_oli(char *data, size_t size)
+prefix_oli(uint8_t *data, size_t size)
 {
 	size_t i = 0;
-	if (i < size && data[i] == ' ') i += 1;
-	if (i < size && data[i] == ' ') i += 1;
-	if (i < size && data[i] == ' ') i += 1;
-	if (i >= size || data[i] < '0' || data[i] > '9') return 0;
-	while (i < size && data[i] >= '0' && data[i] <= '9') i += 1;
-	if (i + 1 >= size || data[i] != '.'
-	|| (data[i + 1] != ' ' && data[i + 1] != '\t')) return 0;
+
+	if (i < size && data[i] == ' ') i++;
+	if (i < size && data[i] == ' ') i++;
+	if (i < size && data[i] == ' ') i++;
+
+	if (i >= size || data[i] < '0' || data[i] > '9')
+		return 0;
+
+	while (i < size && data[i] >= '0' && data[i] <= '9')
+		i++;
+
+	if (i + 1 >= size || data[i] != '.' || data[i + 1] != ' ')
+		return 0;
+
+	if (is_next_headerline(data + i, size - i))
+		return 0;
+
 	return i + 2;
 }
 
 /* prefix_uli • returns ordered list item prefix */
 static size_t
-prefix_uli(char *data, size_t size)
+prefix_uli(uint8_t *data, size_t size)
 {
 	size_t i = 0;
-	if (i < size && data[i] == ' ') i += 1;
-	if (i < size && data[i] == ' ') i += 1;
-	if (i < size && data[i] == ' ') i += 1;
-	if (i + 1 >= size
-	|| (data[i] != '*' && data[i] != '+' && data[i] != '-')
-	|| (data[i + 1] != ' ' && data[i + 1] != '\t'))
+
+	if (i < size && data[i] == ' ') i++;
+	if (i < size && data[i] == ' ') i++;
+	if (i < size && data[i] == ' ') i++;
+
+	if (i + 1 >= size ||
+		(data[i] != '*' && data[i] != '+' && data[i] != '-') ||
+		data[i + 1] != ' ')
 		return 0;
+
+	if (is_next_headerline(data + i, size - i))
+		return 0;
+
 	return i + 2;
 }
 
 
-/* parse_block • parsing of one block, returning next char to parse */
-static void parse_block(struct buf *ob, struct render *rndr,
-			char *data, size_t size);
+/* parse_block • parsing of one block, returning next uint8_t to parse */
+static void parse_block(struct buf *ob, struct sd_markdown *rndr,
+			uint8_t *data, size_t size);
 
 
 /* parse_blockquote • handles parsing of a blockquote fragment */
 static size_t
-parse_blockquote(struct buf *ob, struct render *rndr, char *data, size_t size)
+parse_blockquote(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size)
 {
 	size_t beg, end = 0, pre, work_size = 0;
-	char *work_data = 0;
+	uint8_t *work_data = 0;
 	struct buf *out = 0;
 
 	out = rndr_newbuf(rndr, BUFFER_BLOCK);
@@ -1252,22 +1393,22 @@ parse_blockquote(struct buf *ob, struct render *rndr, char *data, size_t size)
 	}
 
 	parse_block(out, rndr, work_data, work_size);
-	if (rndr->make.blockquote)
-		rndr->make.blockquote(ob, out, rndr->make.opaque);
+	if (rndr->cb.blockquote)
+		rndr->cb.blockquote(ob, out, rndr->opaque);
 	rndr_popbuf(rndr, BUFFER_BLOCK);
 	return end;
 }
 
 static size_t
-parse_htmlblock(struct buf *ob, struct render *rndr, char *data, size_t size, int do_render);
+parse_htmlblock(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size, int do_render);
 
 /* parse_blockquote • handles parsing of a regular paragraph */
 static size_t
-parse_paragraph(struct buf *ob, struct render *rndr, char *data, size_t size)
+parse_paragraph(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size)
 {
 	size_t i = 0, end = 0;
 	int level = 0;
-	struct buf work = { data, 0, 0, 0, 0 }; /* volatile working buffer */
+	struct buf work = { data, 0, 0, 0 };
 
 	while (i < size) {
 		for (end = i + 1; end < size && data[end - 1] != '\n'; end++) /* empty */;
@@ -1276,7 +1417,7 @@ parse_paragraph(struct buf *ob, struct render *rndr, char *data, size_t size)
 			break;
 
 		if (rndr->ext_flags & MKDEXT_LAX_HTML_BLOCKS) {
-			if (data[i] == '<' && rndr->make.blockhtml && parse_htmlblock(ob, rndr, data + i, size - i, 0)) {
+			if (data[i] == '<' && rndr->cb.blockhtml && parse_htmlblock(ob, rndr, data + i, size - i, 0)) {
 				end = i;
 				break;
 			}
@@ -1297,8 +1438,8 @@ parse_paragraph(struct buf *ob, struct render *rndr, char *data, size_t size)
 	if (!level) {
 		struct buf *tmp = rndr_newbuf(rndr, BUFFER_BLOCK);
 		parse_inline(tmp, rndr, work.data, work.size);
-		if (rndr->make.paragraph)
-			rndr->make.paragraph(ob, tmp, rndr->make.opaque);
+		if (rndr->cb.paragraph)
+			rndr->cb.paragraph(ob, tmp, rndr->opaque);
 		rndr_popbuf(rndr, BUFFER_BLOCK);
 	} else {
 		struct buf *header_work;
@@ -1319,8 +1460,8 @@ parse_paragraph(struct buf *ob, struct render *rndr, char *data, size_t size)
 				struct buf *tmp = rndr_newbuf(rndr, BUFFER_BLOCK);
 				parse_inline(tmp, rndr, work.data, work.size);
 
-				if (rndr->make.paragraph)
-					rndr->make.paragraph(ob, tmp, rndr->make.opaque);
+				if (rndr->cb.paragraph)
+					rndr->cb.paragraph(ob, tmp, rndr->opaque);
 
 				rndr_popbuf(rndr, BUFFER_BLOCK);
 				work.data += beg;
@@ -1332,8 +1473,8 @@ parse_paragraph(struct buf *ob, struct render *rndr, char *data, size_t size)
 		header_work = rndr_newbuf(rndr, BUFFER_SPAN);
 		parse_inline(header_work, rndr, work.data, work.size);
 
-		if (rndr->make.header)
-			rndr->make.header(ob, header_work, (int)level, rndr->make.opaque);
+		if (rndr->cb.header)
+			rndr->cb.header(ob, header_work, (int)level, rndr->opaque);
 
 		rndr_popbuf(rndr, BUFFER_SPAN);
 	}
@@ -1343,11 +1484,11 @@ parse_paragraph(struct buf *ob, struct render *rndr, char *data, size_t size)
 
 /* parse_fencedcode • handles parsing of a block-level code fragment */
 static size_t
-parse_fencedcode(struct buf *ob, struct render *rndr, char *data, size_t size)
+parse_fencedcode(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size)
 {
 	size_t beg, end;
 	struct buf *work = 0;
-	struct buf lang = { 0, 0, 0, 0, 0 };
+	struct buf lang = { 0, 0, 0, 0 };
 
 	beg = is_codefence(data, size, &lang);
 	if (beg == 0) return 0;
@@ -1363,7 +1504,7 @@ parse_fencedcode(struct buf *ob, struct render *rndr, char *data, size_t size)
 			break;
 		}
 
-		for (end = beg + 1; end < size && data[end - 1] != '\n'; end += 1);
+		for (end = beg + 1; end < size && data[end - 1] != '\n'; end++);
 
 		if (beg < end) {
 			/* verbatim copy to the working buffer,
@@ -1378,15 +1519,15 @@ parse_fencedcode(struct buf *ob, struct render *rndr, char *data, size_t size)
 	if (work->size && work->data[work->size - 1] != '\n')
 		bufputc(work, '\n');
 
-	if (rndr->make.blockcode)
-		rndr->make.blockcode(ob, work, lang.size ? &lang : NULL, rndr->make.opaque);
+	if (rndr->cb.blockcode)
+		rndr->cb.blockcode(ob, work, lang.size ? &lang : NULL, rndr->opaque);
 
 	rndr_popbuf(rndr, BUFFER_BLOCK);
 	return beg;
 }
 
 static size_t
-parse_blockcode(struct buf *ob, struct render *rndr, char *data, size_t size)
+parse_blockcode(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size)
 {
 	size_t beg, end, pre;
 	struct buf *work = 0;
@@ -1419,8 +1560,8 @@ parse_blockcode(struct buf *ob, struct render *rndr, char *data, size_t size)
 
 	bufputc(work, '\n');
 
-	if (rndr->make.blockcode)
-		rndr->make.blockcode(ob, work, NULL, rndr->make.opaque);
+	if (rndr->cb.blockcode)
+		rndr->cb.blockcode(ob, work, NULL, rndr->opaque);
 
 	rndr_popbuf(rndr, BUFFER_BLOCK);
 	return beg;
@@ -1429,11 +1570,12 @@ parse_blockcode(struct buf *ob, struct render *rndr, char *data, size_t size)
 /* parse_listitem • parsing of a single list item */
 /*	assuming initial prefix is already removed */
 static size_t
-parse_listitem(struct buf *ob, struct render *rndr, char *data, size_t size, int *flags)
+parse_listitem(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size, int *flags)
 {
 	struct buf *work = 0, *inter = 0;
 	size_t beg = 0, end, pre, sublist = 0, orgpre = 0, i;
 	int in_empty = 0, has_inside_empty = 0;
+	int has_next_uli, has_next_oli;
 
 	/* keeping track of the first indentation prefix */
 	while (orgpre < 3 && orgpre < size && data[orgpre] == ' ')
@@ -1479,12 +1621,21 @@ parse_listitem(struct buf *ob, struct render *rndr, char *data, size_t size, int
 			i++;
 
 		pre = i;
-		if (data[beg] == '\t') { i = 1; pre = 8; }
+
+		has_next_uli = prefix_uli(data + beg + i, end - beg - i);
+		has_next_oli = prefix_oli(data + beg + i, end - beg - i);
+
+		/* checking for ul/ol switch */
+		if (in_empty && (
+					((*flags & MKD_LIST_ORDERED) && has_next_uli) ||
+					(!(*flags & MKD_LIST_ORDERED) && has_next_oli)
+			)){
+			*flags |= MKD_LI_END;
+			break; /* the following item must have same list type */
+		}
 
 		/* checking for a new item */
-		if ((prefix_uli(data + beg + i, end - beg - i) &&
-			!is_hrule(data + beg + i, end - beg - i)) ||
-			prefix_oli(data + beg + i, end - beg - i)) {
+		if ((has_next_uli && !is_hrule(data + beg + i, end - beg - i)) || has_next_oli) {
 			if (in_empty)
 				has_inside_empty = 1;
 
@@ -1495,7 +1646,7 @@ parse_listitem(struct buf *ob, struct render *rndr, char *data, size_t size, int
 				sublist = work->size;
 		}
 		/* joining only indented stuff after empty lines */
-		else if (in_empty && i < 4 && data[beg] != '\t') {
+		else if (in_empty && i < 4) {
 				*flags |= MKD_LI_END;
 				break;
 		}
@@ -1519,7 +1670,7 @@ parse_listitem(struct buf *ob, struct render *rndr, char *data, size_t size, int
 		/* intermediate render of block li */
 		if (sublist && sublist < work->size) {
 			parse_block(inter, rndr, work->data, sublist);
-			parse_block(inter, rndr, work->data + sublist, work->size - sublist); 
+			parse_block(inter, rndr, work->data + sublist, work->size - sublist);
 		}
 		else
 			parse_block(inter, rndr, work->data, work->size);
@@ -1534,8 +1685,8 @@ parse_listitem(struct buf *ob, struct render *rndr, char *data, size_t size, int
 	}
 
 	/* render of li itself */
-	if (rndr->make.listitem)
-		rndr->make.listitem(ob, inter, *flags, rndr->make.opaque);
+	if (rndr->cb.listitem)
+		rndr->cb.listitem(ob, inter, *flags, rndr->opaque);
 
 	rndr_popbuf(rndr, BUFFER_SPAN);
 	rndr_popbuf(rndr, BUFFER_SPAN);
@@ -1545,7 +1696,7 @@ parse_listitem(struct buf *ob, struct render *rndr, char *data, size_t size, int
 
 /* parse_list • parsing ordered or unordered list block */
 static size_t
-parse_list(struct buf *ob, struct render *rndr, char *data, size_t size, int flags)
+parse_list(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size, int flags)
 {
 	struct buf *work = 0;
 	size_t i = 0, j;
@@ -1560,15 +1711,15 @@ parse_list(struct buf *ob, struct render *rndr, char *data, size_t size, int fla
 			break;
 	}
 
-	if (rndr->make.list)
-		rndr->make.list(ob, work, flags, rndr->make.opaque);
+	if (rndr->cb.list)
+		rndr->cb.list(ob, work, flags, rndr->opaque);
 	rndr_popbuf(rndr, BUFFER_BLOCK);
 	return i;
 }
 
 /* parse_atxheader • parsing of atx-style headers */
 static size_t
-parse_atxheader(struct buf *ob, struct render *rndr, char *data, size_t size)
+parse_atxheader(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size)
 {
 	size_t level = 0;
 	size_t i, end, skip;
@@ -1576,7 +1727,7 @@ parse_atxheader(struct buf *ob, struct render *rndr, char *data, size_t size)
 	while (level < size && level < 6 && data[level] == '#')
 		level++;
 
-	for (i = level; i < size && (data[i] == ' ' || data[i] == '\t'); i++);
+	for (i = level; i < size && data[i] == ' '; i++);
 
 	for (end = i; end < size && data[end] != '\n'; end++);
 	skip = end;
@@ -1584,7 +1735,7 @@ parse_atxheader(struct buf *ob, struct render *rndr, char *data, size_t size)
 	while (end && data[end - 1] == '#')
 		end--;
 
-	while (end && (data[end - 1] == ' ' || data[end - 1] == '\t'))
+	while (end && data[end - 1] == ' ')
 		end--;
 
 	if (end > i) {
@@ -1592,8 +1743,8 @@ parse_atxheader(struct buf *ob, struct render *rndr, char *data, size_t size)
 
 		parse_inline(work, rndr, data + i, end - i);
 
-		if (rndr->make.header)
-			rndr->make.header(ob, work, (int)level, rndr->make.opaque);
+		if (rndr->cb.header)
+			rndr->cb.header(ob, work, (int)level, rndr->opaque);
 
 		rndr_popbuf(rndr, BUFFER_SPAN);
 	}
@@ -1605,20 +1756,18 @@ parse_atxheader(struct buf *ob, struct render *rndr, char *data, size_t size)
 /* htmlblock_end • checking end of HTML block : </tag>[ \t]*\n[ \t*]\n */
 /*	returns the length on match, 0 otherwise */
 static size_t
-htmlblock_end(struct html_tag *tag, struct render *rndr, char *data, size_t size)
+htmlblock_end(const char *tag, size_t tag_len, struct sd_markdown *rndr, uint8_t *data, size_t size)
 {
 	size_t i, w;
 
-	/* assuming data[0] == '<' && data[1] == '/' already tested */
-
 	/* checking if tag is a match */
-	if (tag->size + 3 >= size
-	|| strncasecmp(data + 2, tag->text, tag->size)
-	|| data[tag->size + 2] != '>')
+	if (tag_len + 3 >= size ||
+		strncasecmp((char *)data + 2, tag, tag_len) != 0 ||
+		data[tag_len + 2] != '>')
 		return 0;
 
 	/* checking white lines */
-	i = tag->size + 3;
+	i = tag_len + 3;
 	w = 0;
 	if (i < size && (w = is_empty(data + i, size - i)) == 0)
 		return 0; /* non-blank after tag */
@@ -1639,16 +1788,23 @@ htmlblock_end(struct html_tag *tag, struct render *rndr, char *data, size_t size
 
 /* parse_htmlblock • parsing of inline HTML block */
 static size_t
-parse_htmlblock(struct buf *ob, struct render *rndr, char *data, size_t size, int do_render)
+parse_htmlblock(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size, int do_render)
 {
 	size_t i, j = 0;
-	struct html_tag *curtag;
+	const char *curtag = NULL;
 	int found;
-	struct buf work = { data, 0, 0, 0, 0 };
+	struct buf work = { data, 0, 0, 0 };
 
 	/* identification of the opening tag */
-	if (size < 2 || data[0] != '<') return 0;
-	curtag = find_block_tag(data + 1, size - 1);
+	if (size < 2 || data[0] != '<')
+		return 0;
+
+	i = 1;
+	while (i < size && data[i] != '>' && data[i] != ' ')
+		i++;
+
+	if (i < size)
+		curtag = find_block_tag((char *)data + 1, i - 1);
 
 	/* handling of special cases */
 	if (!curtag) {
@@ -1667,28 +1823,28 @@ parse_htmlblock(struct buf *ob, struct render *rndr, char *data, size_t size, in
 
 			if (j) {
 				work.size = i + j;
-				if (do_render && rndr->make.blockhtml)
-					rndr->make.blockhtml(ob, &work, rndr->make.opaque);
+				if (do_render && rndr->cb.blockhtml)
+					rndr->cb.blockhtml(ob, &work, rndr->opaque);
 				return work.size;
-			} 
+			}
 		}
 
 		/* HR, which is the only self-closing block tag considered */
 		if (size > 4 && (data[1] == 'h' || data[1] == 'H') && (data[2] == 'r' || data[2] == 'R')) {
 			i = 3;
 			while (i < size && data[i] != '>')
-				i += 1;
+				i++;
 
 			if (i + 1 < size) {
-				i += 1;
+				i++;
 				j = is_empty(data + i, size - i);
 				if (j) {
 					work.size = i + j;
-					if (do_render && rndr->make.blockhtml)
-						rndr->make.blockhtml(ob, &work, rndr->make.opaque);
+					if (do_render && rndr->cb.blockhtml)
+						rndr->cb.blockhtml(ob, &work, rndr->opaque);
 					return work.size;
 				}
-			} 
+			}
 		}
 
 		/* no special case recognised */
@@ -1702,42 +1858,53 @@ parse_htmlblock(struct buf *ob, struct render *rndr, char *data, size_t size, in
 
 	/* if not found, trying a second pass looking for indented match */
 	/* but not if tag is "ins" or "del" (following original Markdown.pl) */
-	if (curtag != INS_TAG && curtag != DEL_TAG) {
+	if (strcmp(curtag, "ins") != 0 && strcmp(curtag, "del") != 0) {
+		size_t tag_size = strlen(curtag);
 		i = 1;
 		while (i < size) {
 			i++;
 			while (i < size && !(data[i - 1] == '<' && data[i] == '/'))
 				i++;
 
-			if (i + 2 + curtag->size >= size)
+			if (i + 2 + tag_size >= size)
 				break;
 
-			j = htmlblock_end(curtag, rndr, data + i - 1, size - i + 1);
+			j = htmlblock_end(curtag, tag_size, rndr, data + i - 1, size - i + 1);
 
 			if (j) {
 				i += j - 1;
 				found = 1;
 				break;
 			}
-		} 
+		}
 	}
 
 	if (!found) return 0;
 
 	/* the end of the block has been found */
 	work.size = i;
-	if (do_render && rndr->make.blockhtml)
-		rndr->make.blockhtml(ob, &work, rndr->make.opaque);
+	if (do_render && rndr->cb.blockhtml)
+		rndr->cb.blockhtml(ob, &work, rndr->opaque);
 
 	return i;
 }
 
 static void
-parse_table_row(struct buf *ob, struct render *rndr, char *data, size_t size, size_t columns, int *col_data)
+parse_table_row(
+	struct buf *ob,
+	struct sd_markdown *rndr,
+	uint8_t *data,
+	size_t size,
+	size_t columns,
+	int *col_data,
+	int header_flag)
 {
 	size_t i = 0, col;
 	struct buf *row_work = 0;
 
+	if (!rndr->cb.table_cell || !rndr->cb.table_row)
+		return;
+
 	row_work = rndr_newbuf(rndr, BUFFER_SPAN);
 
 	if (i < size && data[i] == '|')
@@ -1749,7 +1916,7 @@ parse_table_row(struct buf *ob, struct render *rndr, char *data, size_t size, si
 
 		cell_work = rndr_newbuf(rndr, BUFFER_SPAN);
 
-		while (i < size && isspace(data[i]))
+		while (i < size && _isspace(data[i]))
 			i++;
 
 		cell_start = i;
@@ -1759,31 +1926,34 @@ parse_table_row(struct buf *ob, struct render *rndr, char *data, size_t size, si
 
 		cell_end = i - 1;
 
-		while (cell_end > cell_start && isspace(data[cell_end]))
+		while (cell_end > cell_start && _isspace(data[cell_end]))
 			cell_end--;
 
 		parse_inline(cell_work, rndr, data + cell_start, 1 + cell_end - cell_start);
-		if (rndr->make.table_cell)
-			rndr->make.table_cell(row_work, cell_work, col_data ? col_data[col] : 0, rndr->make.opaque);
+		rndr->cb.table_cell(row_work, cell_work, col_data[col] | header_flag, rndr->opaque);
 
 		rndr_popbuf(rndr, BUFFER_SPAN);
 		i++;
 	}
 
 	for (; col < columns; ++col) {
-		struct buf empty_cell = {0, 0, 0, 0, 0};
-		if (rndr->make.table_cell)
-			rndr->make.table_cell(row_work, &empty_cell, col_data ? col_data[col] : 0, rndr->make.opaque);
+		struct buf empty_cell = { 0, 0, 0, 0 };
+		rndr->cb.table_cell(row_work, &empty_cell, col_data[col] | header_flag, rndr->opaque);
 	}
 
-	if (rndr->make.table_row)
-		rndr->make.table_row(ob, row_work, rndr->make.opaque);
+	rndr->cb.table_row(ob, row_work, rndr->opaque);
 
 	rndr_popbuf(rndr, BUFFER_SPAN);
 }
 
 static size_t
-parse_table_header(struct buf *ob, struct render *rndr, char *data, size_t size, size_t *columns, int **column_data)
+parse_table_header(
+	struct buf *ob,
+	struct sd_markdown *rndr,
+	uint8_t *data,
+	size_t size,
+	size_t *columns,
+	int **column_data)
 {
 	int pipes;
 	size_t i = 0, col, header_end, under_end;
@@ -1819,7 +1989,7 @@ parse_table_header(struct buf *ob, struct render *rndr, char *data, size_t size,
 	for (col = 0; col < *columns && i < under_end; ++col) {
 		size_t dashes = 0;
 
-		while (i < under_end && (data[i] == ' ' || data[i] == '\t'))
+		while (i < under_end && data[i] == ' ')
 			i++;
 
 		if (data[i] == ':') {
@@ -1836,7 +2006,7 @@ parse_table_header(struct buf *ob, struct render *rndr, char *data, size_t size,
 			dashes++;
 		}
 
-		while (i < under_end && (data[i] == ' ' || data[i] == '\t'))
+		while (i < under_end && data[i] == ' ')
 			i++;
 
 		if (i < under_end && data[i] != '|')
@@ -1851,12 +2021,23 @@ parse_table_header(struct buf *ob, struct render *rndr, char *data, size_t size,
 	if (col < *columns)
 		return 0;
 
-	parse_table_row(ob, rndr, data, header_end, *columns, *column_data);
+	parse_table_row(
+		ob, rndr, data,
+		header_end,
+		*columns,
+		*column_data,
+		MKD_TABLE_HEADER
+	);
+
 	return under_end + 1;
 }
 
 static size_t
-parse_table(struct buf *ob, struct render *rndr, char *data, size_t size)
+parse_table(
+	struct buf *ob,
+	struct sd_markdown *rndr,
+	uint8_t *data,
+	size_t size)
 {
 	size_t i;
 
@@ -1887,12 +2068,20 @@ parse_table(struct buf *ob, struct render *rndr, char *data, size_t size)
 				break;
 			}
 
-			parse_table_row(body_work, rndr, data + row_start, i - row_start, columns, col_data);
+			parse_table_row(
+				body_work,
+				rndr,
+				data + row_start,
+				i - row_start,
+				columns,
+				col_data, 0
+			);
+
 			i++;
 		}
 
-		if (rndr->make.table)
-			rndr->make.table(ob, header_work, body_work, rndr->make.opaque);
+		if (rndr->cb.table)
+			rndr->cb.table(ob, header_work, body_work, rndr->opaque);
 	}
 
 	free(col_data);
@@ -1901,16 +2090,16 @@ parse_table(struct buf *ob, struct render *rndr, char *data, size_t size)
 	return i;
 }
 
-/* parse_block • parsing of one block, returning next char to parse */
+/* parse_block • parsing of one block, returning next uint8_t to parse */
 static void
-parse_block(struct buf *ob, struct render *rndr, char *data, size_t size)
+parse_block(struct buf *ob, struct sd_markdown *rndr, uint8_t *data, size_t size)
 {
 	size_t beg, end, i;
-	char *txt_data;
+	uint8_t *txt_data;
 	beg = 0;
 
 	if (rndr->work_bufs[BUFFER_SPAN].size +
-		rndr->work_bufs[BUFFER_BLOCK].size > (int)rndr->max_nesting)
+		rndr->work_bufs[BUFFER_BLOCK].size > rndr->max_nesting)
 		return;
 
 	while (beg < size) {
@@ -1920,7 +2109,7 @@ parse_block(struct buf *ob, struct render *rndr, char *data, size_t size)
 		if (is_atxheader(rndr, txt_data, end))
 			beg += parse_atxheader(ob, rndr, txt_data, end);
 
-		else if (data[beg] == '<' && rndr->make.blockhtml &&
+		else if (data[beg] == '<' && rndr->cb.blockhtml &&
 				(i = parse_htmlblock(ob, rndr, txt_data, end, 1)) != 0)
 			beg += i;
 
@@ -1928,8 +2117,8 @@ parse_block(struct buf *ob, struct render *rndr, char *data, size_t size)
 			beg += i;
 
 		else if (is_hrule(txt_data, end)) {
-			if (rndr->make.hrule)
-				rndr->make.hrule(ob, rndr->make.opaque);
+			if (rndr->cb.hrule)
+				rndr->cb.hrule(ob, rndr->opaque);
 
 			while (beg < size && data[beg] != '\n')
 				beg++;
@@ -1970,7 +2159,7 @@ parse_block(struct buf *ob, struct render *rndr, char *data, size_t size)
 
 /* is_ref • returns whether a line is a reference or not */
 static int
-is_ref(char *data, size_t beg, size_t end, size_t *last, struct array *refs)
+is_ref(const uint8_t *data, size_t beg, size_t end, size_t *last, struct link_ref **refs)
 {
 /*	int n; */
 	size_t i = 0;
@@ -1978,8 +2167,6 @@ is_ref(char *data, size_t beg, size_t end, size_t *last, struct array *refs)
 	size_t link_offset, link_end;
 	size_t title_offset, title_end;
 	size_t line_end;
-	struct link_ref *lr;
-/*	struct buf id = { 0, 0, 0, 0, 0 }; / * volatile buf for id search */
 
 	/* up to 3 optional leading spaces */
 	if (beg + 3 >= end) return 0;
@@ -1991,34 +2178,38 @@ is_ref(char *data, size_t beg, size_t end, size_t *last, struct array *refs)
 
 	/* id part: anything but a newline between brackets */
 	if (data[i] != '[') return 0;
-	i += 1;
+	i++;
 	id_offset = i;
 	while (i < end && data[i] != '\n' && data[i] != '\r' && data[i] != ']')
-		i += 1;
+		i++;
 	if (i >= end || data[i] != ']') return 0;
 	id_end = i;
 
 	/* spacer: colon (space | tab)* newline? (space | tab)* */
-	i += 1;
+	i++;
 	if (i >= end || data[i] != ':') return 0;
-	i += 1;
-	while (i < end && (data[i] == ' ' || data[i] == '\t')) i += 1;
+	i++;
+	while (i < end && data[i] == ' ') i++;
 	if (i < end && (data[i] == '\n' || data[i] == '\r')) {
-		i += 1;
-		if (i < end && data[i] == '\r' && data[i - 1] == '\n') i += 1; }
-	while (i < end && (data[i] == ' ' || data[i] == '\t')) i += 1;
+		i++;
+		if (i < end && data[i] == '\r' && data[i - 1] == '\n') i++; }
+	while (i < end && data[i] == ' ') i++;
 	if (i >= end) return 0;
 
 	/* link: whitespace-free sequence, optionally between angle brackets */
-	if (data[i] == '<') i += 1;
+	if (data[i] == '<')
+		i++;
+
 	link_offset = i;
-	while (i < end && data[i] != ' ' && data[i] != '\t'
-			&& data[i] != '\n' && data[i] != '\r') i += 1;
+
+	while (i < end && data[i] != ' ' && data[i] != '\n' && data[i] != '\r')
+		i++;
+
 	if (data[i - 1] == '>') link_end = i - 1;
 	else link_end = i;
 
 	/* optional spacer: (space | tab)* (newline | '\'' | '"' | '(' ) */
-	while (i < end && (data[i] == ' ' || data[i] == '\t')) i += 1;
+	while (i < end && data[i] == ' ') i++;
 	if (i < end && data[i] != '\n' && data[i] != '\r'
 			&& data[i] != '\'' && data[i] != '"' && data[i] != '(')
 		return 0;
@@ -2031,47 +2222,54 @@ is_ref(char *data, size_t beg, size_t end, size_t *last, struct array *refs)
 	/* optional (space|tab)* spacer after a newline */
 	if (line_end) {
 		i = line_end + 1;
-		while (i < end && (data[i] == ' ' || data[i] == '\t')) i += 1; }
+		while (i < end && data[i] == ' ') i++; }
 
 	/* optional title: any non-newline sequence enclosed in '"()
 					alone on its line */
 	title_offset = title_end = 0;
 	if (i + 1 < end
 	&& (data[i] == '\'' || data[i] == '"' || data[i] == '(')) {
-		i += 1;
+		i++;
 		title_offset = i;
 		/* looking for EOL */
-		while (i < end && data[i] != '\n' && data[i] != '\r') i += 1;
+		while (i < end && data[i] != '\n' && data[i] != '\r') i++;
 		if (i + 1 < end && data[i] == '\n' && data[i + 1] == '\r')
 			title_end = i + 1;
 		else	title_end = i;
 		/* stepping back */
 		i -= 1;
-		while (i > title_offset && (data[i] == ' ' || data[i] == '\t'))
+		while (i > title_offset && data[i] == ' ')
 			i -= 1;
 		if (i > title_offset
 		&& (data[i] == '\'' || data[i] == '"' || data[i] == ')')) {
 			line_end = title_end;
 			title_end = i; } }
-	if (!line_end) return 0; /* garbage after the link */
+
+	if (!line_end)
+		return 0; /* garbage after the link */
 
 	/* a valid ref has been found, filling-in return structures */
-	if (last) *last = line_end;
-	if (!refs) return 1;
-	lr = arr_item(refs, arr_newitem(refs));
-	lr->id = bufnew(id_end - id_offset);
-	bufput(lr->id, data + id_offset, id_end - id_offset);
-	lr->link = bufnew(link_end - link_offset);
-	bufput(lr->link, data + link_offset, link_end - link_offset);
-	if (title_end > title_offset) {
-		lr->title = bufnew(title_end - title_offset);
-		bufput(lr->title, data + title_offset,
-					title_end - title_offset); }
-	else lr->title = 0;
-	return 1; 
+	if (last)
+		*last = line_end;
+
+	if (refs) {
+		struct link_ref *ref;
+
+		ref = add_link_ref(refs, data + id_offset, id_end - id_offset);
+
+		ref->link = bufnew(link_end - link_offset);
+		bufput(ref->link, data + link_offset, link_end - link_offset);
+
+		if (title_end > title_offset) {
+			ref->title = bufnew(title_end - title_offset);
+			bufput(ref->title, data + title_offset, title_end - title_offset);
+		}
+	}
+
+	return 1;
 }
 
-static void expand_tabs(struct buf *ob, const char *line, size_t size)
+static void expand_tabs(struct buf *ob, const uint8_t *line, size_t size)
 {
 	size_t  i = 0, tab = 0;
 
@@ -2100,132 +2298,153 @@ static void expand_tabs(struct buf *ob, const char *line, size_t size)
  * EXPORTED FUNCTIONS *
  **********************/
 
-/* markdown • parses the input buffer and renders it into the output buffer */
-void
-ups_markdown(struct buf *ob, struct buf *ib, const struct mkd_renderer *rndrer, unsigned int extensions) {
-	struct link_ref *lr;
-	struct buf *text;
-	size_t i, beg, end;
-	struct render rndr;
+struct sd_markdown *
+sd_markdown_new(
+	unsigned int extensions,
+	size_t max_nesting,
+	const struct sd_callbacks *callbacks,
+	void *opaque)
+{
+	struct sd_markdown *md = NULL;
 
-	/* filling the render structure */
-	if (!rndrer)
-		return;
+	assert(max_nesting > 0 && callbacks);
 
-	text = bufnew(64);
-	if (!text)
-		return;
+	md = malloc(sizeof(struct sd_markdown));
+	if (!md)
+		return NULL;
 
-	/* Preallocate enough space for our buffer to avoid expanding while copying */
-	bufgrow(text, ib->size);
+	memcpy(&md->cb, callbacks, sizeof(struct sd_callbacks));
 
-	memcpy(&rndr.make, rndrer, sizeof(struct mkd_renderer));
-	arr_init(&rndr.refs, sizeof (struct link_ref));
-	parr_init(&rndr.work_bufs[BUFFER_BLOCK]);
-	parr_init(&rndr.work_bufs[BUFFER_SPAN]);
+	stack_init(&md->work_bufs[BUFFER_BLOCK], 4);
+	stack_init(&md->work_bufs[BUFFER_SPAN], 8);
 
-	for (i = 0; i < 256; i += 1)
-		rndr.active_char[i] = 0;
+	memset(md->active_char, 0x0, 256);
 
-	if (rndr.make.emphasis || rndr.make.double_emphasis || rndr.make.triple_emphasis) {
-		rndr.active_char['*'] = MD_CHAR_EMPHASIS;
-		rndr.active_char['_'] = MD_CHAR_EMPHASIS;
+	if (md->cb.emphasis || md->cb.double_emphasis || md->cb.triple_emphasis) {
+		md->active_char['*'] = MD_CHAR_EMPHASIS;
+		md->active_char['_'] = MD_CHAR_EMPHASIS;
 		if (extensions & MKDEXT_STRIKETHROUGH)
-			rndr.active_char['~'] = MD_CHAR_EMPHASIS;
+			md->active_char['~'] = MD_CHAR_EMPHASIS;
 	}
 
-	if (rndr.make.codespan)
-		rndr.active_char['`'] = MD_CHAR_CODESPAN;
+	if (md->cb.codespan)
+		md->active_char['`'] = MD_CHAR_CODESPAN;
 
-	if (rndr.make.linebreak)
-		rndr.active_char['\n'] = MD_CHAR_LINEBREAK;
+	if (md->cb.linebreak)
+		md->active_char['\n'] = MD_CHAR_LINEBREAK;
 
-	if (rndr.make.image || rndr.make.link)
-		rndr.active_char['['] = MD_CHAR_LINK;
+	if (md->cb.image || md->cb.link)
+		md->active_char['['] = MD_CHAR_LINK;
 
-	rndr.active_char['<'] = MD_CHAR_LANGLE;
-	rndr.active_char['\\'] = MD_CHAR_ESCAPE;
-	rndr.active_char['&'] = MD_CHAR_ENTITITY;
+	md->active_char['<'] = MD_CHAR_LANGLE;
+	md->active_char['\\'] = MD_CHAR_ESCAPE;
+	md->active_char['&'] = MD_CHAR_ENTITITY;
 
 	if (extensions & MKDEXT_AUTOLINK) {
-		rndr.active_char[':'] = MD_CHAR_AUTOLINK_URL;
-		rndr.active_char['@'] = MD_CHAR_AUTOLINK_EMAIL;
-		rndr.active_char['w'] = MD_CHAR_AUTOLINK_WWW;
+		md->active_char[':'] = MD_CHAR_AUTOLINK_URL;
+		md->active_char['@'] = MD_CHAR_AUTOLINK_EMAIL;
+		md->active_char['w'] = MD_CHAR_AUTOLINK_WWW;
 	}
 
+	if (extensions & MKDEXT_SUPERSCRIPT)
+		md->active_char['^'] = MD_CHAR_SUPERSCRIPT;
+
 	/* Extension data */
-	rndr.ext_flags = extensions;
-	rndr.max_nesting = 16;
+	md->ext_flags = extensions;
+	md->opaque = opaque;
+	md->max_nesting = max_nesting;
+	md->in_link_body = 0;
+
+	return md;
+}
+
+void
+sd_markdown_render(struct buf *ob, const uint8_t *document, size_t doc_size, struct sd_markdown *md)
+{
+	static const float MARKDOWN_GROW_FACTOR = 1.4f;
+
+	struct buf *text;
+	size_t beg, end;
+
+	text = bufnew(64);
+	if (!text)
+		return;
+
+	/* Preallocate enough space for our buffer to avoid expanding while copying */
+	bufgrow(text, doc_size);
+
+	/* reset the references table */
+	memset(&md->refs, 0x0, REF_TABLE_SIZE * sizeof(void *));
 
 	/* first pass: looking for references, copying everything else */
 	beg = 0;
-	while (beg < ib->size) /* iterating over lines */
-		if (is_ref(ib->data, beg, ib->size, &end, &rndr.refs))
+	while (beg < doc_size) /* iterating over lines */
+		if (is_ref(document, beg, doc_size, &end, md->refs))
 			beg = end;
 		else { /* skipping to the next line */
 			end = beg;
-			while (end < ib->size && ib->data[end] != '\n' && ib->data[end] != '\r')
-				end += 1;
+			while (end < doc_size && document[end] != '\n' && document[end] != '\r')
+				end++;
 
 			/* adding the line body if present */
 			if (end > beg)
-				expand_tabs(text, ib->data + beg, end - beg);
+				expand_tabs(text, document + beg, end - beg);
 
-			while (end < ib->size && (ib->data[end] == '\n' || ib->data[end] == '\r')) {
+			while (end < doc_size && (document[end] == '\n' || document[end] == '\r')) {
 				/* add one \n per newline */
-				if (ib->data[end] == '\n' || (end + 1 < ib->size && ib->data[end + 1] != '\n'))
+				if (document[end] == '\n' || (end + 1 < doc_size && document[end + 1] != '\n'))
 					bufputc(text, '\n');
-				end += 1;
+				end++;
 			}
 
 			beg = end;
 		}
 
-	/* sorting the reference array */
-	if (rndr.refs.size)
-		qsort(rndr.refs.base, rndr.refs.size, rndr.refs.unit, cmp_link_ref_sort);
+	/* pre-grow the output buffer to minimize allocations */
+	bufgrow(ob, text->size * MARKDOWN_GROW_FACTOR);
 
 	/* second pass: actual rendering */
-	if (rndr.make.doc_header)
-		rndr.make.doc_header(ob, rndr.make.opaque);
+	if (md->cb.doc_header)
+		md->cb.doc_header(ob, md->opaque);
 
 	if (text->size) {
 		/* adding a final newline if not already present */
 		if (text->data[text->size - 1] != '\n' &&  text->data[text->size - 1] != '\r')
 			bufputc(text, '\n');
 
-		parse_block(ob, &rndr, text->data, text->size);
+		parse_block(ob, md, text->data, text->size);
 	}
 
-	if (rndr.make.doc_footer)
-		rndr.make.doc_footer(ob, rndr.make.opaque);
+	if (md->cb.doc_footer)
+		md->cb.doc_footer(ob, md->opaque);
 
 	/* clean-up */
 	bufrelease(text);
-	lr = rndr.refs.base;
-	for (i = 0; i < (size_t)rndr.refs.size; i += 1) {
-		bufrelease(lr[i].id);
-		bufrelease(lr[i].link);
-		bufrelease(lr[i].title);
-	}
+	free_link_refs(md->refs);
+
+	assert(md->work_bufs[BUFFER_SPAN].size == 0);
+	assert(md->work_bufs[BUFFER_BLOCK].size == 0);
+}
 
-	arr_free(&rndr.refs);
+void
+sd_markdown_free(struct sd_markdown *md)
+{
+	size_t i;
 
-	assert(rndr.work_bufs[BUFFER_SPAN].size == 0);
-	assert(rndr.work_bufs[BUFFER_BLOCK].size == 0);
+	for (i = 0; i < (size_t)md->work_bufs[BUFFER_SPAN].asize; ++i)
+		bufrelease(md->work_bufs[BUFFER_SPAN].item[i]);
 
-	for (i = 0; i < (size_t)rndr.work_bufs[BUFFER_SPAN].asize; ++i)
-		bufrelease(rndr.work_bufs[BUFFER_SPAN].item[i]);
+	for (i = 0; i < (size_t)md->work_bufs[BUFFER_BLOCK].asize; ++i)
+		bufrelease(md->work_bufs[BUFFER_BLOCK].item[i]);
 
-	for (i = 0; i < (size_t)rndr.work_bufs[BUFFER_BLOCK].asize; ++i)
-		bufrelease(rndr.work_bufs[BUFFER_BLOCK].item[i]);
+	stack_free(&md->work_bufs[BUFFER_SPAN]);
+	stack_free(&md->work_bufs[BUFFER_BLOCK]);
 
-	parr_free(&rndr.work_bufs[BUFFER_SPAN]);
-	parr_free(&rndr.work_bufs[BUFFER_BLOCK]);
+	free(md);
 }
 
 void
-ups_version(int *ver_major, int *ver_minor, int *ver_revision)
+sd_version(int *ver_major, int *ver_minor, int *ver_revision)
 {
 	*ver_major = UPSKIRT_VER_MAJOR;
 	*ver_minor = UPSKIRT_VER_MINOR;