cmark

diff --git a/src/blocks.c b/src/blocks.c
@@ -33,7 +33,7 @@ static node_block* make_block(int tag, int start_line, int start_column)
 }
 
 // Create a root document node_block.
-extern node_block* make_document()
+static node_block* make_document()
 {
 	node_block *e = make_block(BLOCK_DOCUMENT, 1, 1);
 	e->as.document.refmap = reference_map_new();
@@ -43,7 +43,7 @@ extern node_block* make_document()
 }
 
 // Returns true if line has only space characters, else false.
-bool is_blank(strbuf *s, int offset)
+static bool is_blank(strbuf *s, int offset)
 {
 	while (offset < s->size) {
 		switch (s->ptr[offset]) {
@@ -283,7 +283,7 @@ typedef struct BlockStack {
 
 // Walk through node_block and all children, recursively, parsing
 // string content into inline content where appropriate.
-void process_inlines(node_block* cur, reference_map *refmap)
+static void process_inlines(node_block* cur, reference_map *refmap)
 {
 	block_stack* stack = NULL;
 	block_stack* newstack = NULL;

diff --git a/src/buffer.h b/src/buffer.h
@@ -9,12 +9,12 @@
 typedef struct {
 	unsigned char *ptr;
 	int asize, size;
-} strbuf;
+} cmark_strbuf;
 
-extern unsigned char strbuf__initbuf[];
-extern unsigned char strbuf__oom[];
+extern unsigned char cmark_strbuf__initbuf[];
+extern unsigned char cmark_strbuf__oom[];
 
-#define GH_BUF_INIT { strbuf__initbuf, 0, 0 }
+#define CMARK_GH_BUF_INIT { cmark_strbuf__initbuf, 0, 0 }
 
 /**
  * Initialize a strbuf structure.
@@ -22,7 +22,7 @@ extern unsigned char strbuf__oom[];
  * For the cases where GH_BUF_INIT cannot be used to do static
  * initialization.
  */
-extern void strbuf_init(strbuf *buf, int initial_size);
+extern void cmark_strbuf_init(cmark_strbuf *buf, int initial_size);
 
 /**
  * Attempt to grow the buffer to hold at least `target_size` bytes.
@@ -32,7 +32,7 @@ extern void strbuf_init(strbuf *buf, int initial_size);
  * existing buffer content will be preserved, but calling code must handle
  * that buffer was not expanded.
  */
-extern int strbuf_try_grow(strbuf *buf, int target_size, bool mark_oom);
+extern int cmark_strbuf_try_grow(cmark_strbuf *buf, int target_size, bool mark_oom);
 
 /**
  * Grow the buffer to hold at least `target_size` bytes.
@@ -42,13 +42,13 @@ extern int strbuf_try_grow(strbuf *buf, int target_size, bool mark_oom);
  *
  * @return 0 on success or -1 on failure
  */
-static inline int strbuf_grow(strbuf *buf, int target_size)
+static inline int cmark_strbuf_grow(cmark_strbuf *buf, int target_size)
 {
-	return strbuf_try_grow(buf, target_size, true);
+	return cmark_strbuf_try_grow(buf, target_size, true);
 }
 
-extern void strbuf_free(strbuf *buf);
-extern void strbuf_swap(strbuf *buf_a, strbuf *buf_b);
+extern void cmark_strbuf_free(cmark_strbuf *buf);
+extern void cmark_strbuf_swap(cmark_strbuf *buf_a, cmark_strbuf *buf_b);
 
 /**
  * Test if there have been any reallocation failures with this strbuf.
@@ -61,29 +61,29 @@ extern void strbuf_swap(strbuf *buf_a, strbuf *buf_b);
  *
  * @return false if no error, true if allocation error
  */
-static inline bool strbuf_oom(const strbuf *buf)
+static inline bool cmark_strbuf_oom(const cmark_strbuf *buf)
 {
-	return (buf->ptr == strbuf__oom);
+	return (buf->ptr == cmark_strbuf__oom);
 }
 
 
-static inline size_t strbuf_len(const strbuf *buf)
+static inline size_t cmark_strbuf_len(const cmark_strbuf *buf)
 {
 	return buf->size;
 }
 
-extern int strbuf_cmp(const strbuf *a, const strbuf *b);
+extern int cmark_strbuf_cmp(const cmark_strbuf *a, const cmark_strbuf *b);
 
-extern void strbuf_attach(strbuf *buf, unsigned char *ptr, int asize);
-extern unsigned char *strbuf_detach(strbuf *buf);
-extern void strbuf_copy_cstr(char *data, int datasize, const strbuf *buf);
+extern void cmark_strbuf_attach(cmark_strbuf *buf, unsigned char *ptr, int asize);
+extern unsigned char *cmark_strbuf_detach(cmark_strbuf *buf);
+extern void cmark_strbuf_copy_cstr(char *data, int datasize, const cmark_strbuf *buf);
 
-static inline const char *strbuf_cstr(const strbuf *buf)
+static inline const char *cmark_strbuf_cstr(const cmark_strbuf *buf)
 {
 	return (char *)buf->ptr;
 }
 
-#define strbuf_at(buf, n) ((buf)->ptr[n])
+#define cmark_strbuf_at(buf, n) ((buf)->ptr[n])
 
 /*
  * Functions below that return int value error codes will return 0 on
@@ -93,23 +93,59 @@ static inline const char *strbuf_cstr(const strbuf *buf)
  * return code of these functions and call them in a series then just call
  * strbuf_oom at the end.
  */
-extern int strbuf_set(strbuf *buf, const unsigned char *data, int len);
-extern int strbuf_sets(strbuf *buf, const char *string);
-extern int strbuf_putc(strbuf *buf, int c);
-extern int strbuf_put(strbuf *buf, const unsigned char *data, int len);
-extern int strbuf_puts(strbuf *buf, const char *string);
-extern int strbuf_printf(strbuf *buf, const char *format, ...)
+extern int cmark_strbuf_set(cmark_strbuf *buf, const unsigned char *data, int len);
+extern int cmark_strbuf_sets(cmark_strbuf *buf, const char *string);
+extern int cmark_strbuf_putc(cmark_strbuf *buf, int c);
+extern int cmark_strbuf_put(cmark_strbuf *buf, const unsigned char *data, int len);
+extern int cmark_strbuf_puts(cmark_strbuf *buf, const char *string);
+extern int cmark_strbuf_printf(cmark_strbuf *buf, const char *format, ...)
 	__attribute__((format (printf, 2, 3)));
-extern int strbuf_vprintf(strbuf *buf, const char *format, va_list ap);
-extern void strbuf_clear(strbuf *buf);
-
-int strbuf_strchr(const strbuf *buf, int c, int pos);
-int strbuf_strrchr(const strbuf *buf, int c, int pos);
-void strbuf_drop(strbuf *buf, int n);
-void strbuf_truncate(strbuf *buf, int len);
-void strbuf_rtrim(strbuf *buf);
-void strbuf_trim(strbuf *buf);
-void strbuf_normalize_whitespace(strbuf *s);
-void strbuf_unescape(strbuf *s);
+extern int cmark_strbuf_vprintf(cmark_strbuf *buf, const char *format, va_list ap);
+extern void cmark_strbuf_clear(cmark_strbuf *buf);
+
+int cmark_strbuf_strchr(const cmark_strbuf *buf, int c, int pos);
+int cmark_strbuf_strrchr(const cmark_strbuf *buf, int c, int pos);
+void cmark_strbuf_drop(cmark_strbuf *buf, int n);
+void cmark_strbuf_truncate(cmark_strbuf *buf, int len);
+void cmark_strbuf_rtrim(cmark_strbuf *buf);
+void cmark_strbuf_trim(cmark_strbuf *buf);
+void cmark_strbuf_normalize_whitespace(cmark_strbuf *s);
+void cmark_strbuf_unescape(cmark_strbuf *s);
+
+#ifndef CMARK_NO_SHORT_NAMES
+  #define strbuf                        cmark_strbuf
+  #define strbuf__initbuf               cmark_strbuf__initbuf
+  #define strbuf__oom                   cmark_strbuf__oom
+  #define GH_BUF_INIT                   CMARK_GH_BUF_INIT
+  #define strbuf_init                   cmark_strbuf_init
+  #define strbuf_try_grow               cmark_strbuf_try_grow
+  #define strbuf_grow                   cmark_strbuf_grow
+  #define strbuf_free                   cmark_strbuf_free
+  #define strbuf_swap                   cmark_strbuf_swap
+  #define strbuf_oom                    cmark_strbuf_oom
+  #define strbuf_len                    cmark_strbuf_len
+  #define strbuf_cmp                    cmark_strbuf_cmp
+  #define strbuf_attach                 cmark_strbuf_attach
+  #define strbuf_detach                 cmark_strbuf_detach
+  #define strbuf_copy_cstr              cmark_strbuf_copy_cstr
+  #define strbuf_cstr                   cmark_strbuf_cstr
+  #define strbuf_at                     cmark_strbuf_at
+  #define strbuf_set                    cmark_strbuf_set
+  #define strbuf_sets                   cmark_strbuf_sets
+  #define strbuf_putc                   cmark_strbuf_putc
+  #define strbuf_put                    cmark_strbuf_put
+  #define strbuf_puts                   cmark_strbuf_puts
+  #define strbuf_printf                 cmark_strbuf_printf
+  #define strbuf_vprintf                cmark_strbuf_vprintf
+  #define strbuf_clear                  cmark_strbuf_clear
+  #define strbuf_strchr                 cmark_strbuf_strchr
+  #define strbuf_strrchr                cmark_strbuf_strrchr
+  #define strbuf_drop                   cmark_strbuf_drop
+  #define strbuf_truncate               cmark_strbuf_truncate
+  #define strbuf_rtrim                  cmark_strbuf_rtrim
+  #define strbuf_trim                   cmark_strbuf_trim
+  #define strbuf_normalize_whitespace   cmark_strbuf_normalize_whitespace
+  #define strbuf_unescape               cmark_strbuf_unescape
+#endif
 
 #endif

diff --git a/src/chunk.h b/src/chunk.h
@@ -11,9 +11,9 @@ typedef struct {
 	const unsigned char *data;
 	int len;
 	int alloc;
-} chunk;
+} cmark_chunk;
 
-static inline void chunk_free(chunk *c)
+static inline void cmark_chunk_free(cmark_chunk *c)
 {
 	if (c->alloc)
 		free((char *)c->data);
@@ -23,7 +23,7 @@ static inline void chunk_free(chunk *c)
 	c->len = 0;
 }
 
-static inline void chunk_ltrim(chunk *c)
+static inline void cmark_chunk_ltrim(cmark_chunk *c)
 {
 	assert(!c->alloc);
 
@@ -33,7 +33,7 @@ static inline void chunk_ltrim(chunk *c)
 	}
 }
 
-static inline void chunk_rtrim(chunk *c)
+static inline void cmark_chunk_rtrim(cmark_chunk *c)
 {
 	while (c->len > 0) {
 		if (!isspace(c->data[c->len - 1]))
@@ -43,19 +43,19 @@ static inline void chunk_rtrim(chunk *c)
 	}
 }
 
-static inline void chunk_trim(chunk *c)
+static inline void cmark_chunk_trim(cmark_chunk *c)
 {
-	chunk_ltrim(c);
-	chunk_rtrim(c);
+	cmark_chunk_ltrim(c);
+	cmark_chunk_rtrim(c);
 }
 
-static inline int chunk_strchr(chunk *ch, int c, int offset)
+static inline int cmark_chunk_strchr(cmark_chunk *ch, int c, int offset)
 {
 	const unsigned char *p = memchr(ch->data + offset, c, ch->len - offset);
 	return p ? (int)(p - ch->data) : ch->len;
 }
 
-static inline unsigned char *chunk_to_cstr(chunk *c)
+static inline unsigned char *cmark_chunk_to_cstr(cmark_chunk *c)
 {
 	unsigned char *str;
 
@@ -67,27 +67,40 @@ static inline unsigned char *chunk_to_cstr(chunk *c)
 	return str;
 }
 
-static inline chunk chunk_literal(const char *data)
+static inline cmark_chunk cmark_chunk_literal(const char *data)
 {
-	chunk c = {(const unsigned char *)data, data ? strlen(data) : 0, 0};
+	cmark_chunk c = {(const unsigned char *)data, data ? strlen(data) : 0, 0};
 	return c;
 }
 
-static inline chunk chunk_dup(const chunk *ch, int pos, int len)
+static inline cmark_chunk cmark_chunk_dup(const cmark_chunk *ch, int pos, int len)
 {
-	chunk c = {ch->data + pos, len, 0};
+	cmark_chunk c = {ch->data + pos, len, 0};
 	return c;
 }
 
-static inline chunk chunk_buf_detach(strbuf *buf)
+static inline cmark_chunk cmark_chunk_buf_detach(cmark_strbuf *buf)
 {
-	chunk c;
+	cmark_chunk c;
 
 	c.len = buf->size;
-	c.data = strbuf_detach(buf);
+	c.data = cmark_strbuf_detach(buf);
 	c.alloc = 1;
 
 	return c;
 }
 
+#ifndef CMARK_NO_SHORT_NAMES
+  #define chunk             cmark_chunk
+  #define chunk_free        cmark_chunk_free
+  #define chunk_ltrim       cmark_chunk_ltrim
+  #define chunk_rtrim       cmark_chunk_rtrim
+  #define chunk_trim        cmark_chunk_trim
+  #define chunk_strchr      cmark_chunk_strchr
+  #define chunk_to_cstr     cmark_chunk_to_cstr
+  #define chunk_literal     cmark_chunk_literal
+  #define chunk_dup         cmark_chunk_dup
+  #define chunk_buf_detach  cmark_chunk_buf_detach
+#endif
+
 #endif

diff --git a/src/cmark.h b/src/cmark.h
@@ -11,39 +11,39 @@
 extern "C" {
 #endif
 
-#define VERSION "0.1"
-#define CODE_INDENT 4
+#define CMARK_VERSION "0.1"
+#define CMARK_CODE_INDENT 4
 
-#define MAX_LINK_LABEL_LENGTH 1000
+#define CMARK_MAX_LINK_LABEL_LENGTH 1000
 
-struct node_inl {
+struct cmark_node_inl {
 	enum {
-		INL_STRING,
-		INL_SOFTBREAK,
-		INL_LINEBREAK,
-		INL_CODE,
-		INL_RAW_HTML,
-		INL_EMPH,
-		INL_STRONG,
-		INL_LINK,
-		INL_IMAGE
+		CMARK_INL_STRING,
+		CMARK_INL_SOFTBREAK,
+		CMARK_INL_LINEBREAK,
+		CMARK_INL_CODE,
+		CMARK_INL_RAW_HTML,
+		CMARK_INL_EMPH,
+		CMARK_INL_STRONG,
+		CMARK_INL_LINK,
+		CMARK_INL_IMAGE
 	} tag;
 	union {
-		chunk literal;
-		struct node_inl *inlines;
+		cmark_chunk literal;
+		struct cmark_node_inl *inlines;
 		struct {
-			struct node_inl *label;
+			struct cmark_node_inl *label;
 			unsigned char *url;
 			unsigned char *title;
 		} linkable;
 	} content;
-	struct node_inl *next;
+	struct cmark_node_inl *next;
 };
 
-typedef struct node_inl node_inl;
+typedef struct cmark_node_inl cmark_node_inl;
 
 // Types for blocks
-struct ListData {
+struct cmark_ListData {
 	enum {
 		bullet,
 		ordered
@@ -59,67 +59,98 @@ struct ListData {
 	bool              tight;
 };
 
-struct FencedCodeData {
+struct cmark_FencedCodeData {
 	int               fence_length;
 	int               fence_offset;
 	unsigned char     fence_char;
-	strbuf            info;
+	cmark_strbuf      info;
 };
 
-struct node_block {
+struct cmark_node_block {
 	enum {
-		BLOCK_DOCUMENT,
-		BLOCK_BQUOTE,
-		BLOCK_LIST,
-		BLOCK_LIST_ITEM,
-		BLOCK_FENCED_CODE,
-		BLOCK_INDENTED_CODE,
-		BLOCK_HTML,
-		BLOCK_PARAGRAPH,
-		BLOCK_ATX_HEADER,
-		BLOCK_SETEXT_HEADER,
-		BLOCK_HRULE,
-		BLOCK_REFERENCE_DEF
+		CMARK_BLOCK_DOCUMENT,
+		CMARK_BLOCK_BQUOTE,
+		CMARK_BLOCK_LIST,
+		CMARK_BLOCK_LIST_ITEM,
+		CMARK_BLOCK_FENCED_CODE,
+		CMARK_BLOCK_INDENTED_CODE,
+		CMARK_BLOCK_HTML,
+		CMARK_BLOCK_PARAGRAPH,
+		CMARK_BLOCK_ATX_HEADER,
+		CMARK_BLOCK_SETEXT_HEADER,
+		CMARK_BLOCK_HRULE,
+		CMARK_BLOCK_REFERENCE_DEF
 	} tag;
 	int start_line;
 	int start_column;
 	int end_line;
 	bool open;
 	bool last_line_blank;
-	struct node_block* children;
-	struct node_block* last_child;
-	struct node_block* parent;
-	struct node_block* top;
-	strbuf string_content;
-	node_inl* inline_content;
+	struct cmark_node_block* children;
+	struct cmark_node_block* last_child;
+	struct cmark_node_block* parent;
+	struct cmark_node_block* top;
+	cmark_strbuf string_content;
+	cmark_node_inl* inline_content;
 
 	union  {
-		struct ListData list;
-		struct FencedCodeData code;
+		struct cmark_ListData list;
+		struct cmark_FencedCodeData code;
 		struct {
 			int level;
 		} header;
 		struct {
-			reference_map *refmap;
+			cmark_reference_map *refmap;
 		} document;
 	} as;
 
-	struct node_block *next;
-	struct node_block *prev;
+	struct cmark_node_block *next;
+	struct cmark_node_block *prev;
 };
 
-typedef struct node_block node_block;
+typedef struct cmark_node_block cmark_node_block;
 
-node_block *cmark_parse_document(const unsigned char *buffer, size_t len);
-node_block *cmark_parse_file(FILE *f);
+cmark_node_block *cmark_parse_document(const unsigned char *buffer, size_t len);
+cmark_node_block *cmark_parse_file(FILE *f);
 
-void cmark_free_nodes(node_block *e);
+void cmark_free_nodes(cmark_node_block *e);
 
-void cmark_debug_print(node_block *root);
-void cmark_render_html(strbuf *html, node_block *root);
+void cmark_debug_print(cmark_node_block *root);
+void cmark_render_html(cmark_strbuf *html, cmark_node_block *root);
 
 unsigned char *cmark_markdown_to_html(unsigned char *text, int len);
 
+#ifndef CMARK_NO_SHORT_NAMES
+  #define VERSION                   CMARK_VERSION
+  #define CODE_INDENT               CMARK_CODE_INDENT
+  #define MAX_LINK_LABEL_LENGTH     CMARK_MAX_LINK_LABEL_LENGTH
+  #define node_inl                  cmark_node_inl
+  #define INL_STRING                CMARK_INL_STRING
+  #define INL_SOFTBREAK             CMARK_INL_SOFTBREAK
+  #define INL_LINEBREAK             CMARK_INL_LINEBREAK
+  #define INL_CODE                  CMARK_INL_CODE
+  #define INL_RAW_HTML              CMARK_INL_RAW_HTML
+  #define INL_EMPH                  CMARK_INL_EMPH
+  #define INL_STRONG                CMARK_INL_STRONG
+  #define INL_LINK                  CMARK_INL_LINK
+  #define INL_IMAGE                 CMARK_INL_IMAGE
+  #define ListData                  cmark_ListData
+  #define FencedCodeData            cmark_FencedCodeData
+  #define node_block                cmark_node_block
+  #define BLOCK_DOCUMENT            CMARK_BLOCK_DOCUMENT
+  #define BLOCK_BQUOTE              CMARK_BLOCK_BQUOTE
+  #define BLOCK_LIST                CMARK_BLOCK_LIST
+  #define BLOCK_LIST_ITEM           CMARK_BLOCK_LIST_ITEM
+  #define BLOCK_FENCED_CODE         CMARK_BLOCK_FENCED_CODE
+  #define BLOCK_INDENTED_CODE       CMARK_BLOCK_INDENTED_CODE
+  #define BLOCK_HTML                CMARK_BLOCK_HTML
+  #define BLOCK_PARAGRAPH           CMARK_BLOCK_PARAGRAPH
+  #define BLOCK_ATX_HEADER          CMARK_BLOCK_ATX_HEADER
+  #define BLOCK_SETEXT_HEADER       CMARK_BLOCK_SETEXT_HEADER
+  #define BLOCK_HRULE               CMARK_BLOCK_HRULE
+  #define BLOCK_REFERENCE_DEF       CMARK_BLOCK_REFERENCE_DEF
+#endif
+
 #ifdef __cplusplus
 }
 #endif

diff --git a/src/inlines.c b/src/inlines.c
@@ -112,7 +112,7 @@ inline static node_inl* make_simple(int t)
 #define make_strong(contents) make_inlines(INL_STRONG, contents)
 
 // Utility function used by free_inlines
-void splice_into_list(node_inl* e, node_inl* children) {
+static void splice_into_list(node_inl* e, node_inl* children) {
 	node_inl * tmp;
 	if (children) {
 		tmp = children;
@@ -948,7 +948,7 @@ extern node_inl* parse_inlines(strbuf *input, reference_map *refmap)
 }
 
 // Parse zero or more space characters, including at most one newline.
-void spnl(subject* subj)
+static void spnl(subject* subj)
 {
 	bool seen_newline = false;
 	while (peek_char(subj) == ' ' ||

diff --git a/src/inlines.h b/src/inlines.h
@@ -1,13 +1,22 @@
 #ifndef _INLINES_H_
 #define _INLINES_H_
 
-unsigned char *clean_url(chunk *url);
-unsigned char *clean_autolink(chunk *url, int is_email);
-unsigned char *clean_title(chunk *title);
+unsigned char *cmark_clean_url(cmark_chunk *url);
+unsigned char *cmark_clean_autolink(cmark_chunk *url, int is_email);
+unsigned char *cmark_clean_title(cmark_chunk *title);
 
-node_inl* parse_inlines(strbuf *input, reference_map *refmap);
-void free_inlines(node_inl* e);
+cmark_node_inl* cmark_parse_inlines(cmark_strbuf *input, cmark_reference_map *refmap);
+void cmark_free_inlines(cmark_node_inl* e);
 
-int parse_reference_inline(strbuf *input, reference_map *refmap);
+int cmark_parse_reference_inline(cmark_strbuf *input, cmark_reference_map *refmap);
+
+#ifndef CMARK_NO_SHORT_NAMES
+  #define clean_url                 cmark_clean_url
+  #define clean_autolink            cmark_clean_autolink
+  #define clean_title               cmark_clean_title
+  #define parse_inlines             cmark_parse_inlines
+  #define free_inlines              cmark_free_inlines
+  #define parse_reference_inline    cmark_parse_reference_inline
+#endif
 
 #endif

diff --git a/src/references.h b/src/references.h
@@ -3,25 +3,34 @@
 
 #define REFMAP_SIZE 16
 
-struct reference {
-	struct reference *next;
+struct cmark_reference {
+	struct cmark_reference *next;
 	unsigned char *label;
 	unsigned char *url;
 	unsigned char *title;
 	unsigned int hash;
 };
 
-typedef struct reference reference;
+typedef struct cmark_reference cmark_reference;
 
-struct reference_map {
-	reference *table[REFMAP_SIZE];
+struct cmark_reference_map {
+	cmark_reference *table[REFMAP_SIZE];
 };
 
-typedef struct reference_map reference_map;
+typedef struct cmark_reference_map cmark_reference_map;
 
-reference_map *reference_map_new(void);
-void reference_map_free(reference_map *map);
-reference* reference_lookup(reference_map *map, chunk *label);
-extern void reference_create(reference_map *map, chunk *label, chunk *url, chunk *title);
+cmark_reference_map *cmark_reference_map_new(void);
+void cmark_reference_map_free(cmark_reference_map *map);
+cmark_reference* cmark_reference_lookup(cmark_reference_map *map, cmark_chunk *label);
+extern void cmark_reference_create(cmark_reference_map *map, cmark_chunk *label, cmark_chunk *url, cmark_chunk *title);
+
+#ifndef CMARK_NO_SHORT_NAMES
+  #define reference             cmark_reference
+  #define reference_map         cmark_reference_map
+  #define reference_map_new     cmark_reference_map_new
+  #define reference_map_free    cmark_reference_map_free
+  #define reference_lookup      cmark_reference_lookup
+  #define reference_create      cmark_reference_create
+#endif
 
 #endif

diff --git a/src/utf8.h b/src/utf8.h
@@ -4,10 +4,10 @@
 #include <stdint.h>
 #include "buffer.h"
 
-void utf8proc_case_fold(strbuf *dest, const uint8_t *str, int len);
-void utf8proc_encode_char(int32_t uc, strbuf *buf);
+void utf8proc_case_fold(cmark_strbuf *dest, const uint8_t *str, int len);
+void utf8proc_encode_char(int32_t uc, cmark_strbuf *buf);
 int utf8proc_iterate(const uint8_t *str, int str_len, int32_t *dst);
 int utf8proc_charlen(const uint8_t *str, int str_len);
-void utf8proc_detab(strbuf *dest, const uint8_t *line, size_t size);
+void utf8proc_detab(cmark_strbuf *dest, const uint8_t *line, size_t size);
 
 #endif