diff --git a/api_test/main.c b/api_test/main.c
index a95abc314..1fd851165 100644
--- a/api_test/main.c
+++ b/api_test/main.c
@@ -479,7 +479,7 @@ static void test_content(test_batch_runner *runner, cmark_node_type type,
     int expected = 0;
     if (allowed_content)
         for (unsigned int *p = allowed_content; *p; ++p)
-            expected |= *p == child_type;
+            expected |= *p == (unsigned int)child_type;
 
     INT_EQ(runner, got, expected, "add %d as child of %d", child_type, type);
 
diff --git a/extensions/CMakeLists.txt b/extensions/CMakeLists.txt
index 8d12a530c..50d0f2338 100644
--- a/extensions/CMakeLists.txt
+++ b/extensions/CMakeLists.txt
@@ -68,7 +68,7 @@ if(MSVC)
   else()
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W4")
   endif()
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4706 /D_CRT_SECURE_NO_WARNINGS")
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /WX /wd4706 /wd4204 /wd4221 /wd4100 /D_CRT_SECURE_NO_WARNINGS")
 elseif(CMAKE_COMPILER_IS_GNUCC OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -Wno-unused-parameter -std=c99 -pedantic")
 endif()
diff --git a/extensions/autolink.c b/extensions/autolink.c
index 148463d33..f40fc8c02 100644
--- a/extensions/autolink.c
+++ b/extensions/autolink.c
@@ -75,7 +75,7 @@ static size_t autolink_delim(uint8_t *data, size_t link_end) {
     } else if (copen != 0) {
       size_t closing = 0;
       size_t opening = 0;
-      size_t i = 0;
+      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
@@ -176,18 +176,19 @@ static cmark_node *www_match(cmark_parser *parser, cmark_node *parent,
   if (link_end == 0)
     return NULL;
 
-  cmark_inline_parser_set_offset(inline_parser, max_rewind + link_end);
+  cmark_inline_parser_set_offset(inline_parser, (int)(max_rewind + link_end));
 
   cmark_node *node = cmark_node_new_with_mem(CMARK_NODE_LINK, parser->mem);
 
   cmark_strbuf buf;
   cmark_strbuf_init(parser->mem, &buf, 10);
   cmark_strbuf_puts(&buf, "http://");
-  cmark_strbuf_put(&buf, data, link_end);
+  cmark_strbuf_put(&buf, data, (bufsize_t)link_end);
   node->as.link.url = cmark_chunk_buf_detach(&buf);
 
   cmark_node *text = cmark_node_new_with_mem(CMARK_NODE_TEXT, parser->mem);
-  text->as.literal = cmark_chunk_dup(chunk, max_rewind, link_end);
+  text->as.literal =
+      cmark_chunk_dup(chunk, (bufsize_t)max_rewind, (bufsize_t)link_end);
   cmark_node_append_child(node, text);
 
   return node;
@@ -195,11 +196,12 @@ static cmark_node *www_match(cmark_parser *parser, cmark_node *parent,
 
 static cmark_node *email_match(cmark_parser *parser, cmark_node *parent,
                                cmark_inline_parser *inline_parser) {
-  size_t link_end, rewind;
+  size_t link_end;
+  int rewind;
   int nb = 0, np = 0, ns = 0;
 
   cmark_chunk *chunk = cmark_inline_parser_get_chunk(inline_parser);
-  size_t max_rewind = cmark_inline_parser_get_offset(inline_parser);
+  int max_rewind = cmark_inline_parser_get_offset(inline_parser);
   uint8_t *data = chunk->data + max_rewind;
   size_t size = chunk->len - max_rewind;
 
@@ -244,7 +246,7 @@ static cmark_node *email_match(cmark_parser *parser, cmark_node *parent,
   if (link_end == 0)
     return NULL;
 
-  cmark_inline_parser_set_offset(inline_parser, max_rewind + link_end);
+  cmark_inline_parser_set_offset(inline_parser, (int)(max_rewind + link_end));
   cmark_node_unput(parent, rewind);
 
   cmark_node *node = cmark_node_new_with_mem(CMARK_NODE_LINK, parser->mem);
@@ -252,12 +254,12 @@ static cmark_node *email_match(cmark_parser *parser, cmark_node *parent,
   cmark_strbuf buf;
   cmark_strbuf_init(parser->mem, &buf, 10);
   cmark_strbuf_puts(&buf, "mailto:");
-  cmark_strbuf_put(&buf, data - rewind, link_end + rewind);
+  cmark_strbuf_put(&buf, data - rewind, (bufsize_t)(link_end + rewind));
   node->as.link.url = cmark_chunk_buf_detach(&buf);
 
   cmark_node *text = cmark_node_new_with_mem(CMARK_NODE_TEXT, parser->mem);
-  text->as.literal =
-      cmark_chunk_dup(chunk, max_rewind - rewind, link_end + rewind);
+  text->as.literal = cmark_chunk_dup(chunk, max_rewind - rewind,
+                                     (bufsize_t)(link_end + rewind));
   cmark_node_append_child(node, text);
 
   return node;
@@ -265,10 +267,11 @@ static cmark_node *email_match(cmark_parser *parser, cmark_node *parent,
 
 static cmark_node *url_match(cmark_parser *parser, cmark_node *parent,
                              cmark_inline_parser *inline_parser) {
-  size_t link_end, rewind = 0, domain_len;
+  size_t link_end, domain_len;
+  int rewind = 0;
 
   cmark_chunk *chunk = cmark_inline_parser_get_chunk(inline_parser);
-  size_t max_rewind = cmark_inline_parser_get_offset(inline_parser);
+  int max_rewind = cmark_inline_parser_get_offset(inline_parser);
   uint8_t *data = chunk->data + max_rewind;
   size_t size = chunk->len - max_rewind;
 
@@ -297,13 +300,13 @@ static cmark_node *url_match(cmark_parser *parser, cmark_node *parent,
   if (link_end == 0)
     return NULL;
 
-  cmark_inline_parser_set_offset(inline_parser, max_rewind + link_end);
+  cmark_inline_parser_set_offset(inline_parser, (int)(max_rewind + link_end));
   cmark_node_unput(parent, rewind);
 
   cmark_node *node = cmark_node_new_with_mem(CMARK_NODE_LINK, parser->mem);
 
-  cmark_chunk url =
-      cmark_chunk_dup(chunk, max_rewind - rewind, link_end + rewind);
+  cmark_chunk url = cmark_chunk_dup(chunk, max_rewind - rewind,
+                                    (bufsize_t)(link_end + rewind));
   node->as.link.url = url;
 
   cmark_node *text = cmark_node_new_with_mem(CMARK_NODE_TEXT, parser->mem);
diff --git a/extensions/table.c b/extensions/table.c
index dc74cdf68..cd75bbd9b 100644
--- a/extensions/table.c
+++ b/extensions/table.c
@@ -30,18 +30,18 @@ typedef enum {
 typedef struct { bool is_header; } node_table_row;
 
 static void free_node_table(cmark_mem *mem, void *ptr) {
-  node_table *t = ptr;
+  node_table *t = (node_table *)ptr;
   mem->free(t->alignments);
   mem->free(t);
 }
 
 static void free_node_table_row(cmark_mem *mem, void *ptr) { mem->free(ptr); }
 
-static uint16_t get_n_table_columns(cmark_node *node) {
+static int get_n_table_columns(cmark_node *node) {
   if (!node || node->type != CMARK_NODE_TABLE)
     return -1;
 
-  return ((node_table *)node->user_data)->n_columns;
+  return (int)((node_table *)node->user_data)->n_columns;
 }
 
 static int set_n_table_columns(cmark_node *node, uint16_t n_columns) {
@@ -71,7 +71,7 @@ static int is_table_header(cmark_node *node, int is_table_header) {
   if (!node || node->type != CMARK_NODE_TABLE_ROW)
     return 0;
 
-  ((node_table_row *)node->user_data)->is_header = is_table_header;
+  ((node_table_row *)node->user_data)->is_header = (is_table_header != 0);
   return 1;
 }
 
@@ -159,7 +159,7 @@ static cmark_node *consume_until_pipe_or_eol(cmark_syntax_extension *self,
                                             (*n)->as.literal.len - *offset);
         cmark_node_own(child);
       } else {
-        int len = pipe - cstr - *offset;
+        int len = (int)(pipe - cstr - *offset);
         child->as.literal = cmark_chunk_dup(&(*n)->as.literal, *offset, len);
         cmark_node_own(child);
         *offset += len + 1;
@@ -245,7 +245,7 @@ static cmark_node *try_opening_table_header(cmark_syntax_extension *self,
   parent_string = cmark_node_get_string_content(parent_container);
 
   header_row = row_from_string(self, parser, (unsigned char *)parent_string,
-                               strlen(parent_string));
+                               (int)strlen(parent_string));
 
   if (!header_row) {
     goto done;
@@ -274,10 +274,10 @@ static cmark_node *try_opening_table_header(cmark_syntax_extension *self,
   set_n_table_columns(parent_container, header_row->n_columns);
 
   uint8_t *alignments =
-      parser->mem->calloc(header_row->n_columns, sizeof(uint8_t));
+      (uint8_t *)parser->mem->calloc(header_row->n_columns, sizeof(uint8_t));
   cmark_llist *it = marker_row->cells;
   for (i = 0; it; it = it->next, ++i) {
-    cmark_node *node = it->data;
+    cmark_node *node = (cmark_node *)it->data;
     assert(node->type == CMARK_NODE_TABLE_CELL);
 
     cmark_strbuf strbuf;
@@ -315,7 +315,7 @@ static cmark_node *try_opening_table_header(cmark_syntax_extension *self,
     cmark_llist *tmp, *next;
 
     for (tmp = header_row->cells; tmp; tmp = next) {
-      cmark_node *header_cell = tmp->data;
+      cmark_node *header_cell = (cmark_node *)tmp->data;
       cmark_node_append_child(table_header, header_cell);
       next = header_row->cells = tmp->next;
       parser->mem->free(tmp);
@@ -324,7 +324,7 @@ static cmark_node *try_opening_table_header(cmark_syntax_extension *self,
 
   cmark_parser_advance_offset(
       parser, (char *)input,
-      strlen((char *)input) - 1 - cmark_parser_get_offset(parser), false);
+      (int)strlen((char *)input) - 1 - cmark_parser_get_offset(parser), false);
 done:
   free_table_row(parser->mem, header_row);
   free_table_row(parser->mem, marker_row);
@@ -362,7 +362,7 @@ static cmark_node *try_opening_table_row(cmark_syntax_extension *self,
     int table_columns = get_n_table_columns(parent_container);
 
     for (tmp = row->cells, i = 0; tmp && i < table_columns; tmp = next, ++i) {
-      cmark_node *cell = tmp->data;
+      cmark_node *cell = (cmark_node *)tmp->data;
       assert(cell->type == CMARK_NODE_TABLE_CELL);
       cmark_node_append_child(table_row_block, cell);
       row->cells = next = tmp->next;
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index b90ed9a77..6d3446d7c 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -199,7 +199,7 @@ if(MSVC)
   else()
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /W4")
   endif()
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4706 /D_CRT_SECURE_NO_WARNINGS")
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /WX /wd4706 /wd4204 /wd4221 /wd4100 /D_CRT_SECURE_NO_WARNINGS")
 elseif(CMAKE_COMPILER_IS_GNUCC OR "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -Wno-unused-parameter -std=c99 -pedantic")
 endif()
diff --git a/src/arena.c b/src/arena.c
index 1a30a97c0..0f31cf333 100644
--- a/src/arena.c
+++ b/src/arena.c
@@ -10,7 +10,7 @@ static struct arena_chunk {
 } *A = NULL;
 
 static struct arena_chunk *alloc_arena_chunk(size_t sz, struct arena_chunk *prev) {
-  struct arena_chunk *c = calloc(1, sizeof(*c));
+  struct arena_chunk *c = (struct arena_chunk *)calloc(1, sizeof(*c));
   if (!c)
     abort();
   c->sz = sz;
diff --git a/src/blocks.c b/src/blocks.c
index 1efda3d71..f809882c9 100644
--- a/src/blocks.c
+++ b/src/blocks.c
@@ -181,7 +181,7 @@ static CMARK_INLINE bool accepts_lines(cmark_node_type block_type) {
 
 static CMARK_INLINE bool contains_inlines(cmark_node *node) {
   if (node->extension && node->extension->contains_inlines_func) {
-    return node->extension->contains_inlines_func(node->extension, node);
+    return node->extension->contains_inlines_func(node->extension, node) != 0;
   }
 
   return (node->type == CMARK_NODE_PARAGRAPH ||
@@ -392,7 +392,7 @@ void cmark_manage_extensions_special_characters(cmark_parser *parser, bool add)
     cmark_syntax_extension *ext = (cmark_syntax_extension *) tmp_ext->data;
     cmark_llist *tmp_char;
     for (tmp_char = ext->special_inline_chars; tmp_char; tmp_char=tmp_char->next) {
-      unsigned char c = (unsigned char) (unsigned long) tmp_char->data;
+      unsigned char c = (unsigned char)(size_t)tmp_char->data;
       if (add)
         cmark_inlines_add_special_character(c);
       else
@@ -607,7 +607,7 @@ static void S_parser_feed(cmark_parser *parser, const unsigned char *buffer,
       process = true;
     }
 
-    chunk_len = (eol - buffer);
+    chunk_len = (bufsize_t)(eol - buffer);
     if (process) {
       if (parser->linebuf.size > 0) {
         cmark_strbuf_put(&parser->linebuf, buffer, chunk_len);
@@ -987,7 +987,7 @@ static void open_new_blocks(cmark_parser *parser, cmark_node **container,
                              parser->first_nonspace + 1);
       (*container)->as.code.fenced = true;
       (*container)->as.code.fence_char = peek_at(input, parser->first_nonspace);
-      (*container)->as.code.fence_length = (matched > 255) ? 255 : matched;
+      (*container)->as.code.fence_length = (matched > 255) ? 255 : (uint8_t)matched;
       (*container)->as.code.fence_offset =
           (int8_t)(parser->first_nonspace - parser->offset);
       (*container)->as.code.info = cmark_chunk_literal("");
@@ -1383,5 +1383,5 @@ void cmark_parser_advance_offset(cmark_parser *parser,
                                  int columns) {
   cmark_chunk input_chunk = cmark_chunk_literal(input);
 
-  S_advance_offset(parser, &input_chunk, count, columns);
+  S_advance_offset(parser, &input_chunk, count, columns != 0);
 }
diff --git a/src/buffer.c b/src/buffer.c
index a237b11b3..75733d402 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -96,7 +96,7 @@ void cmark_strbuf_set(cmark_strbuf *buf, const unsigned char *data,
 
 void cmark_strbuf_sets(cmark_strbuf *buf, const char *string) {
   cmark_strbuf_set(buf, (const unsigned char *)string,
-                   string ? strlen(string) : 0);
+                   string ? (bufsize_t)strlen(string) : 0);
 }
 
 void cmark_strbuf_putc(cmark_strbuf *buf, int c) {
@@ -117,7 +117,7 @@ void cmark_strbuf_put(cmark_strbuf *buf, const unsigned char *data,
 }
 
 void cmark_strbuf_puts(cmark_strbuf *buf, const char *string) {
-  cmark_strbuf_put(buf, (const unsigned char *)string, strlen(string));
+  cmark_strbuf_put(buf, (const unsigned char *)string, (bufsize_t)strlen(string));
 }
 
 void cmark_strbuf_copy_cstr(char *data, bufsize_t datasize,
diff --git a/src/cmark.c b/src/cmark.c
index 5758da90c..dd013d2ce 100644
--- a/src/cmark.c
+++ b/src/cmark.c
@@ -32,7 +32,11 @@ static void *xrealloc(void *ptr, size_t size) {
   return new_ptr;
 }
 
-cmark_mem CMARK_DEFAULT_MEM_ALLOCATOR = {xcalloc, xrealloc, free};
+static void xfree(void *ptr) {
+  free(ptr);
+}
+
+cmark_mem CMARK_DEFAULT_MEM_ALLOCATOR = {xcalloc, xrealloc, xfree};
 
 cmark_mem *cmark_get_default_mem_allocator() {
   return &CMARK_DEFAULT_MEM_ALLOCATOR;
diff --git a/src/commonmark.c b/src/commonmark.c
index 9be9d59ee..7b7cc875d 100644
--- a/src/commonmark.c
+++ b/src/commonmark.c
@@ -42,13 +42,13 @@ static CMARK_INLINE void outc(cmark_renderer *renderer, cmark_escaping escape,
          (renderer->begin_content && (c == '.' || c == ')') && follows_digit &&
           (nextc == 0 || cmark_isspace(nextc))))) ||
        (escape == URL &&
-        (c == '`' || c == '<' || c == '>' || cmark_isspace(c) || c == '\\' ||
+        (c == '`' || c == '<' || c == '>' || cmark_isspace((char)c) || c == '\\' ||
          c == ')' || c == '(')) ||
        (escape == TITLE &&
         (c == '`' || c == '<' || c == '>' || c == '"' || c == '\\')));
 
   if (needs_escaping) {
-    if (cmark_isspace(c)) {
+    if (cmark_isspace((char)c)) {
       // use percent encoding for spaces
       snprintf(encoded, ENCODED_SIZE, "%%%2x", c);
       cmark_strbuf_puts(renderer->buffer, encoded);
@@ -236,7 +236,7 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node,
       snprintf(listmarker, LISTMARKER_SIZE, "%d%s%s", list_number,
                list_delim == CMARK_PAREN_DELIM ? ")" : ".",
                list_number < 10 ? "  " : " ");
-      marker_width = strlen(listmarker);
+      marker_width = (bufsize_t)strlen(listmarker);
     }
     if (entering) {
       if (cmark_node_get_list_type(node->parent) == CMARK_BULLET_LIST) {
diff --git a/src/html.c b/src/html.c
index f6525f73c..951f33ecc 100644
--- a/src/html.c
+++ b/src/html.c
@@ -30,7 +30,7 @@ static void filter_html_block(cmark_html_renderer *renderer, uint8_t *data, size
       break;
 
     if (match != data) {
-      cmark_strbuf_put(html, data, match - data);
+      cmark_strbuf_put(html, data, (bufsize_t)(match - data));
       len -= (match - data);
       data = match;
     }
@@ -55,7 +55,7 @@ static void filter_html_block(cmark_html_renderer *renderer, uint8_t *data, size
   }
 
   if (len)
-    cmark_strbuf_put(html, data, len);
+    cmark_strbuf_put(html, data, (bufsize_t)len);
 }
 
 static int S_render_node(cmark_html_renderer *renderer, cmark_node *node,
diff --git a/src/inlines.c b/src/inlines.c
index db3bc2143..434c06262 100644
--- a/src/inlines.c
+++ b/src/inlines.c
@@ -72,7 +72,7 @@ static CMARK_INLINE cmark_node *make_literal(cmark_mem *mem, cmark_node_type t,
                                              cmark_chunk s) {
   cmark_node *e = (cmark_node *)mem->calloc(1, sizeof(*e));
   cmark_strbuf_init(mem, &e->content, 0);
-  e->type = t;
+  e->type = (uint16_t)t;
   e->as.literal = s;
   return e;
 }
@@ -81,7 +81,7 @@ static CMARK_INLINE cmark_node *make_literal(cmark_mem *mem, cmark_node_type t,
 static CMARK_INLINE cmark_node *make_simple(cmark_mem *mem, cmark_node_type t) {
   cmark_node *e = (cmark_node *)mem->calloc(1, sizeof(*e));
   cmark_strbuf_init(mem, &e->content, 0);
-  e->type = t;
+  e->type = (uint16_t)t;
   return e;
 }
 
@@ -508,7 +508,7 @@ static cmark_syntax_extension *get_extension_for_special_char(cmark_parser *pars
     cmark_syntax_extension *ext = (cmark_syntax_extension *) tmp_ext->data;
     cmark_llist *tmp_char;
     for (tmp_char = ext->special_inline_chars; tmp_char; tmp_char=tmp_char->next) {
-      unsigned char tmp_c = (unsigned char) (unsigned long) tmp_char->data;
+      unsigned char tmp_c = (unsigned char)(size_t)tmp_char->data;
 
       if (tmp_c == c) {
         return ext;
@@ -1340,7 +1340,7 @@ void cmark_inline_parser_push_delimiter(cmark_inline_parser *parser,
                                   int can_open,
                                   int can_close,
                                   cmark_node *inl_text) {
-  push_delimiter(parser, c, can_open, can_close, inl_text);
+  push_delimiter(parser, c, can_open != 0, can_close != 0, inl_text);
 }
 
 void cmark_inline_parser_remove_delimiter(cmark_inline_parser *parser, delimiter *delim) {
@@ -1389,8 +1389,8 @@ int cmark_inline_parser_scan_delimiters(cmark_inline_parser *parser,
 
   *punct_before = cmark_utf8proc_is_punctuation(before_char);
   *punct_after = cmark_utf8proc_is_punctuation(after_char);
-  space_before = cmark_utf8proc_is_space(before_char);
-  space_after = cmark_utf8proc_is_space(after_char);
+  space_before = cmark_utf8proc_is_space(before_char) != 0;
+  space_after = cmark_utf8proc_is_space(after_char) != 0;
 
   *left_flanking = numdelims > 0 && !cmark_utf8proc_is_space(after_char) &&
                   !(*punct_after && !space_before && !*punct_before);
@@ -1418,7 +1418,7 @@ cmark_chunk *cmark_inline_parser_get_chunk(cmark_inline_parser *parser) {
 
 int cmark_inline_parser_in_bracket(cmark_inline_parser *parser, int image) {
   for (bracket *b = parser->last_bracket; b; b = b->previous)
-    if (b->active && b->image == image)
+    if (b->active && b->image == (image != 0))
       return 1;
   return 0;
 }
diff --git a/src/node.c b/src/node.c
index 266cf2509..0098b026b 100644
--- a/src/node.c
+++ b/src/node.c
@@ -15,7 +15,7 @@ bool cmark_node_can_contain_type(cmark_node *node, cmark_node_type child_type) {
     }
 
   if (node->extension && node->extension->can_contain_func) {
-    return node->extension->can_contain_func(node->extension, node, child_type);
+    return node->extension->can_contain_func(node->extension, node, child_type) != 0;
   }
 
   switch (node->type) {
@@ -168,18 +168,18 @@ int cmark_node_set_type(cmark_node * node, cmark_node_type type) {
     return 1;
 
   initial_type = (cmark_node_type) node->type;
-  node->type = type;
+  node->type = (uint16_t)type;
 
   if (!S_can_contain(node->parent, node)) {
-    node->type = initial_type;
+    node->type = (uint16_t)initial_type;
     return 0;
   }
 
   /* We rollback the type to free the union members appropriately */
-  node->type = initial_type;
+  node->type = (uint16_t)initial_type;
   free_node_as(node);
 
-  node->type = type;
+  node->type = (uint16_t)type;
 
   return 1;
 }
@@ -549,9 +549,9 @@ int cmark_node_set_fenced(cmark_node * node, int fenced,
   }
 
   if (node->type == CMARK_NODE_CODE_BLOCK) {
-    node->as.code.fenced = fenced;
-    node->as.code.fence_length = length;
-    node->as.code.fence_offset = offset;
+    node->as.code.fenced = (int8_t)fenced;
+    node->as.code.fence_length = (uint8_t)length;
+    node->as.code.fence_offset = (uint8_t)offset;
     node->as.code.fence_char = character;
     return 1;
   } else {
diff --git a/src/render.c b/src/render.c
index b7eabcb53..3190fd20d 100644
--- a/src/render.c
+++ b/src/render.c
@@ -20,7 +20,7 @@ static CMARK_INLINE void S_blankline(cmark_renderer *renderer) {
 
 static void S_out(cmark_renderer *renderer, const char *source, bool wrap,
                   cmark_escaping escape) {
-  int length = strlen(source);
+  int length = (int)strlen(source);
   unsigned char nextc;
   int32_t c;
   int i = 0;
@@ -95,12 +95,12 @@ static void S_out(cmark_renderer *renderer, const char *source, bool wrap,
       // we need to escape a potential list marker after
       // a digit:
       renderer->begin_content =
-          renderer->begin_content && cmark_isdigit(c) == 1;
+          renderer->begin_content && cmark_isdigit((char)c) == 1;
     } else {
       (renderer->outc)(renderer, escape, c, nextc);
       renderer->begin_line = false;
       renderer->begin_content =
-          renderer->begin_content && cmark_isdigit(c) == 1;
+          renderer->begin_content && cmark_isdigit((char)c) == 1;
     }
 
     // If adding the character went beyond width, look for an