8 files changed, 3247 insertions, 3247 deletions

diff --git a/libraries/hoedown/src/autolink.c b/libraries/hoedown/src/autolink.c
index 9bc7fad5..3063b1a0 100644
--- a/libraries/hoedown/src/autolink.c
+++ b/libraries/hoedown/src/autolink.c
@@ -8,274 +8,274 @@
 #ifndef _MSC_VER
 #include <strings.h>
 #else
-#define strncasecmp	_strnicmp
+#define strncasecmp    _strnicmp
 #endif
 
 int
 hoedown_autolink_is_safe(const uint8_t *data, size_t size)
 {
-	static const size_t valid_uris_count = 6;
-	static const char *valid_uris[] = {
-		"http://", "https://", "/", "#", "ftp://", "mailto:"
-	};
-	static const size_t valid_uris_size[] = { 7, 8, 1, 1, 6, 7 };
-	size_t i;
-
-	for (i = 0; i < valid_uris_count; ++i) {
-		size_t len = valid_uris_size[i];
-
-		if (size > len &&
-			strncasecmp((char *)data, valid_uris[i], len) == 0 &&
-			isalnum(data[len]))
-			return 1;
-	}
-
-	return 0;
+    static const size_t valid_uris_count = 6;
+    static const char *valid_uris[] = {
+        "http://", "https://", "/", "#", "ftp://", "mailto:"
+    };
+    static const size_t valid_uris_size[] = { 7, 8, 1, 1, 6, 7 };
+    size_t i;
+
+    for (i = 0; i < valid_uris_count; ++i) {
+        size_t len = valid_uris_size[i];
+
+        if (size > len &&
+            strncasecmp((char *)data, valid_uris[i], len) == 0 &&
+            isalnum(data[len]))
+            return 1;
+    }
+
+    return 0;
 }
 
 static size_t
 autolink_delim(uint8_t *data, size_t link_end, size_t max_rewind, size_t size)
 {
-	uint8_t cclose, copen = 0;
-	size_t i;
-
-	for (i = 0; i < link_end; ++i)
-		if (data[i] == '<') {
-			link_end = i;
-			break;
-		}
-
-	while (link_end > 0) {
-		if (strchr("?!.,:", data[link_end - 1]) != NULL)
-			link_end--;
-
-		else if (data[link_end - 1] == ';') {
-			size_t new_end = link_end - 2;
-
-			while (new_end > 0 && isalpha(data[new_end]))
-				new_end--;
-
-			if (new_end < link_end - 2 && data[new_end] == '&')
-				link_end = new_end;
-			else
-				link_end--;
-		}
-		else break;
-	}
-
-	if (link_end == 0)
-		return 0;
-
-	cclose = data[link_end - 1];
-
-	switch (cclose) {
-	case '"':	copen = '"'; break;
-	case '\'':	copen = '\''; break;
-	case ')':	copen = '('; break;
-	case ']':	copen = '['; break;
-	case '}':	copen = '{'; break;
-	}
-
-	if (copen != 0) {
-		size_t closing = 0;
-		size_t opening = 0;
-		size_t i = 0;
-
-		/* Try to close the final punctuation sign in this same line;
-		 * if we managed to close it outside of the URL, that means that it's
-		 * not part of the URL. If it closes inside the URL, that means it
-		 * is part of the URL.
-		 *
-		 * Examples:
-		 *
-		 *	foo http://www.pokemon.com/Pikachu_(Electric) bar
-		 *		=> http://www.pokemon.com/Pikachu_(Electric)
-		 *
-		 *	foo (http://www.pokemon.com/Pikachu_(Electric)) bar
-		 *		=> http://www.pokemon.com/Pikachu_(Electric)
-		 *
-		 *	foo http://www.pokemon.com/Pikachu_(Electric)) bar
-		 *		=> http://www.pokemon.com/Pikachu_(Electric))
-		 *
-		 *	(foo http://www.pokemon.com/Pikachu_(Electric)) bar
-		 *		=> foo http://www.pokemon.com/Pikachu_(Electric)
-		 */
-
-		while (i < link_end) {
-			if (data[i] == copen)
-				opening++;
-			else if (data[i] == cclose)
-				closing++;
-
-			i++;
-		}
-
-		if (closing != opening)
-			link_end--;
-	}
-
-	return link_end;
+    uint8_t cclose, copen = 0;
+    size_t i;
+
+    for (i = 0; i < link_end; ++i)
+        if (data[i] == '<') {
+            link_end = i;
+            break;
+        }
+
+    while (link_end > 0) {
+        if (strchr("?!.,:", data[link_end - 1]) != NULL)
+            link_end--;
+
+        else if (data[link_end - 1] == ';') {
+            size_t new_end = link_end - 2;
+
+            while (new_end > 0 && isalpha(data[new_end]))
+                new_end--;
+
+            if (new_end < link_end - 2 && data[new_end] == '&')
+                link_end = new_end;
+            else
+                link_end--;
+        }
+        else break;
+    }
+
+    if (link_end == 0)
+        return 0;
+
+    cclose = data[link_end - 1];
+
+    switch (cclose) {
+    case '"':    copen = '"'; break;
+    case '\'':    copen = '\''; break;
+    case ')':    copen = '('; break;
+    case ']':    copen = '['; break;
+    case '}':    copen = '{'; break;
+    }
+
+    if (copen != 0) {
+        size_t closing = 0;
+        size_t opening = 0;
+        size_t i = 0;
+
+        /* Try to close the final punctuation sign in this same line;
+         * if we managed to close it outside of the URL, that means that it's
+         * not part of the URL. If it closes inside the URL, that means it
+         * is part of the URL.
+         *
+         * Examples:
+         *
+         *    foo http://www.pokemon.com/Pikachu_(Electric) bar
+         *        => http://www.pokemon.com/Pikachu_(Electric)
+         *
+         *    foo (http://www.pokemon.com/Pikachu_(Electric)) bar
+         *        => http://www.pokemon.com/Pikachu_(Electric)
+         *
+         *    foo http://www.pokemon.com/Pikachu_(Electric)) bar
+         *        => http://www.pokemon.com/Pikachu_(Electric))
+         *
+         *    (foo http://www.pokemon.com/Pikachu_(Electric)) bar
+         *        => foo http://www.pokemon.com/Pikachu_(Electric)
+         */
+
+        while (i < link_end) {
+            if (data[i] == copen)
+                opening++;
+            else if (data[i] == cclose)
+                closing++;
+
+            i++;
+        }
+
+        if (closing != opening)
+            link_end--;
+    }
+
+    return link_end;
 }
 
 static size_t
 check_domain(uint8_t *data, size_t size, int allow_short)
 {
-	size_t i, np = 0;
-
-	if (!isalnum(data[0]))
-		return 0;
-
-	for (i = 1; i < size - 1; ++i) {
-		if (strchr(".:", data[i]) != NULL) np++;
-		else if (!isalnum(data[i]) && data[i] != '-') break;
-	}
-
-	if (allow_short) {
-		/* We don't need a valid domain in the strict sense (with
-		 * least one dot; so just make sure it's composed of valid
-		 * domain characters and return the length of the the valid
-		 * sequence. */
-		return i;
-	} else {
-		/* a valid domain needs to have at least a dot.
-		 * that's as far as we get */
-		return np ? i : 0;
-	}
+    size_t i, np = 0;
+
+    if (!isalnum(data[0]))
+        return 0;
+
+    for (i = 1; i < size - 1; ++i) {
+        if (strchr(".:", data[i]) != NULL) np++;
+        else if (!isalnum(data[i]) && data[i] != '-') break;
+    }
+
+    if (allow_short) {
+        /* We don't need a valid domain in the strict sense (with
+         * least one dot; so just make sure it's composed of valid
+         * domain characters and return the length of the the valid
+         * sequence. */
+        return i;
+    } else {
+        /* a valid domain needs to have at least a dot.
+         * that's as far as we get */
+        return np ? i : 0;
+    }
 }
 
 size_t
 hoedown_autolink__www(
-	size_t *rewind_p,
-	hoedown_buffer *link,
-	uint8_t *data,
-	size_t max_rewind,
-	size_t size,
-	unsigned int flags)
+    size_t *rewind_p,
+    hoedown_buffer *link,
+    uint8_t *data,
+    size_t max_rewind,
+    size_t size,
+    unsigned int flags)
 {
-	size_t link_end;
+    size_t link_end;
 
-	if (max_rewind > 0 && !ispunct(data[-1]) && !isspace(data[-1]))
-		return 0;
+    if (max_rewind > 0 && !ispunct(data[-1]) && !isspace(data[-1]))
+        return 0;
 
-	if (size < 4 || memcmp(data, "www.", strlen("www.")) != 0)
-		return 0;
+    if (size < 4 || memcmp(data, "www.", strlen("www.")) != 0)
+        return 0;
 
-	link_end = check_domain(data, size, 0);
+    link_end = check_domain(data, size, 0);
 
-	if (link_end == 0)
-		return 0;
+    if (link_end == 0)
+        return 0;
 
-	while (link_end < size && !isspace(data[link_end]))
-		link_end++;
+    while (link_end < size && !isspace(data[link_end]))
+        link_end++;
 
-	link_end = autolink_delim(data, link_end, max_rewind, size);
+    link_end = autolink_delim(data, link_end, max_rewind, size);
 
-	if (link_end == 0)
-		return 0;
+    if (link_end == 0)
+        return 0;
 
-	hoedown_buffer_put(link, data, link_end);
-	*rewind_p = 0;
+    hoedown_buffer_put(link, data, link_end);
+    *rewind_p = 0;
 
-	return (int)link_end;
+    return (int)link_end;
 }
 
 size_t
 hoedown_autolink__email(
-	size_t *rewind_p,
-	hoedown_buffer *link,
-	uint8_t *data,
-	size_t max_rewind,
-	size_t size,
-	unsigned int flags)
+    size_t *rewind_p,
+    hoedown_buffer *link,
+    uint8_t *data,
+    size_t max_rewind,
+    size_t size,
+    unsigned int flags)
 {
-	size_t link_end, rewind;
-	int nb = 0, np = 0;
+    size_t link_end, rewind;
+    int nb = 0, np = 0;
 
-	for (rewind = 0; rewind < max_rewind; ++rewind) {
-		uint8_t c = data[-1 - rewind];
+    for (rewind = 0; rewind < max_rewind; ++rewind) {
+        uint8_t c = data[-1 - rewind];
 
-		if (isalnum(c))
-			continue;
+        if (isalnum(c))
+            continue;
 
-		if (strchr(".+-_", c) != NULL)
-			continue;
+        if (strchr(".+-_", c) != NULL)
+            continue;
 
-		break;
-	}
+        break;
+    }
 
-	if (rewind == 0)
-		return 0;
+    if (rewind == 0)
+        return 0;
 
-	for (link_end = 0; link_end < size; ++link_end) {
-		uint8_t c = data[link_end];
+    for (link_end = 0; link_end < size; ++link_end) {
+        uint8_t c = data[link_end];
 
-		if (isalnum(c))
-			continue;
+        if (isalnum(c))
+            continue;
 
-		if (c == '@')
-			nb++;
-		else if (c == '.' && link_end < size - 1)
-			np++;
-		else if (c != '-' && c != '_')
-			break;
-	}
+        if (c == '@')
+            nb++;
+        else if (c == '.' && link_end < size - 1)
+            np++;
+        else if (c != '-' && c != '_')
+            break;
+    }
 
-	if (link_end < 2 || nb != 1 || np == 0 ||
-		!isalpha(data[link_end - 1]))
-		return 0;
+    if (link_end < 2 || nb != 1 || np == 0 ||
+        !isalpha(data[link_end - 1]))
+        return 0;
 
-	link_end = autolink_delim(data, link_end, max_rewind, size);
+    link_end = autolink_delim(data, link_end, max_rewind, size);
 
-	if (link_end == 0)
-		return 0;
+    if (link_end == 0)
+        return 0;
 
-	hoedown_buffer_put(link, data - rewind, link_end + rewind);
-	*rewind_p = rewind;
+    hoedown_buffer_put(link, data - rewind, link_end + rewind);
+    *rewind_p = rewind;
 
-	return link_end;
+    return link_end;
 }
 
 size_t
 hoedown_autolink__url(
-	size_t *rewind_p,
-	hoedown_buffer *link,
-	uint8_t *data,
-	size_t max_rewind,
-	size_t size,
-	unsigned int flags)
+    size_t *rewind_p,
+    hoedown_buffer *link,
+    uint8_t *data,
+    size_t max_rewind,
+    size_t size,
+    unsigned int flags)
 {
-	size_t link_end, rewind = 0, domain_len;
+    size_t link_end, rewind = 0, domain_len;
 
-	if (size < 4 || data[1] != '/' || data[2] != '/')
-		return 0;
+    if (size < 4 || data[1] != '/' || data[2] != '/')
+        return 0;
 
-	while (rewind < max_rewind && isalpha(data[-1 - rewind]))
-		rewind++;
+    while (rewind < max_rewind && isalpha(data[-1 - rewind]))
+        rewind++;
 
-	if (!hoedown_autolink_is_safe(data - rewind, size + rewind))
-		return 0;
+    if (!hoedown_autolink_is_safe(data - rewind, size + rewind))
+        return 0;
 
-	link_end = strlen("://");
+    link_end = strlen("://");
 
-	domain_len = check_domain(
-		data + link_end,
-		size - link_end,
-		flags & HOEDOWN_AUTOLINK_SHORT_DOMAINS);
+    domain_len = check_domain(
+        data + link_end,
+        size - link_end,
+        flags & HOEDOWN_AUTOLINK_SHORT_DOMAINS);
 
-	if (domain_len == 0)
-		return 0;
+    if (domain_len == 0)
+        return 0;
 
-	link_end += domain_len;
-	while (link_end < size && !isspace(data[link_end]))
-		link_end++;
+    link_end += domain_len;
+    while (link_end < size && !isspace(data[link_end]))
+        link_end++;
 
-	link_end = autolink_delim(data, link_end, max_rewind, size);
+    link_end = autolink_delim(data, link_end, max_rewind, size);
 
-	if (link_end == 0)
-		return 0;
+    if (link_end == 0)
+        return 0;
 
-	hoedown_buffer_put(link, data - rewind, link_end + rewind);
-	*rewind_p = rewind;
+    hoedown_buffer_put(link, data - rewind, link_end + rewind);
+    *rewind_p = rewind;
 
-	return link_end;
+    return link_end;
 }
diff --git a/libraries/hoedown/src/buffer.c b/libraries/hoedown/src/buffer.c
index 1c7ba55a..024a8bcc 100644
--- a/libraries/hoedown/src/buffer.c
+++ b/libraries/hoedown/src/buffer.c
@@ -8,301 +8,301 @@
 void *
 hoedown_malloc(size_t size)
 {
-	void *ret = malloc(size);
+    void *ret = malloc(size);
 
-	if (!ret) {
-		fprintf(stderr, "Allocation failed.\n");
-		abort();
-	}
+    if (!ret) {
+        fprintf(stderr, "Allocation failed.\n");
+        abort();
+    }
 
-	return ret;
+    return ret;
 }
 
 void *
 hoedown_calloc(size_t nmemb, size_t size)
 {
-	void *ret = calloc(nmemb, size);
+    void *ret = calloc(nmemb, size);
 
-	if (!ret) {
-		fprintf(stderr, "Allocation failed.\n");
-		abort();
-	}
+    if (!ret) {
+        fprintf(stderr, "Allocation failed.\n");
+        abort();
+    }
 
-	return ret;
+    return ret;
 }
 
 void *
 hoedown_realloc(void *ptr, size_t size)
 {
-	void *ret = realloc(ptr, size);
+    void *ret = realloc(ptr, size);
 
-	if (!ret) {
-		fprintf(stderr, "Allocation failed.\n");
-		abort();
-	}
+    if (!ret) {
+        fprintf(stderr, "Allocation failed.\n");
+        abort();
+    }
 
-	return ret;
+    return ret;
 }
 
 void
 hoedown_buffer_init(
-	hoedown_buffer *buf,
-	size_t unit,
-	hoedown_realloc_callback data_realloc,
-	hoedown_free_callback data_free,
-	hoedown_free_callback buffer_free)
+    hoedown_buffer *buf,
+    size_t unit,
+    hoedown_realloc_callback data_realloc,
+    hoedown_free_callback data_free,
+    hoedown_free_callback buffer_free)
 {
-	assert(buf);
-
-	buf->data = NULL;
-	buf->size = buf->asize = 0;
-	buf->unit = unit;
-	buf->data_realloc = data_realloc;
-	buf->data_free = data_free;
-	buf->buffer_free = buffer_free;
+    assert(buf);
+
+    buf->data = NULL;
+    buf->size = buf->asize = 0;
+    buf->unit = unit;
+    buf->data_realloc = data_realloc;
+    buf->data_free = data_free;
+    buf->buffer_free = buffer_free;
 }
 
 void
 hoedown_buffer_uninit(hoedown_buffer *buf)
 {
-	assert(buf && buf->unit);
-	buf->data_free(buf->data);
+    assert(buf && buf->unit);
+    buf->data_free(buf->data);
 }
 
 hoedown_buffer *
 hoedown_buffer_new(size_t unit)
 {
-	hoedown_buffer *ret = hoedown_malloc(sizeof (hoedown_buffer));
-	hoedown_buffer_init(ret, unit, hoedown_realloc, free, free);
-	return ret;
+    hoedown_buffer *ret = hoedown_malloc(sizeof (hoedown_buffer));
+    hoedown_buffer_init(ret, unit, hoedown_realloc, free, free);
+    return ret;
 }
 
 void
 hoedown_buffer_free(hoedown_buffer *buf)
 {
-	if (!buf) return;
-	assert(buf && buf->unit);
+    if (!buf) return;
+    assert(buf && buf->unit);
 
-	buf->data_free(buf->data);
+    buf->data_free(buf->data);
 
-	if (buf->buffer_free)
-		buf->buffer_free(buf);
+    if (buf->buffer_free)
+        buf->buffer_free(buf);
 }
 
 void
 hoedown_buffer_reset(hoedown_buffer *buf)
 {
-	assert(buf && buf->unit);
+    assert(buf && buf->unit);
 
-	buf->data_free(buf->data);
-	buf->data = NULL;
-	buf->size = buf->asize = 0;
+    buf->data_free(buf->data);
+    buf->data = NULL;
+    buf->size = buf->asize = 0;
 }
 
 void
 hoedown_buffer_grow(hoedown_buffer *buf, size_t neosz)
 {
-	size_t neoasz;
-	assert(buf && buf->unit);
+    size_t neoasz;
+    assert(buf && buf->unit);
 
-	if (buf->asize >= neosz)
-		return;
+    if (buf->asize >= neosz)
+        return;
 
-	neoasz = buf->asize + buf->unit;
-	while (neoasz < neosz)
-		neoasz += buf->unit;
+    neoasz = buf->asize + buf->unit;
+    while (neoasz < neosz)
+        neoasz += buf->unit;
 
-	buf->data = (uint8_t *) buf->data_realloc(buf->data, neoasz);
-	buf->asize = neoasz;
+    buf->data = (uint8_t *) buf->data_realloc(buf->data, neoasz);
+    buf->asize = neoasz;
 }
 
 void
 hoedown_buffer_put(hoedown_buffer *buf, const uint8_t *data, size_t size)
 {
-	assert(buf && buf->unit);
+    assert(buf && buf->unit);
 
-	if (buf->size + size > buf->asize)
-		hoedown_buffer_grow(buf, buf->size + size);
+    if (buf->size + size > buf->asize)
+        hoedown_buffer_grow(buf, buf->size + size);
 
-	memcpy(buf->data + buf->size, data, size);
-	buf->size += size;
+    memcpy(buf->data + buf->size, data, size);
+    buf->size += size;
 }
 
 void
 hoedown_buffer_puts(hoedown_buffer *buf, const char *str)
 {
-	hoedown_buffer_put(buf, (const uint8_t *)str, strlen(str));
+    hoedown_buffer_put(buf, (const uint8_t *)str, strlen(str));
 }
 
 void
 hoedown_buffer_putc(hoedown_buffer *buf, uint8_t c)
 {
-	assert(buf && buf->unit);
+    assert(buf && buf->unit);
 
-	if (buf->size >= buf->asize)
-		hoedown_buffer_grow(buf, buf->size + 1);
+    if (buf->size >= buf->asize)
+        hoedown_buffer_grow(buf, buf->size + 1);
 
-	buf->data[buf->size] = c;
-	buf->size += 1;
+    buf->data[buf->size] = c;
+    buf->size += 1;
 }
 
 int
 hoedown_buffer_putf(hoedown_buffer *buf, FILE *file)
 {
-	assert(buf && buf->unit);
+    assert(buf && buf->unit);
 
-	while (!(feof(file) || ferror(file))) {
-		hoedown_buffer_grow(buf, buf->size + buf->unit);
-		buf->size += fread(buf->data + buf->size, 1, buf->unit, file);
-	}
+    while (!(feof(file) || ferror(file))) {
+        hoedown_buffer_grow(buf, buf->size + buf->unit);
+        buf->size += fread(buf->data + buf->size, 1, buf->unit, file);
+    }
 
-	return ferror(file);
+    return ferror(file);
 }
 
 void
 hoedown_buffer_set(hoedown_buffer *buf, const uint8_t *data, size_t size)
 {
-	assert(buf && buf->unit);
+    assert(buf && buf->unit);
 
-	if (size > buf->asize)
-		hoedown_buffer_grow(buf, size);
+    if (size > buf->asize)
+        hoedown_buffer_grow(buf, size);
 
-	memcpy(buf->data, data, size);
-	buf->size = size;
+    memcpy(buf->data, data, size);
+    buf->size = size;
 }
 
 void
 hoedown_buffer_sets(hoedown_buffer *buf, const char *str)
 {
-	hoedown_buffer_set(buf, (const uint8_t *)str, strlen(str));
+    hoedown_buffer_set(buf, (const uint8_t *)str, strlen(str));
 }
 
 int
 hoedown_buffer_eq(const hoedown_buffer *buf, const uint8_t *data, size_t size)
 {
-	if (buf->size != size) return 0;
-	return memcmp(buf->data, data, size) == 0;
+    if (buf->size != size) return 0;
+    return memcmp(buf->data, data, size) == 0;
 }
 
 int
 hoedown_buffer_eqs(const hoedown_buffer *buf, const char *str)
 {
-	return hoedown_buffer_eq(buf, (const uint8_t *)str, strlen(str));
+    return hoedown_buffer_eq(buf, (const uint8_t *)str, strlen(str));
 }
 
 int
 hoedown_buffer_prefix(const hoedown_buffer *buf, const char *prefix)
 {
-	size_t i;
+    size_t i;
 
-	for (i = 0; i < buf->size; ++i) {
-		if (prefix[i] == 0)
-			return 0;
+    for (i = 0; i < buf->size; ++i) {
+        if (prefix[i] == 0)
+            return 0;
 
-		if (buf->data[i] != prefix[i])
-			return buf->data[i] - prefix[i];
-	}
+        if (buf->data[i] != prefix[i])
+            return buf->data[i] - prefix[i];
+    }
 
-	return 0;
+    return 0;
 }
 
 void
 hoedown_buffer_slurp(hoedown_buffer *buf, size_t size)
 {
-	assert(buf && buf->unit);
+    assert(buf && buf->unit);
 
-	if (size >= buf->size) {
-		buf->size = 0;
-		return;
-	}
+    if (size >= buf->size) {
+        buf->size = 0;
+        return;
+    }
 
-	buf->size -= size;
-	memmove(buf->data, buf->data + size, buf->size);
+    buf->size -= size;
+    memmove(buf->data, buf->data + size, buf->size);
 }
 
 const char *
 hoedown_buffer_cstr(hoedown_buffer *buf)
 {
-	assert(buf && buf->unit);
+    assert(buf && buf->unit);
 
-	if (buf->size < buf->asize && buf->data[buf->size] == 0)
-		return (char *)buf->data;
+    if (buf->size < buf->asize && buf->data[buf->size] == 0)
+        return (char *)buf->data;
 
-	hoedown_buffer_grow(buf, buf->size + 1);
-	buf->data[buf->size] = 0;
+    hoedown_buffer_grow(buf, buf->size + 1);
+    buf->data[buf->size] = 0;
 
-	return (char *)buf->data;
+    return (char *)buf->data;
 }
 
 void
 hoedown_buffer_printf(hoedown_buffer *buf, const char *fmt, ...)
 {
-	va_list ap;
-	int n;
+    va_list ap;
+    int n;
 
-	assert(buf && buf->unit);
+    assert(buf && buf->unit);
 
-	if (buf->size >= buf->asize)
-		hoedown_buffer_grow(buf, buf->size + 1);
+    if (buf->size >= buf->asize)
+        hoedown_buffer_grow(buf, buf->size + 1);
 
-	va_start(ap, fmt);
-	n = vsnprintf((char *)buf->data + buf->size, buf->asize - buf->size, fmt, ap);
-	va_end(ap);
+    va_start(ap, fmt);
+    n = vsnprintf((char *)buf->data + buf->size, buf->asize - buf->size, fmt, ap);
+    va_end(ap);
 
-	if (n < 0) {
+    if (n < 0) {
 #ifndef _MSC_VER
-		return;
+        return;
 #else
-		va_start(ap, fmt);
-		n = _vscprintf(fmt, ap);
-		va_end(ap);
+        va_start(ap, fmt);
+        n = _vscprintf(fmt, ap);
+        va_end(ap);
 #endif
-	}
+    }
 
-	if ((size_t)n >= buf->asize - buf->size) {
-		hoedown_buffer_grow(buf, buf->size + n + 1);
+    if ((size_t)n >= buf->asize - buf->size) {
+        hoedown_buffer_grow(buf, buf->size + n + 1);
 
-		va_start(ap, fmt);
-		n = vsnprintf((char *)buf->data + buf->size, buf->asize - buf->size, fmt, ap);
-		va_end(ap);
-	}
+        va_start(ap, fmt);
+        n = vsnprintf((char *)buf->data + buf->size, buf->asize - buf->size, fmt, ap);
+        va_end(ap);
+    }
 
-	if (n < 0)
-		return;
+    if (n < 0)
+        return;
 
-	buf->size += n;
+    buf->size += n;
 }
 
 void hoedown_buffer_put_utf8(hoedown_buffer *buf, unsigned int c) {
-	unsigned char unichar[4];
-
-	assert(buf && buf->unit);
-
-	if (c < 0x80) {
-		hoedown_buffer_putc(buf, c);
-	}
-	else if (c < 0x800) {
-		unichar[0] = 192 + (c / 64);
-		unichar[1] = 128 + (c % 64);
-		hoedown_buffer_put(buf, unichar, 2);
-	}
-	else if (c - 0xd800u < 0x800) {
-		HOEDOWN_BUFPUTSL(buf, "\xef\xbf\xbd");
-	}
-	else if (c < 0x10000) {
-		unichar[0] = 224 + (c / 4096);
-		unichar[1] = 128 + (c / 64) % 64;
-		unichar[2] = 128 + (c % 64);
-		hoedown_buffer_put(buf, unichar, 3);
-	}
-	else if (c < 0x110000) {
-		unichar[0] = 240 + (c / 262144);
-		unichar[1] = 128 + (c / 4096) % 64;
-		unichar[2] = 128 + (c / 64) % 64;
-		unichar[3] = 128 + (c % 64);
-		hoedown_buffer_put(buf, unichar, 4);
-	}
-	else {
-		HOEDOWN_BUFPUTSL(buf, "\xef\xbf\xbd");
-	}
+    unsigned char unichar[4];
+
+    assert(buf && buf->unit);
+
+    if (c < 0x80) {
+        hoedown_buffer_putc(buf, c);
+    }
+    else if (c < 0x800) {
+        unichar[0] = 192 + (c / 64);
+        unichar[1] = 128 + (c % 64);
+        hoedown_buffer_put(buf, unichar, 2);
+    }
+    else if (c - 0xd800u < 0x800) {
+        HOEDOWN_BUFPUTSL(buf, "\xef\xbf\xbd");
+    }
+    else if (c < 0x10000) {
+        unichar[0] = 224 + (c / 4096);
+        unichar[1] = 128 + (c / 64) % 64;
+        unichar[2] = 128 + (c % 64);
+        hoedown_buffer_put(buf, unichar, 3);
+    }
+    else if (c < 0x110000) {
+        unichar[0] = 240 + (c / 262144);
+        unichar[1] = 128 + (c / 4096) % 64;
+        unichar[2] = 128 + (c / 64) % 64;
+        unichar[3] = 128 + (c % 64);
+        hoedown_buffer_put(buf, unichar, 4);
+    }
+    else {
+        HOEDOWN_BUFPUTSL(buf, "\xef\xbf\xbd");
+    }
 }
diff --git a/libraries/hoedown/src/document.c b/libraries/hoedown/src/document.c
index 8ba82e47..e9e2ab11 100644
--- a/libraries/hoedown/src/document.c
+++ b/libraries/hoedown/src/document.c
@@ -10,7 +10,7 @@
 #ifndef _MSC_VER
 #include <strings.h>
 #else
-#define strncasecmp	_strnicmp
+#define strncasecmp    _strnicmp
 #endif
 
 #define REF_TABLE_SIZE 8
@@ -18,7 +18,7 @@
 #define BUFFER_BLOCK 0
 #define BUFFER_SPAN 1
 
-#define HOEDOWN_LI_END 8	/* internal list flag */
+#define HOEDOWN_LI_END 8    /* internal list flag */
 
 const char *hoedown_find_block_tag(const char *str, unsigned int len);
 
@@ -28,35 +28,35 @@ const char *hoedown_find_block_tag(const char *str, unsigned int len);
 
 /* link_ref: reference to a link */
 struct link_ref {
-	unsigned int id;
+    unsigned int id;
 
-	hoedown_buffer *link;
-	hoedown_buffer *title;
+    hoedown_buffer *link;
+    hoedown_buffer *title;
 
-	struct link_ref *next;
+    struct link_ref *next;
 };
 
 /* footnote_ref: reference to a footnote */
 struct footnote_ref {
-	unsigned int id;
+    unsigned int id;
 
-	int is_used;
-	unsigned int num;
+    int is_used;
+    unsigned int num;
 
-	hoedown_buffer *contents;
+    hoedown_buffer *contents;
 };
 
 /* footnote_item: an item in a footnote_list */
 struct footnote_item {
-	struct footnote_ref *ref;
-	struct footnote_item *next;
+    struct footnote_ref *ref;
+    struct footnote_item *next;
 };
 
 /* footnote_list: linked list of footnote_item */
 struct footnote_list {
-	unsigned int count;
-	struct footnote_item *head;
-	struct footnote_item *tail;
+    unsigned int count;
+    struct footnote_item *head;
+    struct footnote_item *tail;
 };
 
 /* char_trigger: function pointer to render active chars */
@@ -81,51 +81,51 @@ static size_t char_superscript(hoedown_buffer *ob, hoedown_document *doc, uint8_
 static size_t char_math(hoedown_buffer *ob, hoedown_document *doc, uint8_t *data, size_t offset, size_t size);
 
 enum markdown_char_t {
-	MD_CHAR_NONE = 0,
-	MD_CHAR_EMPHASIS,
-	MD_CHAR_CODESPAN,
-	MD_CHAR_LINEBREAK,
-	MD_CHAR_LINK,
-	MD_CHAR_LANGLE,
-	MD_CHAR_ESCAPE,
-	MD_CHAR_ENTITY,
-	MD_CHAR_AUTOLINK_URL,
-	MD_CHAR_AUTOLINK_EMAIL,
-	MD_CHAR_AUTOLINK_WWW,
-	MD_CHAR_SUPERSCRIPT,
-	MD_CHAR_QUOTE,
-	MD_CHAR_MATH
+    MD_CHAR_NONE = 0,
+    MD_CHAR_EMPHASIS,
+    MD_CHAR_CODESPAN,
+    MD_CHAR_LINEBREAK,
+    MD_CHAR_LINK,
+    MD_CHAR_LANGLE,
+    MD_CHAR_ESCAPE,
+    MD_CHAR_ENTITY,
+    MD_CHAR_AUTOLINK_URL,
+    MD_CHAR_AUTOLINK_EMAIL,
+    MD_CHAR_AUTOLINK_WWW,
+    MD_CHAR_SUPERSCRIPT,
+    MD_CHAR_QUOTE,
+    MD_CHAR_MATH
 };
 
 static char_trigger markdown_char_ptrs[] = {
-	NULL,
-	&char_emphasis,
-	&char_codespan,
-	&char_linebreak,
-	&char_link,
-	&char_langle_tag,
-	&char_escape,
-	&char_entity,
-	&char_autolink_url,
-	&char_autolink_email,
-	&char_autolink_www,
-	&char_superscript,
-	&char_quote,
-	&char_math
+    NULL,
+    &char_emphasis,
+    &char_codespan,
+    &char_linebreak,
+    &char_link,
+    &char_langle_tag,
+    &char_escape,
+    &char_entity,
+    &char_autolink_url,
+    &char_autolink_email,
+    &char_autolink_www,
+    &char_superscript,
+    &char_quote,
+    &char_math
 };
 
 struct hoedown_document {
-	hoedown_renderer md;
-	hoedown_renderer_data data;
-
-	struct link_ref *refs[REF_TABLE_SIZE];
-	struct footnote_list footnotes_found;
-	struct footnote_list footnotes_used;
-	uint8_t active_char[256];
-	hoedown_stack work_bufs[2];
-	hoedown_extensions ext_flags;
-	size_t max_nesting;
-	int in_link_body;
+    hoedown_renderer md;
+    hoedown_renderer_data data;
+
+    struct link_ref *refs[REF_TABLE_SIZE];
+    struct footnote_list footnotes_found;
+    struct footnote_list footnotes_used;
+    uint8_t active_char[256];
+    hoedown_stack work_bufs[2];
+    hoedown_extensions ext_flags;
+    size_t max_nesting;
+    int in_link_body;
 };
 
 /***************************
@@ -135,177 +135,177 @@ struct hoedown_document {
 static hoedown_buffer *
 newbuf(hoedown_document *doc, int type)
 {
-	static const size_t buf_size[2] = {256, 64};
-	hoedown_buffer *work = NULL;
-	hoedown_stack *pool = &doc->work_bufs[type];
+    static const size_t buf_size[2] = {256, 64};
+    hoedown_buffer *work = NULL;
+    hoedown_stack *pool = &doc->work_bufs[type];
 
-	if (pool->size < pool->asize &&
-		pool->item[pool->size] != NULL) {
-		work = pool->item[pool->size++];
-		work->size = 0;
-	} else {
-		work = hoedown_buffer_new(buf_size[type]);
-		hoedown_stack_push(pool, work);
-	}
+    if (pool->size < pool->asize &&
+        pool->item[pool->size] != NULL) {
+        work = pool->item[pool->size++];
+        work->size = 0;
+    } else {
+        work = hoedown_buffer_new(buf_size[type]);
+        hoedown_stack_push(pool, work);
+    }
 
-	return work;
+    return work;
 }
 
 static void
 popbuf(hoedown_document *doc, int type)
 {
-	doc->work_bufs[type].size--;
+    doc->work_bufs[type].size--;
 }
 
 static void
 unscape_text(hoedown_buffer *ob, hoedown_buffer *src)
 {
-	size_t i = 0, org;
-	while (i < src->size) {
-		org = i;
-		while (i < src->size && src->data[i] != '\\')
-			i++;
+    size_t i = 0, org;
+    while (i < src->size) {
+        org = i;
+        while (i < src->size && src->data[i] != '\\')
+            i++;
 
-		if (i > org)
-			hoedown_buffer_put(ob, src->data + org, i - org);
+        if (i > org)
+            hoedown_buffer_put(ob, src->data + org, i - org);
 
-		if (i + 1 >= src->size)
-			break;
+        if (i + 1 >= src->size)
+            break;
 
-		hoedown_buffer_putc(ob, src->data[i + 1]);
-		i += 2;
-	}
+        hoedown_buffer_putc(ob, src->data[i + 1]);
+        i += 2;
+    }
 }
 
 static unsigned int
 hash_link_ref(const uint8_t *link_ref, size_t length)
 {
-	size_t i;
-	unsigned int hash = 0;
+    size_t i;
+    unsigned int hash = 0;
 
-	for (i = 0; i < length; ++i)
-		hash = tolower(link_ref[i]) + (hash << 6) + (hash << 16) - hash;