git subrepo clone --branch=0.30.3 https://github.com/commonmark/cmark.git deps/cmark

subrepo:
  subdir:   "deps/cmark"
  merged:   "5ba25ff"
upstream:
  origin:   "https://github.com/commonmark/cmark.git"
  branch:   "0.30.3"
  commit:   "5ba25ff"
git-subrepo:
  version:  "0.4.6"
  commit:   "d4444b563"

deps/cmark/src/CMakeLists.txt

@@ -0,0 +1,207 @@
+if(${CMAKE_VERSION} VERSION_GREATER "3.3")
+    cmake_policy(SET CMP0063 NEW)
+endif()
+
+set(LIBRARY "cmark")
+set(STATICLIBRARY "cmark_static")
+set(HEADERS
+  cmark.h
+  parser.h
+  buffer.h
+  node.h
+  iterator.h
+  chunk.h
+  references.h
+  utf8.h
+  scanners.h
+  inlines.h
+  houdini.h
+  cmark_ctype.h
+  render.h
+  )
+set(LIBRARY_SOURCES
+  cmark.c
+  node.c
+  iterator.c
+  blocks.c
+  inlines.c
+  scanners.c
+  scanners.re
+  utf8.c
+  buffer.c
+  references.c
+  render.c
+  man.c
+  xml.c
+  html.c
+  commonmark.c
+  latex.c
+  houdini_href_e.c
+  houdini_html_e.c
+  houdini_html_u.c
+  cmark_ctype.c
+  ${HEADERS}
+  )
+
+set(PROGRAM "cmark_exe")
+set(PROGRAM_SOURCES main.c)
+
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/cmark_version.h.in
+  ${CMAKE_CURRENT_BINARY_DIR}/cmark_version.h)
+
+include(GNUInstallDirs)
+include (GenerateExportHeader)
+
+add_executable(${PROGRAM} ${PROGRAM_SOURCES})
+cmark_add_compile_options(${PROGRAM})
+set_target_properties(${PROGRAM} PROPERTIES
+  OUTPUT_NAME "cmark")
+
+if (CMARK_STATIC)
+  target_link_libraries(${PROGRAM} ${STATICLIBRARY})
+  # Disable the PUBLIC declarations when compiling the executable:
+  set_target_properties(${PROGRAM} PROPERTIES
+    COMPILE_FLAGS -DCMARK_STATIC_DEFINE)
+elseif (CMARK_SHARED)
+  target_link_libraries(${PROGRAM} ${LIBRARY})
+endif()
+
+# -fvisibility=hidden
+set(CMAKE_C_VISIBILITY_PRESET hidden)
+set(CMAKE_VISIBILITY_INLINES_HIDDEN 1)
+
+if (CMARK_SHARED)
+  add_library(${LIBRARY} SHARED ${LIBRARY_SOURCES})
+  cmark_add_compile_options(${LIBRARY})
+  set_target_properties(${LIBRARY} PROPERTIES
+    MACOSX_RPATH TRUE
+    OUTPUT_NAME "cmark"
+    # Avoid name clash between PROGRAM and LIBRARY pdb files.
+    PDB_NAME cmark_dll
+    # Include minor version and patch level in soname for now.
+    SOVERSION ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}
+    VERSION ${PROJECT_VERSION})
+  target_include_directories(${LIBRARY} INTERFACE
+    $<INSTALL_INTERFACE:include>
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>)
+  add_library(cmark::cmark ALIAS ${LIBRARY})
+
+  generate_export_header(${LIBRARY}
+    BASE_NAME ${PROJECT_NAME})
+
+  list(APPEND CMARK_INSTALL ${LIBRARY})
+endif()
+
+if (CMARK_STATIC)
+  add_library(${STATICLIBRARY} STATIC ${LIBRARY_SOURCES})
+  cmark_add_compile_options(${STATICLIBRARY})
+  set_target_properties(${STATICLIBRARY} PROPERTIES
+    COMPILE_FLAGS -DCMARK_STATIC_DEFINE
+    POSITION_INDEPENDENT_CODE ON
+    VERSION ${PROJECT_VERSION})
+  if(MSVC)
+    set_target_properties(${STATICLIBRARY} PROPERTIES
+      OUTPUT_NAME cmark_static)
+  else()
+    set_target_properties(${STATICLIBRARY} PROPERTIES
+      OUTPUT_NAME cmark)
+  endif()
+  target_include_directories(${STATICLIBRARY} INTERFACE
+    $<INSTALL_INTERFACE:include>
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>)
+  add_library(cmark::cmark_static ALIAS ${STATICLIBRARY})
+
+  if (NOT CMARK_SHARED)
+    generate_export_header(${STATICLIBRARY}
+      BASE_NAME ${PROJECT_NAME})
+  endif()
+
+  list(APPEND CMARK_INSTALL ${STATICLIBRARY})
+endif()
+
+if (MSVC)
+  set_property(TARGET ${PROGRAM}
+    APPEND PROPERTY LINK_FLAGS /INCREMENTAL:NO)
+endif(MSVC)
+
+if(NOT MSVC OR CMAKE_HOST_SYSTEM_NAME STREQUAL Windows)
+  set(CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_NO_WARNINGS ON)
+  include(InstallRequiredSystemLibraries)
+endif()
+
+install(TARGETS ${PROGRAM} ${CMARK_INSTALL}
+  EXPORT cmark-targets
+  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
+  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+  )
+
+if(CMARK_SHARED OR CMARK_STATIC)
+  configure_file(${CMAKE_CURRENT_SOURCE_DIR}/libcmark.pc.in
+    ${CMAKE_CURRENT_BINARY_DIR}/libcmark.pc @ONLY)
+  install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libcmark.pc
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)
+
+  install(FILES
+    cmark.h
+    ${CMAKE_CURRENT_BINARY_DIR}/cmark_export.h
+    ${CMAKE_CURRENT_BINARY_DIR}/cmark_version.h
+    DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}
+    )
+
+  # Include module for functions
+  # - 'write_basic_package_version_file'
+  # - 'configure_package_config_file'
+  include(CMakePackageConfigHelpers)
+  # generate cmark-config.cmake and cmark-config-version.cmake files
+  configure_package_config_file(
+    "cmarkConfig.cmake.in"
+    "${CMAKE_CURRENT_BINARY_DIR}/generated/cmark-config.cmake"
+    INSTALL_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/cmark")
+  write_basic_package_version_file(
+    "${CMAKE_CURRENT_BINARY_DIR}/generated/cmark-config-version.cmake"
+    VERSION ${PROJECT_VERSION}
+    COMPATIBILITY SameMajorVersion)
+  # install config and version file
+  install(
+    FILES "${CMAKE_CURRENT_BINARY_DIR}/generated/cmark-config.cmake"
+          "${CMAKE_CURRENT_BINARY_DIR}/generated/cmark-config-version.cmake"
+    DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/cmark"
+  )
+  # install targets file
+  install(
+    EXPORT "cmark-targets"
+    NAMESPACE "cmark::"
+    DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/cmark"
+  )
+
+endif()
+
+# Feature tests
+include(CheckIncludeFile)
+include(CheckCSourceCompiles)
+CHECK_INCLUDE_FILE(stdbool.h HAVE_STDBOOL_H)
+CHECK_C_SOURCE_COMPILES(
+  "int main() { __builtin_expect(0,0); return 0; }"
+  HAVE___BUILTIN_EXPECT)
+CHECK_C_SOURCE_COMPILES("
+  int f(void) __attribute__ (());
+  int main() { return 0; }
+" HAVE___ATTRIBUTE__)
+
+CONFIGURE_FILE(
+  ${CMAKE_CURRENT_SOURCE_DIR}/config.h.in
+  ${CMAKE_CURRENT_BINARY_DIR}/config.h)
+
+if(CMARK_LIB_FUZZER)
+  add_executable(cmark-fuzz ../test/cmark-fuzz.c ${LIBRARY_SOURCES})
+  cmark_add_compile_options(cmark-fuzz)
+  target_link_libraries(cmark-fuzz "${CMAKE_LIB_FUZZER_PATH}")
+
+  # cmark is written in C but the libFuzzer runtime is written in C++ which
+  # needs to link against the C++ runtime.
+  set_target_properties(cmark-fuzz PROPERTIES
+    LINKER_LANGUAGE CXX)
+endif()

deps/cmark/src/buffer.c

@@ -0,0 +1,278 @@
+#include <stdarg.h>
+#include <string.h>
+#include <assert.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <limits.h>
+
+#include "config.h"
+#include "cmark_ctype.h"
+#include "buffer.h"
+
+/* Used as default value for cmark_strbuf->ptr so that people can always
+ * assume ptr is non-NULL and zero terminated even for new cmark_strbufs.
+ */
+unsigned char cmark_strbuf__initbuf[1];
+
+#ifndef MIN
+#define MIN(x, y) ((x < y) ? x : y)
+#endif
+
+void cmark_strbuf_init(cmark_mem *mem, cmark_strbuf *buf,
+                       bufsize_t initial_size) {
+  buf->mem = mem;
+  buf->asize = 0;
+  buf->size = 0;
+  buf->ptr = cmark_strbuf__initbuf;
+
+  if (initial_size > 0)
+    cmark_strbuf_grow(buf, initial_size);
+}
+
+static CMARK_INLINE void S_strbuf_grow_by(cmark_strbuf *buf, bufsize_t add) {
+  cmark_strbuf_grow(buf, buf->size + add);
+}
+
+void cmark_strbuf_grow(cmark_strbuf *buf, bufsize_t target_size) {
+  assert(target_size > 0);
+
+  if (target_size < buf->asize)
+    return;
+
+  if (target_size > (bufsize_t)(INT32_MAX / 2)) {
+    fprintf(stderr,
+      "[cmark] cmark_strbuf_grow requests buffer with size > %d, aborting\n",
+         (INT32_MAX / 2));
+    abort();
+  }
+
+  /* Oversize the buffer by 50% to guarantee amortized linear time
+   * complexity on append operations. */
+  bufsize_t new_size = target_size + target_size / 2;
+  new_size += 1;
+  new_size = (new_size + 7) & ~7;
+
+  buf->ptr = (unsigned char *)buf->mem->realloc(buf->asize ? buf->ptr : NULL,
+                                                new_size);
+  buf->asize = new_size;
+}
+
+bufsize_t cmark_strbuf_len(const cmark_strbuf *buf) { return buf->size; }
+
+void cmark_strbuf_free(cmark_strbuf *buf) {
+  if (!buf)
+    return;
+
+  if (buf->ptr != cmark_strbuf__initbuf)
+    buf->mem->free(buf->ptr);
+
+  cmark_strbuf_init(buf->mem, buf, 0);
+}
+
+void cmark_strbuf_clear(cmark_strbuf *buf) {
+  buf->size = 0;
+
+  if (buf->asize > 0)
+    buf->ptr[0] = '\0';
+}
+
+void cmark_strbuf_set(cmark_strbuf *buf, const unsigned char *data,
+                      bufsize_t len) {
+  if (len <= 0 || data == NULL) {
+    cmark_strbuf_clear(buf);
+  } else {
+    if (data != buf->ptr) {
+      if (len >= buf->asize)
+        cmark_strbuf_grow(buf, len);
+      memmove(buf->ptr, data, len);
+    }
+    buf->size = len;
+    buf->ptr[buf->size] = '\0';
+  }
+}
+
+void cmark_strbuf_sets(cmark_strbuf *buf, const char *string) {
+  cmark_strbuf_set(buf, (const unsigned char *)string,
+                   string ? strlen(string) : 0);
+}
+
+void cmark_strbuf_putc(cmark_strbuf *buf, int c) {
+  S_strbuf_grow_by(buf, 1);
+  buf->ptr[buf->size++] = (unsigned char)(c & 0xFF);
+  buf->ptr[buf->size] = '\0';
+}
+
+void cmark_strbuf_put(cmark_strbuf *buf, const unsigned char *data,
+                      bufsize_t len) {
+  if (len <= 0)
+    return;
+
+  S_strbuf_grow_by(buf, len);
+  memmove(buf->ptr + buf->size, data, len);
+  buf->size += len;
+  buf->ptr[buf->size] = '\0';
+}
+
+void cmark_strbuf_puts(cmark_strbuf *buf, const char *string) {
+  cmark_strbuf_put(buf, (const unsigned char *)string, strlen(string));
+}
+
+void cmark_strbuf_copy_cstr(char *data, bufsize_t datasize,
+                            const cmark_strbuf *buf) {
+  bufsize_t copylen;
+
+  assert(buf);
+  if (!data || datasize <= 0)
+    return;
+
+  data[0] = '\0';
+
+  if (buf->size == 0 || buf->asize <= 0)
+    return;
+
+  copylen = buf->size;
+  if (copylen > datasize - 1)
+    copylen = datasize - 1;
+  memmove(data, buf->ptr, copylen);
+  data[copylen] = '\0';
+}
+
+void cmark_strbuf_swap(cmark_strbuf *buf_a, cmark_strbuf *buf_b) {
+  cmark_strbuf t = *buf_a;
+  *buf_a = *buf_b;
+  *buf_b = t;
+}
+
+unsigned char *cmark_strbuf_detach(cmark_strbuf *buf) {
+  unsigned char *data = buf->ptr;
+
+  if (buf->asize == 0) {
+    /* return an empty string */
+    return (unsigned char *)buf->mem->calloc(1, 1);
+  }
+
+  cmark_strbuf_init(buf->mem, buf, 0);
+  return data;
+}
+
+int cmark_strbuf_cmp(const cmark_strbuf *a, const cmark_strbuf *b) {
+  int result = memcmp(a->ptr, b->ptr, MIN(a->size, b->size));
+  return (result != 0) ? result
+                       : (a->size < b->size) ? -1 : (a->size > b->size) ? 1 : 0;
+}
+
+bufsize_t cmark_strbuf_strchr(const cmark_strbuf *buf, int c, bufsize_t pos) {
+  if (pos >= buf->size)
+    return -1;
+  if (pos < 0)
+    pos = 0;
+
+  const unsigned char *p =
+      (unsigned char *)memchr(buf->ptr + pos, c, buf->size - pos);
+  if (!p)
+    return -1;
+
+  return (bufsize_t)(p - (const unsigned char *)buf->ptr);
+}
+
+bufsize_t cmark_strbuf_strrchr(const cmark_strbuf *buf, int c, bufsize_t pos) {
+  if (pos < 0 || buf->size == 0)
+    return -1;
+  if (pos >= buf->size)
+    pos = buf->size - 1;
+
+  bufsize_t i;
+  for (i = pos; i >= 0; i--) {
+    if (buf->ptr[i] == (unsigned char)c)
+      return i;
+  }
+
+  return -1;
+}
+
+void cmark_strbuf_truncate(cmark_strbuf *buf, bufsize_t len) {
+  if (len < 0)
+    len = 0;
+
+  if (len < buf->size) {
+    buf->size = len;
+    buf->ptr[buf->size] = '\0';
+  }
+}
+
+void cmark_strbuf_drop(cmark_strbuf *buf, bufsize_t n) {
+  if (n > 0) {
+    if (n > buf->size)
+      n = buf->size;
+    buf->size = buf->size - n;
+    if (buf->size)
+      memmove(buf->ptr, buf->ptr + n, buf->size);
+
+    buf->ptr[buf->size] = '\0';
+  }
+}
+
+void cmark_strbuf_rtrim(cmark_strbuf *buf) {
+  if (!buf->size)
+    return;
+
+  while (buf->size > 0) {
+    if (!cmark_isspace(buf->ptr[buf->size - 1]))
+      break;
+
+    buf->size--;
+  }
+
+  buf->ptr[buf->size] = '\0';
+}
+
+void cmark_strbuf_trim(cmark_strbuf *buf) {
+  bufsize_t i = 0;
+
+  if (!buf->size)
+    return;
+
+  while (i < buf->size && cmark_isspace(buf->ptr[i]))
+    i++;
+
+  cmark_strbuf_drop(buf, i);
+
+  cmark_strbuf_rtrim(buf);
+}
+
+// Destructively modify string, collapsing consecutive
+// space and newline characters into a single space.
+void cmark_strbuf_normalize_whitespace(cmark_strbuf *s) {
+  bool last_char_was_space = false;
+  bufsize_t r, w;
+
+  for (r = 0, w = 0; r < s->size; ++r) {
+    if (cmark_isspace(s->ptr[r])) {
+      if (!last_char_was_space) {
+        s->ptr[w++] = ' ';
+        last_char_was_space = true;
+      }
+    } else {
+      s->ptr[w++] = s->ptr[r];
+      last_char_was_space = false;
+    }
+  }
+
+  cmark_strbuf_truncate(s, w);
+}
+
+// Destructively unescape a string: remove backslashes before punctuation chars.
+extern void cmark_strbuf_unescape(cmark_strbuf *buf) {
+  bufsize_t r, w;
+
+  for (r = 0, w = 0; r < buf->size; ++r) {
+    if (buf->ptr[r] == '\\' && cmark_ispunct(buf->ptr[r + 1]))
+      r++;
+
+    buf->ptr[w++] = buf->ptr[r];
+  }
+
+  cmark_strbuf_truncate(buf, w);
+}

deps/cmark/src/buffer.h

@@ -0,0 +1,84 @@
+#ifndef CMARK_BUFFER_H
+#define CMARK_BUFFER_H
+
+#include <stddef.h>
+#include <stdarg.h>
+#include <string.h>
+#include <limits.h>
+#include <stdint.h>
+#include "config.h"
+#include "cmark.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef int32_t bufsize_t;
+
+typedef struct {
+  cmark_mem *mem;
+  unsigned char *ptr;
+  bufsize_t asize, size;
+} cmark_strbuf;
+
+extern unsigned char cmark_strbuf__initbuf[];
+
+#define CMARK_BUF_INIT(mem)                                                    \
+  { mem, cmark_strbuf__initbuf, 0, 0 }
+
+/**
+ * Initialize a cmark_strbuf structure.
+ *
+ * For the cases where CMARK_BUF_INIT cannot be used to do static
+ * initialization.
+ */
+void cmark_strbuf_init(cmark_mem *mem, cmark_strbuf *buf,
+                       bufsize_t initial_size);
+
+/**
+ * Grow the buffer to hold at least `target_size` bytes.
+ */
+void cmark_strbuf_grow(cmark_strbuf *buf, bufsize_t target_size);
+
+void cmark_strbuf_free(cmark_strbuf *buf);
+void cmark_strbuf_swap(cmark_strbuf *buf_a, cmark_strbuf *buf_b);
+
+bufsize_t cmark_strbuf_len(const cmark_strbuf *buf);
+
+int cmark_strbuf_cmp(const cmark_strbuf *a, const cmark_strbuf *b);
+
+unsigned char *cmark_strbuf_detach(cmark_strbuf *buf);
+void cmark_strbuf_copy_cstr(char *data, bufsize_t datasize,
+                            const cmark_strbuf *buf);
+
+/*
+static CMARK_INLINE const char *cmark_strbuf_cstr(const cmark_strbuf *buf) {
+ return (char *)buf->ptr;
+}
+*/
+
+#define cmark_strbuf_at(buf, n) ((buf)->ptr[n])
+
+void cmark_strbuf_set(cmark_strbuf *buf, const unsigned char *data,
+                      bufsize_t len);
+void cmark_strbuf_sets(cmark_strbuf *buf, const char *string);
+void cmark_strbuf_putc(cmark_strbuf *buf, int c);
+void cmark_strbuf_put(cmark_strbuf *buf, const unsigned char *data,
+                      bufsize_t len);
+void cmark_strbuf_puts(cmark_strbuf *buf, const char *string);
+void cmark_strbuf_clear(cmark_strbuf *buf);
+
+bufsize_t cmark_strbuf_strchr(const cmark_strbuf *buf, int c, bufsize_t pos);
+bufsize_t cmark_strbuf_strrchr(const cmark_strbuf *buf, int c, bufsize_t pos);
+void cmark_strbuf_drop(cmark_strbuf *buf, bufsize_t n);
+void cmark_strbuf_truncate(cmark_strbuf *buf, bufsize_t 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);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

deps/cmark/src/chunk.h

@@ -0,0 +1,69 @@
+#ifndef CMARK_CHUNK_H
+#define CMARK_CHUNK_H
+
+#include <string.h>
+#include <stdlib.h>
+#include <assert.h>
+#include "cmark.h"
+#include "buffer.h"
+#include "cmark_ctype.h"
+
+#define CMARK_CHUNK_EMPTY                                                      \
+  { NULL, 0 }
+
+typedef struct {
+  const unsigned char *data;
+  bufsize_t len;
+} cmark_chunk;
+
+// NOLINTNEXTLINE(clang-diagnostic-unused-function)
+static CMARK_INLINE void cmark_chunk_free(cmark_chunk *c) {
+  c->data = NULL;
+  c->len = 0;
+}
+
+static CMARK_INLINE void cmark_chunk_ltrim(cmark_chunk *c) {
+  while (c->len && cmark_isspace(c->data[0])) {
+    c->data++;
+    c->len--;
+  }
+}
+
+static CMARK_INLINE void cmark_chunk_rtrim(cmark_chunk *c) {
+  while (c->len > 0) {
+    if (!cmark_isspace(c->data[c->len - 1]))
+      break;
+
+    c->len--;
+  }
+}
+
+// NOLINTNEXTLINE(clang-diagnostic-unused-function)
+static CMARK_INLINE void cmark_chunk_trim(cmark_chunk *c) {
+  cmark_chunk_ltrim(c);
+  cmark_chunk_rtrim(c);
+}
+
+// NOLINTNEXTLINE(clang-diagnostic-unused-function)
+static CMARK_INLINE bufsize_t cmark_chunk_strchr(cmark_chunk *ch, int c,
+                                                 bufsize_t offset) {
+  const unsigned char *p =
+      (unsigned char *)memchr(ch->data + offset, c, ch->len - offset);
+  return p ? (bufsize_t)(p - ch->data) : ch->len;
+}
+
+// NOLINTNEXTLINE(clang-diagnostic-unused-function)
+static CMARK_INLINE cmark_chunk cmark_chunk_literal(const char *data) {
+  bufsize_t len = data ? (bufsize_t)strlen(data) : 0;
+  cmark_chunk c = {(unsigned char *)data, len};
+  return c;
+}
+
+// NOLINTNEXTLINE(clang-diagnostic-unused-function)
+static CMARK_INLINE cmark_chunk cmark_chunk_dup(const cmark_chunk *ch,
+                                                bufsize_t pos, bufsize_t len) {
+  cmark_chunk c = {ch->data + pos, len};
+  return c;
+}
+
+#endif

deps/cmark/src/cmark.c

@@ -0,0 +1,48 @@
+#include <stdlib.h>
+#include <assert.h>
+#include <stdio.h>
+#include "node.h"
+#include "houdini.h"
+#include "cmark.h"
+#include "buffer.h"
+
+int cmark_version(void) { return CMARK_VERSION; }
+
+const char *cmark_version_string(void) { return CMARK_VERSION_STRING; }
+
+static void *xcalloc(size_t nmem, size_t size) {
+  void *ptr = calloc(nmem, size);
+  if (!ptr) {
+    fprintf(stderr, "[cmark] calloc returned null pointer, aborting\n");
+    abort();
+  }
+  return ptr;
+}
+
+static void *xrealloc(void *ptr, size_t size) {
+  void *new_ptr = realloc(ptr, size);
+  if (!new_ptr) {
+    fprintf(stderr, "[cmark] realloc returned null pointer, aborting\n");
+    abort();
+  }
+  return new_ptr;
+}
+
+cmark_mem DEFAULT_MEM_ALLOCATOR = {xcalloc, xrealloc, free};
+
+cmark_mem *cmark_get_default_mem_allocator(void) {
+  return &DEFAULT_MEM_ALLOCATOR;
+}
+
+
+char *cmark_markdown_to_html(const char *text, size_t len, int options) {
+  cmark_node *doc;
+  char *result;
+
+  doc = cmark_parse_document(text, len, options);
+
+  result = cmark_render_html(doc, options);
+  cmark_node_free(doc);
+
+  return result;
+}

deps/cmark/src/cmark.h

@@ -0,0 +1,654 @@
+#ifndef CMARK_H
+#define CMARK_H
+
+#include <stdio.h>
+#include <cmark_export.h>
+#include <cmark_version.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** # NAME
+ *
+ * **cmark** - CommonMark parsing, manipulating, and rendering
+ */
+
+/** # DESCRIPTION
+ *
+ * ## Simple Interface
+ */
+
+/** Convert 'text' (assumed to be a UTF-8 encoded string with length
+ * 'len') from CommonMark Markdown to HTML, returning a null-terminated,
+ * UTF-8-encoded string. It is the caller's responsibility
+ * to free the returned buffer.
+ */
+CMARK_EXPORT
+char *cmark_markdown_to_html(const char *text, size_t len, int options);
+
+/** ## Node Structure
+ */
+
+typedef enum {
+  /* Error status */
+  CMARK_NODE_NONE,
+
+  /* Block */
+  CMARK_NODE_DOCUMENT,
+  CMARK_NODE_BLOCK_QUOTE,
+  CMARK_NODE_LIST,
+  CMARK_NODE_ITEM,
+  CMARK_NODE_CODE_BLOCK,
+  CMARK_NODE_HTML_BLOCK,
+  CMARK_NODE_CUSTOM_BLOCK,
+  CMARK_NODE_PARAGRAPH,
+  CMARK_NODE_HEADING,
+  CMARK_NODE_THEMATIC_BREAK,
+
+  CMARK_NODE_FIRST_BLOCK = CMARK_NODE_DOCUMENT,
+  CMARK_NODE_LAST_BLOCK = CMARK_NODE_THEMATIC_BREAK,
+
+  /* Inline */
+  CMARK_NODE_TEXT,
+  CMARK_NODE_SOFTBREAK,
+  CMARK_NODE_LINEBREAK,
+  CMARK_NODE_CODE,
+  CMARK_NODE_HTML_INLINE,
+  CMARK_NODE_CUSTOM_INLINE,
+  CMARK_NODE_EMPH,
+  CMARK_NODE_STRONG,
+  CMARK_NODE_LINK,
+  CMARK_NODE_IMAGE,
+
+  CMARK_NODE_FIRST_INLINE = CMARK_NODE_TEXT,
+  CMARK_NODE_LAST_INLINE = CMARK_NODE_IMAGE
+} cmark_node_type;
+
+/* For backwards compatibility: */
+#define CMARK_NODE_HEADER CMARK_NODE_HEADING
+#define CMARK_NODE_HRULE CMARK_NODE_THEMATIC_BREAK
+#define CMARK_NODE_HTML CMARK_NODE_HTML_BLOCK
+#define CMARK_NODE_INLINE_HTML CMARK_NODE_HTML_INLINE
+
+typedef enum {
+  CMARK_NO_LIST,
+  CMARK_BULLET_LIST,
+  CMARK_ORDERED_LIST
+} cmark_list_type;
+
+typedef enum {
+  CMARK_NO_DELIM,
+  CMARK_PERIOD_DELIM,
+  CMARK_PAREN_DELIM
+} cmark_delim_type;
+
+typedef struct cmark_node cmark_node;
+typedef struct cmark_parser cmark_parser;
+typedef struct cmark_iter cmark_iter;
+
+/**
+ * ## Custom memory allocator support
+ */
+
+/** Defines the memory allocation functions to be used by CMark
+ * when parsing and allocating a document tree
+ */
+typedef struct cmark_mem {
+  void *(*calloc)(size_t, size_t);
+  void *(*realloc)(void *, size_t);
+  void (*free)(void *);
+} cmark_mem;
+
+/** Returns a pointer to the default memory allocator.
+ */
+CMARK_EXPORT cmark_mem *cmark_get_default_mem_allocator(void);
+
+/**
+ * ## Creating and Destroying Nodes
+ */
+
+/** Creates a new node of type 'type'.  Note that the node may have
+ * other required properties, which it is the caller's responsibility
+ * to assign.
+ */
+CMARK_EXPORT cmark_node *cmark_node_new(cmark_node_type type);
+
+/** Same as `cmark_node_new`, but explicitly listing the memory
+ * allocator used to allocate the node.  Note:  be sure to use the same
+ * allocator for every node in a tree, or bad things can happen.
+ */
+CMARK_EXPORT cmark_node *cmark_node_new_with_mem(cmark_node_type type,
+                                                 cmark_mem *mem);
+
+/** Frees the memory allocated for a node and any children.
+ */
+CMARK_EXPORT void cmark_node_free(cmark_node *node);
+
+/**
+ * ## Tree Traversal
+ */
+
+/** Returns the next node in the sequence after 'node', or NULL if
+ * there is none.
+ */
+CMARK_EXPORT cmark_node *cmark_node_next(cmark_node *node);
+
+/** Returns the previous node in the sequence after 'node', or NULL if
+ * there is none.
+ */
+CMARK_EXPORT cmark_node *cmark_node_previous(cmark_node *node);
+
+/** Returns the parent of 'node', or NULL if there is none.
+ */
+CMARK_EXPORT cmark_node *cmark_node_parent(cmark_node *node);
+
+/** Returns the first child of 'node', or NULL if 'node' has no children.
+ */
+CMARK_EXPORT cmark_node *cmark_node_first_child(cmark_node *node);
+
+/** Returns the last child of 'node', or NULL if 'node' has no children.
+ */
+CMARK_EXPORT cmark_node *cmark_node_last_child(cmark_node *node);
+
+/**
+ * ## Iterator
+ *
+ * An iterator will walk through a tree of nodes, starting from a root
+ * node, returning one node at a time, together with information about
+ * whether the node is being entered or exited.  The iterator will
+ * first descend to a child node, if there is one.  When there is no
+ * child, the iterator will go to the next sibling.  When there is no
+ * next sibling, the iterator will return to the parent (but with
+ * a 'cmark_event_type' of `CMARK_EVENT_EXIT`).  The iterator will
+ * return `CMARK_EVENT_DONE` when it reaches the root node again.
+ * One natural application is an HTML renderer, where an `ENTER` event
+ * outputs an open tag and an `EXIT` event outputs a close tag.
+ * An iterator might also be used to transform an AST in some systematic
+ * way, for example, turning all level-3 headings into regular paragraphs.
+ *
+ *     void
+ *     usage_example(cmark_node *root) {
+ *         cmark_event_type ev_type;
+ *         cmark_iter *iter = cmark_iter_new(root);
+ *
+ *         while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) {
+ *             cmark_node *cur = cmark_iter_get_node(iter);
+ *             // Do something with `cur` and `ev_type`
+ *         }
+ *
+ *         cmark_iter_free(iter);
+ *     }
+ *
+ * Iterators will never return `EXIT` events for leaf nodes, which are nodes
+ * of type:
+ *
+ * * CMARK_NODE_HTML_BLOCK
+ * * CMARK_NODE_THEMATIC_BREAK
+ * * CMARK_NODE_CODE_BLOCK
+ * * CMARK_NODE_TEXT
+ * * CMARK_NODE_SOFTBREAK
+ * * CMARK_NODE_LINEBREAK
+ * * CMARK_NODE_CODE
+ * * CMARK_NODE_HTML_INLINE
+ *
+ * Nodes must only be modified after an `EXIT` event, or an `ENTER` event for
+ * leaf nodes.
+ */
+
+typedef enum {
+  CMARK_EVENT_NONE,
+  CMARK_EVENT_DONE,
+  CMARK_EVENT_ENTER,
+  CMARK_EVENT_EXIT
+} cmark_event_type;
+
+/** Creates a new iterator starting at 'root'.  The current node and event
+ * type are undefined until 'cmark_iter_next' is called for the first time.
+ * The memory allocated for the iterator should be released using
+ * 'cmark_iter_free' when it is no longer needed.
+ */
+CMARK_EXPORT
+cmark_iter *cmark_iter_new(cmark_node *root);
+
+/** Frees the memory allocated for an iterator.
+ */
+CMARK_EXPORT
+void cmark_iter_free(cmark_iter *iter);
+
+/** Advances to the next node and returns the event type (`CMARK_EVENT_ENTER`,
+ * `CMARK_EVENT_EXIT` or `CMARK_EVENT_DONE`).
+ */
+CMARK_EXPORT
+cmark_event_type cmark_iter_next(cmark_iter *iter);
+
+/** Returns the current node.
+ */
+CMARK_EXPORT
+cmark_node *cmark_iter_get_node(cmark_iter *iter);
+
+/** Returns the current event type.
+ */
+CMARK_EXPORT
+cmark_event_type cmark_iter_get_event_type(cmark_iter *iter);
+
+/** Returns the root node.
+ */
+CMARK_EXPORT
+cmark_node *cmark_iter_get_root(cmark_iter *iter);
+
+/** Resets the iterator so that the current node is 'current' and
+ * the event type is 'event_type'.  The new current node must be a
+ * descendant of the root node or the root node itself.
+ */
+CMARK_EXPORT
+void cmark_iter_reset(cmark_iter *iter, cmark_node *current,
+                      cmark_event_type event_type);
+
+/**
+ * ## Accessors
+ */
+
+/** Returns the user data of 'node'.
+ */
+CMARK_EXPORT void *cmark_node_get_user_data(cmark_node *node);
+
+/** Sets arbitrary user data for 'node'.  Returns 1 on success,
+ * 0 on failure.
+ */
+CMARK_EXPORT int cmark_node_set_user_data(cmark_node *node, void *user_data);
+
+/** Returns the type of 'node', or `CMARK_NODE_NONE` on error.
+ */
+CMARK_EXPORT cmark_node_type cmark_node_get_type(cmark_node *node);
+
+/** Like 'cmark_node_get_type', but returns a string representation
+    of the type, or `"<unknown>"`.
+ */
+CMARK_EXPORT
+const char *cmark_node_get_type_string(cmark_node *node);
+
+/** Returns the string contents of 'node', or an empty
+    string if none is set.  Returns NULL if called on a
+    node that does not have string content.
+ */
+CMARK_EXPORT const char *cmark_node_get_literal(cmark_node *node);
+
+/** Sets the string contents of 'node'.  Returns 1 on success,
+ * 0 on failure.
+ */
+CMARK_EXPORT int cmark_node_set_literal(cmark_node *node, const char *content);
+
+/** Returns the heading level of 'node', or 0 if 'node' is not a heading.
+ */
+CMARK_EXPORT int cmark_node_get_heading_level(cmark_node *node);
+
+/* For backwards compatibility */
+#define cmark_node_get_header_level cmark_node_get_heading_level
+#define cmark_node_set_header_level cmark_node_set_heading_level
+
+/** Sets the heading level of 'node', returning 1 on success and 0 on error.
+ */
+CMARK_EXPORT int cmark_node_set_heading_level(cmark_node *node, int level);
+
+/** Returns the list type of 'node', or `CMARK_NO_LIST` if 'node'
+ * is not a list.
+ */
+CMARK_EXPORT cmark_list_type cmark_node_get_list_type(cmark_node *node);
+
+/** Sets the list type of 'node', returning 1 on success and 0 on error.
+ */
+CMARK_EXPORT int cmark_node_set_list_type(cmark_node *node,
+                                          cmark_list_type type);
+
+/** Returns the list delimiter type of 'node', or `CMARK_NO_DELIM` if 'node'
+ * is not a list.
+ */
+CMARK_EXPORT cmark_delim_type cmark_node_get_list_delim(cmark_node *node);
+
+/** Sets the list delimiter type of 'node', returning 1 on success and 0
+ * on error.
+ */
+CMARK_EXPORT int cmark_node_set_list_delim(cmark_node *node,
+                                           cmark_delim_type delim);
+
+/** Returns starting number of 'node', if it is an ordered list, otherwise 0.
+ */
+CMARK_EXPORT int cmark_node_get_list_start(cmark_node *node);
+
+/** Sets starting number of 'node', if it is an ordered list. Returns 1
+ * on success, 0 on failure.
+ */
+CMARK_EXPORT int cmark_node_set_list_start(cmark_node *node, int start);
+
+/** Returns 1 if 'node' is a tight list, 0 otherwise.
+ */
+CMARK_EXPORT int cmark_node_get_list_tight(cmark_node *node);
+
+/** Sets the "tightness" of a list.  Returns 1 on success, 0 on failure.
+ */
+CMARK_EXPORT int cmark_node_set_list_tight(cmark_node *node, int tight);
+
+/** Returns the info string from a fenced code block.
+ */
+CMARK_EXPORT const char *cmark_node_get_fence_info(cmark_node *node);
+
+/** Sets the info string in a fenced code block, returning 1 on
+ * success and 0 on failure.
+ */
+CMARK_EXPORT int cmark_node_set_fence_info(cmark_node *node, const char *info);
+
+/** Returns the URL of a link or image 'node', or an empty string
+    if no URL is set.  Returns NULL if called on a node that is
+    not a link or image.
+ */
+CMARK_EXPORT const char *cmark_node_get_url(cmark_node *node);
+
+/** Sets the URL of a link or image 'node'. Returns 1 on success,
+ * 0 on failure.
+ */
+CMARK_EXPORT int cmark_node_set_url(cmark_node *node, const char *url);
+
+/** Returns the title of a link or image 'node', or an empty
+    string if no title is set.  Returns NULL if called on a node
+    that is not a link or image.
+ */
+CMARK_EXPORT const char *cmark_node_get_title(cmark_node *node);
+
+/** Sets the title of a link or image 'node'. Returns 1 on success,
+ * 0 on failure.
+ */
+CMARK_EXPORT int cmark_node_set_title(cmark_node *node, const char *title);
+
+/** Returns the literal "on enter" text for a custom 'node', or
+    an empty string if no on_enter is set.  Returns NULL if called
+    on a non-custom node.
+ */
+CMARK_EXPORT const char *cmark_node_get_on_enter(cmark_node *node);
+
+/** Sets the literal text to render "on enter" for a custom 'node'.
+    Any children of the node will be rendered after this text.
+    Returns 1 on success 0 on failure.
+ */
+CMARK_EXPORT int cmark_node_set_on_enter(cmark_node *node,
+                                         const char *on_enter);
+
+/** Returns the literal "on exit" text for a custom 'node', or
+    an empty string if no on_exit is set.  Returns NULL if
+    called on a non-custom node.
+ */
+CMARK_EXPORT const char *cmark_node_get_on_exit(cmark_node *node);
+
+/** Sets the literal text to render "on exit" for a custom 'node'.
+    Any children of the node will be rendered before this text.
+    Returns 1 on success 0 on failure.
+ */
+CMARK_EXPORT int cmark_node_set_on_exit(cmark_node *node, const char *on_exit);
+
+/** Returns the line on which 'node' begins.
+ */
+CMARK_EXPORT int cmark_node_get_start_line(cmark_node *node);
+
+/** Returns the column at which 'node' begins.
+ */
+CMARK_EXPORT int cmark_node_get_start_column(cmark_node *node);
+
+/** Returns the line on which 'node' ends.
+ */
+CMARK_EXPORT int cmark_node_get_end_line(cmark_node *node);
+
+/** Returns the column at which 'node' ends.
+ */
+CMARK_EXPORT int cmark_node_get_end_column(cmark_node *node);
+
+/**
+ * ## Tree Manipulation
+ */
+
+/** Unlinks a 'node', removing it from the tree, but not freeing its
+ * memory.  (Use 'cmark_node_free' for that.)
+ */
+CMARK_EXPORT void cmark_node_unlink(cmark_node *node);
+
+/** Inserts 'sibling' before 'node'.  Returns 1 on success, 0 on failure.
+ */
+CMARK_EXPORT int cmark_node_insert_before(cmark_node *node,
+                                          cmark_node *sibling);
+
+/** Inserts 'sibling' after 'node'. Returns 1 on success, 0 on failure.
+ */
+CMARK_EXPORT int cmark_node_insert_after(cmark_node *node, cmark_node *sibling);
+
+/** Replaces 'oldnode' with 'newnode' and unlinks 'oldnode' (but does
+ * not free its memory).
+ * Returns 1 on success, 0 on failure.
+ */
+CMARK_EXPORT int cmark_node_replace(cmark_node *oldnode, cmark_node *newnode);
+
+/** Adds 'child' to the beginning of the children of 'node'.
+ * Returns 1 on success, 0 on failure.
+ */
+CMARK_EXPORT int cmark_node_prepend_child(cmark_node *node, cmark_node *child);
+
+/** Adds 'child' to the end of the children of 'node'.
+ * Returns 1 on success, 0 on failure.
+ */
+CMARK_EXPORT int cmark_node_append_child(cmark_node *node, cmark_node *child);
+
+/** Consolidates adjacent text nodes.
+ */
+CMARK_EXPORT void cmark_consolidate_text_nodes(cmark_node *root);
+
+/**
+ * ## Parsing
+ *
+ * Simple interface:
+ *
+ *     cmark_node *document = cmark_parse_document("Hello *world*", 13,
+ *                                                 CMARK_OPT_DEFAULT);
+ *
+ * Streaming interface:
+ *
+ *     cmark_parser *parser = cmark_parser_new(CMARK_OPT_DEFAULT);
+ *     FILE *fp = fopen("myfile.md", "rb");
+ *     while ((bytes = fread(buffer, 1, sizeof(buffer), fp)) > 0) {
+ *         cmark_parser_feed(parser, buffer, bytes);
+ *         if (bytes < sizeof(buffer)) {
+ *             break;
+ *         }
+ *     }
+ *     document = cmark_parser_finish(parser);
+ *     cmark_parser_free(parser);
+ */
+
+/** Creates a new parser object.
+ */
+CMARK_EXPORT
+cmark_parser *cmark_parser_new(int options);
+
+/** Creates a new parser object with the given memory allocator
+ */
+CMARK_EXPORT
+cmark_parser *cmark_parser_new_with_mem(int options, cmark_mem *mem);
+
+/** Frees memory allocated for a parser object.
+ */
+CMARK_EXPORT
+void cmark_parser_free(cmark_parser *parser);
+
+/** Feeds a string of length 'len' to 'parser'.
+ */
+CMARK_EXPORT
+void cmark_parser_feed(cmark_parser *parser, const char *buffer, size_t len);
+
+/** Finish parsing and return a pointer to a tree of nodes.
+ */
+CMARK_EXPORT
+cmark_node *cmark_parser_finish(cmark_parser *parser);
+
+/** Parse a CommonMark document in 'buffer' of length 'len'.
+ * Returns a pointer to a tree of nodes.  The memory allocated for
+ * the node tree should be released using 'cmark_node_free'
+ * when it is no longer needed.
+ */
+CMARK_EXPORT
+cmark_node *cmark_parse_document(const char *buffer, size_t len, int options);
+
+/** Parse a CommonMark document in file 'f', returning a pointer to
+ * a tree of nodes.  The memory allocated for the node tree should be
+ * released using 'cmark_node_free' when it is no longer needed.
+ */
+CMARK_EXPORT
+cmark_node *cmark_parse_file(FILE *f, int options);
+
+/**
+ * ## Rendering
+ */
+
+/** Render a 'node' tree as XML.  It is the caller's responsibility
+ * to free the returned buffer.
+ */
+CMARK_EXPORT
+char *cmark_render_xml(cmark_node *root, int options);
+
+/** Render a 'node' tree as an HTML fragment.  It is up to the user
+ * to add an appropriate header and footer. It is the caller's
+ * responsibility to free the returned buffer.
+ */
+CMARK_EXPORT
+char *cmark_render_html(cmark_node *root, int options);
+
+/** Render a 'node' tree as a groff man page, without the header.
+ * It is the caller's responsibility to free the returned buffer.
+ */
+CMARK_EXPORT
+char *cmark_render_man(cmark_node *root, int options, int width);
+
+/** Render a 'node' tree as a commonmark document.
+ * It is the caller's responsibility to free the returned buffer.
+ */
+CMARK_EXPORT
+char *cmark_render_commonmark(cmark_node *root, int options, int width);
+
+/** Render a 'node' tree as a LaTeX document.
+ * It is the caller's responsibility to free the returned buffer.
+ */
+CMARK_EXPORT
+char *cmark_render_latex(cmark_node *root, int options, int width);
+
+/**
+ * ## Options
+ */
+
+/** Default options.
+ */
+#define CMARK_OPT_DEFAULT 0
+
+/**
+ * ### Options affecting rendering
+ */
+
+/** Include a `data-sourcepos` attribute on all block elements.
+ */
+#define CMARK_OPT_SOURCEPOS (1 << 1)
+
+/** Render `softbreak` elements as hard line breaks.
+ */
+#define CMARK_OPT_HARDBREAKS (1 << 2)
+
+/** `CMARK_OPT_SAFE` is defined here for API compatibility,
+    but it no longer has any effect. "Safe" mode is now the default:
+    set `CMARK_OPT_UNSAFE` to disable it.
+ */
+#define CMARK_OPT_SAFE (1 << 3)
+
+/** Render raw HTML and unsafe links (`javascript:`, `vbscript:`,
+ * `file:`, and `data:`, except for `image/png`, `image/gif`,
+ * `image/jpeg`, or `image/webp` mime types).  By default,
+ * raw HTML is replaced by a placeholder HTML comment. Unsafe
+ * links are replaced by empty strings.
+ */
+#define CMARK_OPT_UNSAFE (1 << 17)
+
+/** Render `softbreak` elements as spaces.
+ */
+#define CMARK_OPT_NOBREAKS (1 << 4)
+
+/**
+ * ### Options affecting parsing
+ */
+
+/** Legacy option (no effect).
+ */
+#define CMARK_OPT_NORMALIZE (1 << 8)
+
+/** Validate UTF-8 in the input before parsing, replacing illegal
+ * sequences with the replacement character U+FFFD.
+ */
+#define CMARK_OPT_VALIDATE_UTF8 (1 << 9)
+
+/** Convert straight quotes to curly, --- to em dashes, -- to en dashes.
+ */
+#define CMARK_OPT_SMART (1 << 10)
+
+/**
+ * ## Version information
+ */
+
+/** The library version as integer for runtime checks. Also available as
+ * macro CMARK_VERSION for compile time checks.
+ *
+ * * Bits 16-23 contain the major version.
+ * * Bits 8-15 contain the minor version.
+ * * Bits 0-7 contain the patchlevel.
+ *
+ * In hexadecimal format, the number 0x010203 represents version 1.2.3.
+ */
+CMARK_EXPORT
+int cmark_version(void);
+
+/** The library version string for runtime checks. Also available as
+ * macro CMARK_VERSION_STRING for compile time checks.
+ */
+CMARK_EXPORT
+const char *cmark_version_string(void);
+
+/** # AUTHORS
+ *
+ * John MacFarlane, Vicent Marti,  Kārlis Gaņģis, Nick Wellnhofer.
+ */
+
+#ifndef CMARK_NO_SHORT_NAMES
+#define NODE_DOCUMENT CMARK_NODE_DOCUMENT
+#define NODE_BLOCK_QUOTE CMARK_NODE_BLOCK_QUOTE
+#define NODE_LIST CMARK_NODE_LIST
+#define NODE_ITEM CMARK_NODE_ITEM
+#define NODE_CODE_BLOCK CMARK_NODE_CODE_BLOCK
+#define NODE_HTML_BLOCK CMARK_NODE_HTML_BLOCK
+#define NODE_CUSTOM_BLOCK CMARK_NODE_CUSTOM_BLOCK
+#define NODE_PARAGRAPH CMARK_NODE_PARAGRAPH
+#define NODE_HEADING CMARK_NODE_HEADING
+#define NODE_HEADER CMARK_NODE_HEADER
+#define NODE_THEMATIC_BREAK CMARK_NODE_THEMATIC_BREAK
+#define NODE_HRULE CMARK_NODE_HRULE
+#define NODE_TEXT CMARK_NODE_TEXT
+#define NODE_SOFTBREAK CMARK_NODE_SOFTBREAK
+#define NODE_LINEBREAK CMARK_NODE_LINEBREAK
+#define NODE_CODE CMARK_NODE_CODE
+#define NODE_HTML_INLINE CMARK_NODE_HTML_INLINE
+#define NODE_CUSTOM_INLINE CMARK_NODE_CUSTOM_INLINE
+#define NODE_EMPH CMARK_NODE_EMPH
+#define NODE_STRONG CMARK_NODE_STRONG
+#define NODE_LINK CMARK_NODE_LINK
+#define NODE_IMAGE CMARK_NODE_IMAGE
+#define BULLET_LIST CMARK_BULLET_LIST
+#define ORDERED_LIST CMARK_ORDERED_LIST
+#define PERIOD_DELIM CMARK_PERIOD_DELIM
+#define PAREN_DELIM CMARK_PAREN_DELIM
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

deps/cmark/src/cmarkConfig.cmake.in

@@ -0,0 +1,4 @@
+@PACKAGE_INIT@
+
+include("${CMAKE_CURRENT_LIST_DIR}/cmark-targets.cmake")
+check_required_components("cmark")

deps/cmark/src/cmark_ctype.c

@@ -0,0 +1,44 @@
+#include <stdint.h>
+
+#include "cmark_ctype.h"
+
+/** 1 = space, 2 = punct, 3 = digit, 4 = alpha, 0 = other
+ */
+static const uint8_t cmark_ctype_class[256] = {
+    /*      0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f */
+    /* 0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0,
+    /* 1 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* 2 */ 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+    /* 3 */ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2,
+    /* 4 */ 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+    /* 5 */ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2,
+    /* 6 */ 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+    /* 7 */ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 0,
+    /* 8 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* 9 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* a */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* b */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* c */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* d */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* e */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* f */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+
+/**
+ * Returns 1 if c is a "whitespace" character as defined by the spec.
+ */
+int cmark_isspace(char c) { return cmark_ctype_class[(uint8_t)c] == 1; }
+
+/**
+ * Returns 1 if c is an ascii punctuation character.
+ */
+int cmark_ispunct(char c) { return cmark_ctype_class[(uint8_t)c] == 2; }
+
+int cmark_isalnum(char c) {
+  uint8_t result;
+  result = cmark_ctype_class[(uint8_t)c];
+  return (result == 3 || result == 4);
+}
+
+int cmark_isdigit(char c) { return cmark_ctype_class[(uint8_t)c] == 3; }
+
+int cmark_isalpha(char c) { return cmark_ctype_class[(uint8_t)c] == 4; }

deps/cmark/src/cmark_ctype.h

@@ -0,0 +1,26 @@
+#ifndef CMARK_CMARK_CTYPE_H
+#define CMARK_CMARK_CTYPE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** Locale-independent versions of functions from ctype.h.
+ * We want cmark to behave the same no matter what the system locale.
+ */
+
+int cmark_isspace(char c);
+
+int cmark_ispunct(char c);
+
+int cmark_isalnum(char c);
+
+int cmark_isdigit(char c);
+
+int cmark_isalpha(char c);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

deps/cmark/src/cmark_version.h.in

@@ -0,0 +1,7 @@
+#ifndef CMARK_VERSION_H
+#define CMARK_VERSION_H
+
+#define CMARK_VERSION ((@PROJECT_VERSION_MAJOR@ << 16) | (@PROJECT_VERSION_MINOR@ << 8)  | @PROJECT_VERSION_PATCH@)
+#define CMARK_VERSION_STRING "@PROJECT_VERSION_MAJOR@.@PROJECT_VERSION_MINOR@.@PROJECT_VERSION_PATCH@"
+
+#endif

deps/cmark/src/commonmark.c

@@ -0,0 +1,468 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+#include <assert.h>
+
+#include "config.h"
+#include "cmark.h"
+#include "node.h"
+#include "buffer.h"
+#include "utf8.h"
+#include "scanners.h"
+#include "render.h"
+
+#define OUT(s, wrap, escaping) renderer->out(renderer, s, wrap, escaping)
+#define LIT(s) renderer->out(renderer, s, false, LITERAL)
+#define CR() renderer->cr(renderer)
+#define BLANKLINE() renderer->blankline(renderer)
+#define ENCODED_SIZE 20
+#define LISTMARKER_SIZE 20
+
+// Functions to convert cmark_nodes to commonmark strings.
+
+static CMARK_INLINE void outc(cmark_renderer *renderer, cmark_escaping escape,
+                              int32_t c, unsigned char nextc) {
+  bool needs_escaping = false;
+  bool follows_digit =
+      renderer->buffer->size > 0 &&
+      cmark_isdigit(renderer->buffer->ptr[renderer->buffer->size - 1]);
+  char encoded[ENCODED_SIZE];
+  int options = renderer->options;
+
+  needs_escaping =
+      c < 0x80 && escape != LITERAL &&
+      ((escape == NORMAL &&
+        (c < 0x20 ||
+         c == '*' || c == '_' || c == '[' || c == ']' || c == '#' || c == '<' ||
+         c == '>' || c == '\\' || c == '`' || c == '!' ||
+         (c == '&' && cmark_isalpha(nextc)) || (c == '!' && nextc == '[') ||
+         ((CMARK_OPT_SMART & options) &&
+            ((c == '-' && nextc == '-') ||
+             (c == '.' && nextc == '.') ||
+             c == '"' || c == '\'')) ||
+         (renderer->begin_content && (c == '-' || c == '+' || c == '=') &&
+          // begin_content doesn't get set to false til we've passed digits
+          // at the beginning of line, so...
+          !follows_digit) ||
+         (renderer->begin_content && (c == '.' || c == ')') && follows_digit &&
+          (nextc == 0 || cmark_isspace(nextc))))) ||
+       (escape == URL &&
+        (c == '`' || c == '<' || c == '>' || cmark_isspace(c) || c == '\\' ||
+         c == ')' || c == '(')) ||
+       (escape == TITLE &&
+        (c == '`' || c == '<' || c == '>' || c == '"' || c == '\\')));
+
+  if (needs_escaping) {
+    if (escape == URL && cmark_isspace(c)) {
+      // use percent encoding for spaces
+      snprintf(encoded, ENCODED_SIZE, "%%%2X", c);
+      cmark_strbuf_puts(renderer->buffer, encoded);
+      renderer->column += 3;
+    } else if (cmark_ispunct(c)) {
+      cmark_render_ascii(renderer, "\\");
+      cmark_render_code_point(renderer, c);
+    } else { // render as entity
+      snprintf(encoded, ENCODED_SIZE, "&#%d;", c);
+      cmark_strbuf_puts(renderer->buffer, encoded);
+      renderer->column += strlen(encoded);
+    }
+  } else {
+    cmark_render_code_point(renderer, c);
+  }
+}
+
+static int longest_backtick_sequence(const char *code) {
+  int longest = 0;
+  int current = 0;
+  size_t i = 0;
+  size_t code_len = strlen(code);
+  while (i <= code_len) {
+    if (code[i] == '`') {
+      current++;
+    } else {
+      if (current > longest) {
+        longest = current;
+      }
+      current = 0;
+    }
+    i++;
+  }
+  return longest;
+}
+
+static int shortest_unused_backtick_sequence(const char *code) {
+  // note: if the shortest sequence is >= 32, this returns 32
+  // so as not to overflow the bit array.
+  uint32_t used = 1;
+  int current = 0;
+  size_t i = 0;
+  size_t code_len = strlen(code);
+  while (i <= code_len) {
+    if (code[i] == '`') {
+      current++;
+    } else {
+      if (current > 0 && current < 32) {
+        used |= (1U << current);
+      }
+      current = 0;
+    }
+    i++;
+  }
+  // return number of first bit that is 0:
+  i = 0;
+  while (i < 32 && used & 1) {
+    used = used >> 1;
+    i++;
+  }
+  return (int)i;
+}
+
+static bool is_autolink(cmark_node *node) {
+  const unsigned char *title;
+  const unsigned char *url;
+  cmark_node *link_text;
+
+  if (node->type != CMARK_NODE_LINK) {
+    return false;
+  }
+
+  url = node->as.link.url;
+  if (url == NULL || _scan_scheme(url) == 0) {
+    return false;
+  }
+
+  title = node->as.link.title;
+  // if it has a title, we can't treat it as an autolink:
+  if (title && title[0]) {
+    return false;
+  }
+
+  link_text = node->first_child;
+  if (link_text == NULL) {
+    return false;
+  }
+  cmark_consolidate_text_nodes(link_text);
+  if (strncmp((const char *)url, "mailto:", 7) == 0) {
+    url += 7;
+  }
+  return link_text->data != NULL &&
+         strcmp((const char *)url, (char *)link_text->data) == 0;
+}
+
+static int S_render_node(cmark_renderer *renderer, cmark_node *node,
+                         cmark_event_type ev_type, int options) {
+  cmark_node *tmp;
+  int list_number;
+  cmark_delim_type list_delim;
+  size_t numticks;
+  bool extra_spaces;
+  size_t i;
+  bool entering = (ev_type == CMARK_EVENT_ENTER);
+  const char *info, *code, *title;
+  char fencechar[2] = {'\0', '\0'};
+  size_t code_len;
+  char listmarker[LISTMARKER_SIZE];
+  const char *emph_delim;
+  bool first_in_list_item;
+  bufsize_t marker_width;
+  bool has_nonspace;
+  bool allow_wrap = renderer->width > 0 && !(CMARK_OPT_NOBREAKS & options) &&
+                    !(CMARK_OPT_HARDBREAKS & options);
+
+  // Don't adjust tight list status til we've started the list.
+  // Otherwise we lose the blank line between a paragraph and
+  // a following list.
+  if (entering) {
+    if (node->parent && node->parent->type == CMARK_NODE_ITEM) {
+      renderer->in_tight_list_item = node->parent->parent->as.list.tight;
+    }
+  } else {
+    if (node->type == CMARK_NODE_LIST) {
+      renderer->in_tight_list_item =
+        node->parent &&
+        node->parent->type == CMARK_NODE_ITEM &&
+        node->parent->parent->as.list.tight;
+    }
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_DOCUMENT:
+    break;
+
+  case CMARK_NODE_BLOCK_QUOTE:
+    if (entering) {
+      LIT("> ");
+      renderer->begin_content = true;
+      cmark_strbuf_puts(renderer->prefix, "> ");
+    } else {
+      cmark_strbuf_truncate(renderer->prefix, renderer->prefix->size - 2);
+      BLANKLINE();
+    }
+    break;
+
+  case CMARK_NODE_LIST:
+    if (!entering && node->next && (node->next->type == CMARK_NODE_LIST)) {
+      // this ensures that a following indented code block or list will be
+      // inteprereted correctly.
+      CR();
+      LIT("<!-- end list -->");
+      BLANKLINE();
+    }
+    break;
+
+  case CMARK_NODE_ITEM:
+    if (cmark_node_get_list_type(node->parent) == CMARK_BULLET_LIST) {
+      marker_width = 4;
+    } else {
+      list_number = cmark_node_get_list_start(node->parent);
+      list_delim = cmark_node_get_list_delim(node->parent);
+      tmp = node;
+      while (tmp->prev) {
+        tmp = tmp->prev;
+        list_number += 1;
+      }
+      // we ensure a width of at least 4 so
+      // we get nice transition from single digits
+      // to double
+      snprintf(listmarker, LISTMARKER_SIZE, "%d%s%s", list_number,
+               list_delim == CMARK_PAREN_DELIM ? ")" : ".",
+               list_number < 10 ? "  " : " ");
+      marker_width = strlen(listmarker);
+    }
+    if (entering) {
+      if (cmark_node_get_list_type(node->parent) == CMARK_BULLET_LIST) {
+        LIT("  - ");
+        renderer->begin_content = true;
+      } else {
+        LIT(listmarker);
+        renderer->begin_content = true;
+      }
+      for (i = marker_width; i--;) {
+        cmark_strbuf_putc(renderer->prefix, ' ');
+      }
+    } else {
+      cmark_strbuf_truncate(renderer->prefix,
+                            renderer->prefix->size - marker_width);
+      CR();
+    }
+    break;
+
+  case CMARK_NODE_HEADING:
+    if (entering) {
+      for (i = cmark_node_get_heading_level(node); i > 0; i--) {
+        LIT("#");
+      }
+      LIT(" ");
+      renderer->begin_content = true;
+      renderer->no_linebreaks = true;
+    } else {
+      renderer->no_linebreaks = false;
+      BLANKLINE();
+    }
+    break;
+
+  case CMARK_NODE_CODE_BLOCK:
+
+    first_in_list_item = node->prev == NULL && node->parent &&
+                         node->parent->type == CMARK_NODE_ITEM;
+
+    if (!first_in_list_item) {
+      BLANKLINE();
+    }
+    info = cmark_node_get_fence_info(node);
+    fencechar[0] = strchr(info, '`') == NULL ? '`' : '~';
+    code = cmark_node_get_literal(node);
+
+    numticks = longest_backtick_sequence(code) + 1;
+    if (numticks < 3) {
+      numticks = 3;
+    }
+    for (i = 0; i < numticks; i++) {
+      LIT(fencechar);
+    }
+    LIT(" ");
+    OUT(info, false, LITERAL);
+    CR();
+    OUT(cmark_node_get_literal(node), false, LITERAL);
+    CR();
+    for (i = 0; i < numticks; i++) {
+      LIT(fencechar);
+    }
+
+    BLANKLINE();
+    break;
+
+  case CMARK_NODE_HTML_BLOCK:
+    BLANKLINE();
+    OUT(cmark_node_get_literal(node), false, LITERAL);
+    BLANKLINE();
+    break;
+
+  case CMARK_NODE_CUSTOM_BLOCK:
+    BLANKLINE();
+    OUT(entering ? cmark_node_get_on_enter(node) : cmark_node_get_on_exit(node),
+        false, LITERAL);
+    BLANKLINE();
+    break;
+
+  case CMARK_NODE_THEMATIC_BREAK:
+    BLANKLINE();
+    LIT("-----");
+    BLANKLINE();
+    break;
+
+  case CMARK_NODE_PARAGRAPH:
+    if (!entering) {
+      BLANKLINE();
+    }
+    break;
+
+  case CMARK_NODE_TEXT:
+    OUT(cmark_node_get_literal(node), allow_wrap, NORMAL);
+    break;
+
+  case CMARK_NODE_LINEBREAK:
+    if (!(CMARK_OPT_HARDBREAKS & options)) {
+      LIT("  ");
+    }
+    CR();
+    break;
+
+  case CMARK_NODE_SOFTBREAK:
+    if (CMARK_OPT_HARDBREAKS & options) {
+      LIT("  ");
+      CR();
+    } else if (!renderer->no_linebreaks && renderer->width == 0 &&
+               !(CMARK_OPT_HARDBREAKS & options) &&
+               !(CMARK_OPT_NOBREAKS & options)) {
+      CR();
+    } else {
+      OUT(" ", allow_wrap, LITERAL);
+    }
+    break;
+
+  case CMARK_NODE_CODE:
+    code = cmark_node_get_literal(node);
+    code_len = strlen(code);
+    numticks = shortest_unused_backtick_sequence(code);
+    has_nonspace = false;
+    for (i=0; i < code_len; i++) {
+      if (code[i] != ' ') {
+        has_nonspace = true;
+        break;
+      }
+    }
+    extra_spaces = code_len == 0 ||
+            code[0] == '`' || code[code_len - 1] == '`' ||
+            (has_nonspace && code[0] == ' ' && code[code_len - 1] == ' ');
+    for (i = 0; i < numticks; i++) {
+      LIT("`");
+    }
+    if (extra_spaces) {
+      LIT(" ");
+    }
+    OUT(cmark_node_get_literal(node), allow_wrap, LITERAL);
+    if (extra_spaces) {
+      LIT(" ");
+    }
+    for (i = 0; i < numticks; i++) {
+      LIT("`");
+    }
+    break;
+
+  case CMARK_NODE_HTML_INLINE:
+    OUT(cmark_node_get_literal(node), false, LITERAL);
+    break;
+
+  case CMARK_NODE_CUSTOM_INLINE:
+    OUT(entering ? cmark_node_get_on_enter(node) : cmark_node_get_on_exit(node),
+        false, LITERAL);
+    break;
+
+  case CMARK_NODE_STRONG:
+    if (entering) {
+      LIT("**");
+    } else {
+      LIT("**");
+    }
+    break;
+
+  case CMARK_NODE_EMPH:
+    // If we have EMPH(EMPH(x)), we need to use *_x_*
+    // because **x** is STRONG(x):
+    if (node->parent && node->parent->type == CMARK_NODE_EMPH &&
+        node->next == NULL && node->prev == NULL) {
+      emph_delim = "_";
+    } else {
+      emph_delim = "*";
+    }
+    if (entering) {
+      LIT(emph_delim);
+    } else {
+      LIT(emph_delim);
+    }
+    break;
+
+  case CMARK_NODE_LINK:
+    if (is_autolink(node)) {
+      if (entering) {
+        LIT("<");
+        if (strncmp(cmark_node_get_url(node), "mailto:", 7) == 0) {
+          LIT((const char *)cmark_node_get_url(node) + 7);
+        } else {
+          LIT((const char *)cmark_node_get_url(node));
+        }
+        LIT(">");
+        // return signal to skip contents of node...
+        return 0;
+      }
+    } else {
+      if (entering) {
+        LIT("[");
+      } else {
+        LIT("](");
+        OUT(cmark_node_get_url(node), false, URL);
+        title = cmark_node_get_title(node);
+        if (strlen(title) > 0) {
+          LIT(" \"");
+          OUT(title, false, TITLE);
+          LIT("\"");
+        }
+        LIT(")");
+      }
+    }
+    break;
+
+  case CMARK_NODE_IMAGE:
+    if (entering) {
+      LIT("![");
+    } else {
+      LIT("](");
+      OUT(cmark_node_get_url(node), false, URL);
+      title = cmark_node_get_title(node);
+      if (strlen(title) > 0) {
+        OUT(" \"", allow_wrap, LITERAL);
+        OUT(title, false, TITLE);
+        LIT("\"");
+      }
+      LIT(")");
+    }
+    break;
+
+  default:
+    assert(false);
+    break;
+  }
+
+  return 1;
+}
+
+char *cmark_render_commonmark(cmark_node *root, int options, int width) {
+  if (options & CMARK_OPT_HARDBREAKS) {
+    // disable breaking on width, since it has
+    // a different meaning with OPT_HARDBREAKS
+    width = 0;
+  }
+  return cmark_render(root, options, width, outc, S_render_node);
+}

deps/cmark/src/config.h.in

@@ -0,0 +1,76 @@
+#ifndef CMARK_CONFIG_H
+#define CMARK_CONFIG_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#cmakedefine HAVE_STDBOOL_H
+
+#ifdef HAVE_STDBOOL_H
+  #include <stdbool.h>
+#elif !defined(__cplusplus)
+  typedef char bool;
+#endif
+
+#cmakedefine HAVE___BUILTIN_EXPECT
+
+#cmakedefine HAVE___ATTRIBUTE__
+
+#ifdef HAVE___ATTRIBUTE__
+  #define CMARK_ATTRIBUTE(list) __attribute__ (list)
+#else
+  #define CMARK_ATTRIBUTE(list)
+#endif
+
+#ifndef CMARK_INLINE
+  #if defined(_MSC_VER) && !defined(__cplusplus)
+    #define CMARK_INLINE __inline
+  #else
+    #define CMARK_INLINE inline
+  #endif
+#endif
+
+/* snprintf and vsnprintf fallbacks for MSVC before 2015,
+   due to Valentin Milea http://stackoverflow.com/questions/2915672/
+*/
+
+#if defined(_MSC_VER) && _MSC_VER < 1900
+
+#include <stdio.h>
+#include <stdarg.h>
+
+#define snprintf c99_snprintf
+#define vsnprintf c99_vsnprintf
+
+CMARK_INLINE int c99_vsnprintf(char *outBuf, size_t size, const char *format, va_list ap)
+{
+    int count = -1;
+
+    if (size != 0)
+        count = _vsnprintf_s(outBuf, size, _TRUNCATE, format, ap);
+    if (count == -1)
+        count = _vscprintf(format, ap);
+
+    return count;
+}
+
+CMARK_INLINE int c99_snprintf(char *outBuf, size_t size, const char *format, ...)
+{
+    int count;
+    va_list ap;
+
+    va_start(ap, format);
+    count = c99_vsnprintf(outBuf, size, format, ap);
+    va_end(ap);
+
+    return count;
+}
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

deps/cmark/src/houdini.h

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

deps/cmark/src/houdini_href_e.c

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

deps/cmark/src/houdini_html_e.c

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

deps/cmark/src/houdini_html_u.c

@@ -0,0 +1,153 @@
+#include <assert.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "buffer.h"
+#include "houdini.h"
+#include "utf8.h"
+#include "entities.inc"
+
+/* Binary tree lookup code for entities added by JGM */
+
+static const unsigned char *S_lookup(int i, int low, int hi,
+                                     const unsigned char *s, int len) {
+  int j;
+  int cmp =
+      strncmp((const char *)s, (const char *)cmark_entities[i].entity, len);
+  if (cmp == 0 && cmark_entities[i].entity[len] == 0) {
+    return (const unsigned char *)cmark_entities[i].bytes;
+  } else if (cmp <= 0 && i > low) {
+    j = i - ((i - low) / 2);
+    if (j == i)
+      j -= 1;
+    return S_lookup(j, low, i - 1, s, len);
+  } else if (cmp > 0 && i < hi) {
+    j = i + ((hi - i) / 2);
+    if (j == i)
+      j += 1;
+    return S_lookup(j, i + 1, hi, s, len);
+  } else {
+    return NULL;
+  }
+}
+
+static const unsigned char *S_lookup_entity(const unsigned char *s, int len) {
+  return S_lookup(CMARK_NUM_ENTITIES / 2, 0, CMARK_NUM_ENTITIES - 1, s, len);
+}
+
+bufsize_t houdini_unescape_ent(cmark_strbuf *ob, const uint8_t *src,
+                               bufsize_t size) {
+  bufsize_t i = 0;
+
+  if (size >= 3 && src[0] == '#') {
+    int codepoint = 0;
+    int num_digits = 0;
+    int max_digits = 7;
+
+    if (_isdigit(src[1])) {
+      for (i = 1; i < size && _isdigit(src[i]); ++i) {
+        codepoint = (codepoint * 10) + (src[i] - '0');
+
+        if (codepoint >= 0x110000) {
+          // Keep counting digits but
+          // avoid integer overflow.
+          codepoint = 0x110000;
+        }
+      }
+
+      num_digits = i - 1;
+      max_digits = 7;
+    }
+
+    else if (src[1] == 'x' || src[1] == 'X') {
+      for (i = 2; i < size && _isxdigit(src[i]); ++i) {
+        codepoint = (codepoint * 16) + ((src[i] | 32) % 39 - 9);
+
+        if (codepoint >= 0x110000) {
+          // Keep counting digits but
+          // avoid integer overflow.
+          codepoint = 0x110000;
+        }
+      }
+
+      num_digits = i - 2;
+      max_digits = 6;
+    }
+
+    if (num_digits >= 1 && num_digits <= max_digits &&
+                    i < size && src[i] == ';') {
+      if (codepoint == 0 || (codepoint >= 0xD800 && codepoint < 0xE000) ||
+          codepoint >= 0x110000) {
+        codepoint = 0xFFFD;
+      }
+      cmark_utf8proc_encode_char(codepoint, ob);
+      return i + 1;
+    }
+  }
+
+  else {
+    if (size > CMARK_ENTITY_MAX_LENGTH)
+      size = CMARK_ENTITY_MAX_LENGTH;
+
+    for (i = CMARK_ENTITY_MIN_LENGTH; i < size; ++i) {
+      if (src[i] == ' ')
+        break;
+
+      if (src[i] == ';') {
+        const unsigned char *entity = S_lookup_entity(src, i);
+
+        if (entity != NULL) {
+          cmark_strbuf_puts(ob, (const char *)entity);
+          return i + 1;
+        }
+
+        break;
+      }
+    }
+  }
+
+  return 0;
+}
+
+int houdini_unescape_html(cmark_strbuf *ob, const uint8_t *src,
+                          bufsize_t size) {
+  bufsize_t i = 0, org, ent;
+
+  while (i < size) {
+    org = i;
+    while (i < size && src[i] != '&')
+      i++;
+
+    if (likely(i > org)) {
+      if (unlikely(org == 0)) {
+        if (i >= size)
+          return 0;
+
+        cmark_strbuf_grow(ob, HOUDINI_UNESCAPED_SIZE(size));
+      }
+
+      cmark_strbuf_put(ob, src + org, i - org);
+    }
+
+    /* escaping */
+    if (i >= size)
+      break;
+
+    i++;
+
+    ent = houdini_unescape_ent(ob, src + i, size - i);
+    i += ent;
+
+    /* not really an entity */
+    if (ent == 0)
+      cmark_strbuf_putc(ob, '&');
+  }
+
+  return 1;
+}
+
+void houdini_unescape_html_f(cmark_strbuf *ob, const uint8_t *src,
+                             bufsize_t size) {
+  if (!houdini_unescape_html(ob, src, size))
+    cmark_strbuf_put(ob, src, size);
+}

deps/cmark/src/html.c

@@ -0,0 +1,341 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+#include "cmark_ctype.h"
+#include "config.h"
+#include "cmark.h"
+#include "node.h"
+#include "buffer.h"
+#include "houdini.h"
+#include "scanners.h"
+
+#define BUFFER_SIZE 100
+
+// Functions to convert cmark_nodes to HTML strings.
+
+static void escape_html(cmark_strbuf *dest, const unsigned char *source,
+                        bufsize_t length) {
+  houdini_escape_html0(dest, source, length, 0);
+}
+
+static CMARK_INLINE void cr(cmark_strbuf *html) {
+  if (html->size && html->ptr[html->size - 1] != '\n')
+    cmark_strbuf_putc(html, '\n');
+}
+
+struct render_state {
+  cmark_strbuf *html;
+  cmark_node *plain;
+};
+
+static void S_render_sourcepos(cmark_node *node, cmark_strbuf *html,
+                               int options) {
+  char buffer[BUFFER_SIZE];
+  if (CMARK_OPT_SOURCEPOS & options) {
+    snprintf(buffer, BUFFER_SIZE, " data-sourcepos=\"%d:%d-%d:%d\"",
+             cmark_node_get_start_line(node), cmark_node_get_start_column(node),
+             cmark_node_get_end_line(node), cmark_node_get_end_column(node));
+    cmark_strbuf_puts(html, buffer);
+  }
+}
+
+static int S_render_node(cmark_node *node, cmark_event_type ev_type,
+                         struct render_state *state, int options) {
+  cmark_node *parent;
+  cmark_node *grandparent;
+  cmark_strbuf *html = state->html;
+  char start_heading[] = "<h0";
+  char end_heading[] = "</h0";
+  bool tight;
+  char buffer[BUFFER_SIZE];
+
+  bool entering = (ev_type == CMARK_EVENT_ENTER);
+
+  if (state->plain == node) { // back at original node
+    state->plain = NULL;
+  }
+
+  if (state->plain != NULL) {
+    switch (node->type) {
+    case CMARK_NODE_TEXT:
+    case CMARK_NODE_CODE:
+    case CMARK_NODE_HTML_INLINE:
+      escape_html(html, node->data, node->len);
+      break;
+
+    case CMARK_NODE_LINEBREAK:
+    case CMARK_NODE_SOFTBREAK:
+      cmark_strbuf_putc(html, ' ');
+      break;
+
+    default:
+      break;
+    }
+    return 1;
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_DOCUMENT:
+    break;
+
+  case CMARK_NODE_BLOCK_QUOTE:
+    if (entering) {
+      cr(html);
+      cmark_strbuf_puts(html, "<blockquote");
+      S_render_sourcepos(node, html, options);
+      cmark_strbuf_puts(html, ">\n");
+    } else {
+      cr(html);
+      cmark_strbuf_puts(html, "</blockquote>\n");
+    }
+    break;
+
+  case CMARK_NODE_LIST: {
+    cmark_list_type list_type = (cmark_list_type)node->as.list.list_type;
+    int start = node->as.list.start;
+
+    if (entering) {
+      cr(html);
+      if (list_type == CMARK_BULLET_LIST) {
+        cmark_strbuf_puts(html, "<ul");
+        S_render_sourcepos(node, html, options);
+        cmark_strbuf_puts(html, ">\n");
+      } else if (start == 1) {
+        cmark_strbuf_puts(html, "<ol");
+        S_render_sourcepos(node, html, options);
+        cmark_strbuf_puts(html, ">\n");
+      } else {
+        snprintf(buffer, BUFFER_SIZE, "<ol start=\"%d\"", start);
+        cmark_strbuf_puts(html, buffer);
+        S_render_sourcepos(node, html, options);
+        cmark_strbuf_puts(html, ">\n");
+      }
+    } else {
+      cmark_strbuf_puts(html,
+                        list_type == CMARK_BULLET_LIST ? "</ul>\n" : "</ol>\n");
+    }
+    break;
+  }
+
+  case CMARK_NODE_ITEM:
+    if (entering) {
+      cr(html);
+      cmark_strbuf_puts(html, "<li");
+      S_render_sourcepos(node, html, options);
+      cmark_strbuf_putc(html, '>');
+    } else {
+      cmark_strbuf_puts(html, "</li>\n");
+    }
+    break;
+
+  case CMARK_NODE_HEADING:
+    if (entering) {
+      cr(html);
+      start_heading[2] = (char)('0' + node->as.heading.level);
+      cmark_strbuf_puts(html, start_heading);
+      S_render_sourcepos(node, html, options);
+      cmark_strbuf_putc(html, '>');
+    } else {
+      end_heading[3] = (char)('0' + node->as.heading.level);
+      cmark_strbuf_puts(html, end_heading);
+      cmark_strbuf_puts(html, ">\n");
+    }
+    break;
+
+  case CMARK_NODE_CODE_BLOCK:
+    cr(html);
+
+    if (node->as.code.info == NULL || node->as.code.info[0] == 0) {
+      cmark_strbuf_puts(html, "<pre");
+      S_render_sourcepos(node, html, options);
+      cmark_strbuf_puts(html, "><code>");
+    } else {
+      bufsize_t first_tag = 0;
+      while (node->as.code.info[first_tag] &&
+             !cmark_isspace(node->as.code.info[first_tag])) {
+        first_tag += 1;
+      }
+
+      cmark_strbuf_puts(html, "<pre");
+      S_render_sourcepos(node, html, options);
+      cmark_strbuf_puts(html, "><code class=\"language-");
+      escape_html(html, node->as.code.info, first_tag);
+      cmark_strbuf_puts(html, "\">");
+    }
+
+    escape_html(html, node->data, node->len);
+    cmark_strbuf_puts(html, "</code></pre>\n");
+    break;
+
+  case CMARK_NODE_HTML_BLOCK:
+    cr(html);
+    if (!(options & CMARK_OPT_UNSAFE)) {
+      cmark_strbuf_puts(html, "<!-- raw HTML omitted -->");
+    } else {
+      cmark_strbuf_put(html, node->data, node->len);
+    }
+    cr(html);
+    break;
+
+  case CMARK_NODE_CUSTOM_BLOCK: {
+    unsigned char *block = entering ? node->as.custom.on_enter :
+                                      node->as.custom.on_exit;
+    cr(html);
+    if (block) {
+      cmark_strbuf_puts(html, (char *)block);
+    }
+    cr(html);
+    break;
+  }
+
+  case CMARK_NODE_THEMATIC_BREAK:
+    cr(html);
+    cmark_strbuf_puts(html, "<hr");
+    S_render_sourcepos(node, html, options);
+    cmark_strbuf_puts(html, " />\n");
+    break;
+
+  case CMARK_NODE_PARAGRAPH:
+    parent = cmark_node_parent(node);
+    grandparent = cmark_node_parent(parent);
+    if (grandparent != NULL && grandparent->type == CMARK_NODE_LIST) {
+      tight = grandparent->as.list.tight;
+    } else {
+      tight = false;
+    }
+    if (!tight) {
+      if (entering) {
+        cr(html);
+        cmark_strbuf_puts(html, "<p");
+        S_render_sourcepos(node, html, options);
+        cmark_strbuf_putc(html, '>');
+      } else {
+        cmark_strbuf_puts(html, "</p>\n");
+      }
+    }
+    break;
+
+  case CMARK_NODE_TEXT:
+    escape_html(html, node->data, node->len);
+    break;
+
+  case CMARK_NODE_LINEBREAK:
+    cmark_strbuf_puts(html, "<br />\n");
+    break;
+
+  case CMARK_NODE_SOFTBREAK:
+    if (options & CMARK_OPT_HARDBREAKS) {
+      cmark_strbuf_puts(html, "<br />\n");
+    } else if (options & CMARK_OPT_NOBREAKS) {
+      cmark_strbuf_putc(html, ' ');
+    } else {
+      cmark_strbuf_putc(html, '\n');
+    }
+    break;
+
+  case CMARK_NODE_CODE:
+    cmark_strbuf_puts(html, "<code>");
+    escape_html(html, node->data, node->len);
+    cmark_strbuf_puts(html, "</code>");
+    break;
+
+  case CMARK_NODE_HTML_INLINE:
+    if (!(options & CMARK_OPT_UNSAFE)) {
+      cmark_strbuf_puts(html, "<!-- raw HTML omitted -->");
+    } else {
+      cmark_strbuf_put(html, node->data, node->len);
+    }
+    break;
+
+  case CMARK_NODE_CUSTOM_INLINE: {
+    unsigned char *block = entering ? node->as.custom.on_enter :
+                                      node->as.custom.on_exit;
+    if (block) {
+      cmark_strbuf_puts(html, (char *)block);
+    }
+    break;
+  }
+
+  case CMARK_NODE_STRONG:
+    if (entering) {
+      cmark_strbuf_puts(html, "<strong>");
+    } else {
+      cmark_strbuf_puts(html, "</strong>");
+    }
+    break;
+
+  case CMARK_NODE_EMPH:
+    if (entering) {
+      cmark_strbuf_puts(html, "<em>");
+    } else {
+      cmark_strbuf_puts(html, "</em>");
+    }
+    break;
+
+  case CMARK_NODE_LINK:
+    if (entering) {
+      cmark_strbuf_puts(html, "<a href=\"");
+      if (node->as.link.url && ((options & CMARK_OPT_UNSAFE) ||
+                                !(_scan_dangerous_url(node->as.link.url)))) {
+        houdini_escape_href(html, node->as.link.url,
+                            strlen((char *)node->as.link.url));
+      }
+      if (node->as.link.title) {
+        cmark_strbuf_puts(html, "\" title=\"");
+        escape_html(html, node->as.link.title,
+                    strlen((char *)node->as.link.title));
+      }
+      cmark_strbuf_puts(html, "\">");
+    } else {
+      cmark_strbuf_puts(html, "</a>");
+    }
+    break;
+
+  case CMARK_NODE_IMAGE:
+    if (entering) {
+      cmark_strbuf_puts(html, "<img src=\"");
+      if (node->as.link.url && ((options & CMARK_OPT_UNSAFE) ||
+                                !(_scan_dangerous_url(node->as.link.url)))) {
+        houdini_escape_href(html, node->as.link.url,
+                            strlen((char *)node->as.link.url));
+      }
+      cmark_strbuf_puts(html, "\" alt=\"");
+      state->plain = node;
+    } else {
+      if (node->as.link.title) {
+        cmark_strbuf_puts(html, "\" title=\"");
+        escape_html(html, node->as.link.title,
+                    strlen((char *)node->as.link.title));
+      }
+
+      cmark_strbuf_puts(html, "\" />");
+    }
+    break;
+
+  default:
+    assert(false);
+    break;
+  }
+
+  // cmark_strbuf_putc(html, 'x');
+  return 1;
+}
+
+char *cmark_render_html(cmark_node *root, int options) {
+  char *result;
+  cmark_strbuf html = CMARK_BUF_INIT(root->mem);
+  cmark_event_type ev_type;
+  cmark_node *cur;
+  struct render_state state = {&html, NULL};
+  cmark_iter *iter = cmark_iter_new(root);
+
+  while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) {
+    cur = cmark_iter_get_node(iter);
+    S_render_node(cur, ev_type, &state, options);
+  }
+  result = (char *)cmark_strbuf_detach(&html);
+
+  cmark_iter_free(iter);
+  return result;
+}

deps/cmark/src/inlines.h

@@ -0,0 +1,24 @@
+#ifndef CMARK_INLINES_H
+#define CMARK_INLINES_H
+
+#include "chunk.h"
+#include "references.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+unsigned char *cmark_clean_url(cmark_mem *mem, cmark_chunk *url);
+unsigned char *cmark_clean_title(cmark_mem *mem, cmark_chunk *title);
+
+void cmark_parse_inlines(cmark_mem *mem, cmark_node *parent,
+                         cmark_reference_map *refmap, int options);
+
+bufsize_t cmark_parse_reference_inline(cmark_mem *mem, cmark_chunk *input,
+                                       cmark_reference_map *refmap);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

deps/cmark/src/iterator.c

@@ -0,0 +1,122 @@
+#include <assert.h>
+#include <stdlib.h>
+
+#include "config.h"
+#include "node.h"
+#include "cmark.h"
+#include "iterator.h"
+
+static const int S_leaf_mask =
+    (1 << CMARK_NODE_HTML_BLOCK) | (1 << CMARK_NODE_THEMATIC_BREAK) |
+    (1 << CMARK_NODE_CODE_BLOCK) | (1 << CMARK_NODE_TEXT) |
+    (1 << CMARK_NODE_SOFTBREAK) | (1 << CMARK_NODE_LINEBREAK) |
+    (1 << CMARK_NODE_CODE) | (1 << CMARK_NODE_HTML_INLINE);
+
+cmark_iter *cmark_iter_new(cmark_node *root) {
+  if (root == NULL) {
+    return NULL;
+  }
+  cmark_mem *mem = root->mem;
+  cmark_iter *iter = (cmark_iter *)mem->calloc(1, sizeof(cmark_iter));
+  iter->mem = mem;
+  iter->root = root;
+  iter->cur.ev_type = CMARK_EVENT_NONE;
+  iter->cur.node = NULL;
+  iter->next.ev_type = CMARK_EVENT_ENTER;
+  iter->next.node = root;
+  return iter;
+}
+
+void cmark_iter_free(cmark_iter *iter) { iter->mem->free(iter); }
+
+static bool S_is_leaf(cmark_node *node) {
+  return ((1 << node->type) & S_leaf_mask) != 0;
+}
+
+cmark_event_type cmark_iter_next(cmark_iter *iter) {
+  cmark_event_type ev_type = iter->next.ev_type;
+  cmark_node *node = iter->next.node;
+
+  iter->cur.ev_type = ev_type;
+  iter->cur.node = node;
+
+  if (ev_type == CMARK_EVENT_DONE) {
+    return ev_type;
+  }
+
+  /* roll forward to next item, setting both fields */
+  if (ev_type == CMARK_EVENT_ENTER && !S_is_leaf(node)) {
+    if (node->first_child == NULL) {
+      /* stay on this node but exit */
+      iter->next.ev_type = CMARK_EVENT_EXIT;
+    } else {
+      iter->next.ev_type = CMARK_EVENT_ENTER;
+      iter->next.node = node->first_child;
+    }
+  } else if (node == iter->root) {
+    /* don't move past root */
+    iter->next.ev_type = CMARK_EVENT_DONE;
+    iter->next.node = NULL;
+  } else if (node->next) {
+    iter->next.ev_type = CMARK_EVENT_ENTER;
+    iter->next.node = node->next;
+  } else if (node->parent) {
+    iter->next.ev_type = CMARK_EVENT_EXIT;
+    iter->next.node = node->parent;
+  } else {
+    assert(false);
+    iter->next.ev_type = CMARK_EVENT_DONE;
+    iter->next.node = NULL;
+  }
+
+  return ev_type;
+}
+
+void cmark_iter_reset(cmark_iter *iter, cmark_node *current,
+                      cmark_event_type event_type) {
+  iter->next.ev_type = event_type;
+  iter->next.node = current;
+  cmark_iter_next(iter);
+}
+
+cmark_node *cmark_iter_get_node(cmark_iter *iter) { return iter->cur.node; }
+
+cmark_event_type cmark_iter_get_event_type(cmark_iter *iter) {
+  return iter->cur.ev_type;
+}
+
+cmark_node *cmark_iter_get_root(cmark_iter *iter) { return iter->root; }
+
+void cmark_consolidate_text_nodes(cmark_node *root) {
+  if (root == NULL) {
+    return;
+  }
+  cmark_iter *iter = cmark_iter_new(root);
+  cmark_strbuf buf = CMARK_BUF_INIT(iter->mem);
+  cmark_event_type ev_type;
+  cmark_node *cur, *tmp, *next;
+
+  while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) {
+    cur = cmark_iter_get_node(iter);
+    if (ev_type == CMARK_EVENT_ENTER && cur->type == CMARK_NODE_TEXT &&
+        cur->next && cur->next->type == CMARK_NODE_TEXT) {
+      cmark_strbuf_clear(&buf);
+      cmark_strbuf_put(&buf, cur->data, cur->len);
+      tmp = cur->next;
+      while (tmp && tmp->type == CMARK_NODE_TEXT) {
+        cmark_iter_next(iter); // advance pointer
+        cmark_strbuf_put(&buf, tmp->data, tmp->len);
+        cur->end_column = tmp->end_column;
+        next = tmp->next;
+        cmark_node_free(tmp);
+        tmp = next;
+      }
+      iter->mem->free(cur->data);
+      cur->len = buf.size;
+      cur->data = cmark_strbuf_detach(&buf);
+    }
+  }
+
+  cmark_strbuf_free(&buf);
+  cmark_iter_free(iter);
+}

deps/cmark/src/iterator.h

@@ -0,0 +1,26 @@
+#ifndef CMARK_ITERATOR_H
+#define CMARK_ITERATOR_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "cmark.h"
+
+typedef struct {
+  cmark_event_type ev_type;
+  cmark_node *node;
+} cmark_iter_state;
+
+struct cmark_iter {
+  cmark_mem *mem;
+  cmark_node *root;
+  cmark_iter_state cur;
+  cmark_iter_state next;
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

deps/cmark/src/latex.c

@@ -0,0 +1,453 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+#include "config.h"
+#include "cmark.h"
+#include "node.h"
+#include "buffer.h"
+#include "utf8.h"
+#include "scanners.h"
+#include "render.h"
+
+#define OUT(s, wrap, escaping) renderer->out(renderer, s, wrap, escaping)
+#define LIT(s) renderer->out(renderer, s, false, LITERAL)
+#define CR() renderer->cr(renderer)
+#define BLANKLINE() renderer->blankline(renderer)
+#define LIST_NUMBER_STRING_SIZE 20
+
+static CMARK_INLINE void outc(cmark_renderer *renderer, cmark_escaping escape,
+                              int32_t c, unsigned char nextc) {
+  if (escape == LITERAL) {
+    cmark_render_code_point(renderer, c);
+    return;
+  }
+
+  switch (c) {
+  case 123: // '{'
+  case 125: // '}'
+  case 35:  // '#'
+  case 37:  // '%'
+  case 38:  // '&'
+    cmark_render_ascii(renderer, "\\");
+    cmark_render_code_point(renderer, c);
+    break;
+  case 36: // '$'
+  case 95: // '_'
+    if (escape == NORMAL) {
+      cmark_render_ascii(renderer, "\\");
+    }
+    cmark_render_code_point(renderer, c);
+    break;
+  case 45:             // '-'
+    if (nextc == 45) { // prevent ligature
+      cmark_render_ascii(renderer, "-{}");
+    } else {
+      cmark_render_ascii(renderer, "-");
+    }
+    break;
+  case 126: // '~'
+    if (escape == NORMAL) {
+      cmark_render_ascii(renderer, "\\textasciitilde{}");
+    } else {
+      cmark_render_code_point(renderer, c);
+    }
+    break;
+  case 94: // '^'
+    cmark_render_ascii(renderer, "\\^{}");
+    break;
+  case 92: // '\\'
+    if (escape == URL) {
+      // / acts as path sep even on windows:
+      cmark_render_ascii(renderer, "/");
+    } else {
+      cmark_render_ascii(renderer, "\\textbackslash{}");
+    }
+    break;
+  case 124: // '|'
+    cmark_render_ascii(renderer, "\\textbar{}");
+    break;
+  case 60: // '<'
+    cmark_render_ascii(renderer, "\\textless{}");
+    break;
+  case 62: // '>'
+    cmark_render_ascii(renderer, "\\textgreater{}");
+    break;
+  case 91: // '['
+  case 93: // ']'
+    cmark_render_ascii(renderer, "{");
+    cmark_render_code_point(renderer, c);
+    cmark_render_ascii(renderer, "}");
+    break;
+  case 34: // '"'
+    cmark_render_ascii(renderer, "\\textquotedbl{}");
+    // requires \usepackage[T1]{fontenc}
+    break;
+  case 39: // '\''
+    cmark_render_ascii(renderer, "\\textquotesingle{}");
+    // requires \usepackage{textcomp}
+    break;
+  case 160: // nbsp
+    cmark_render_ascii(renderer, "~");
+    break;
+  case 8230: // hellip
+    cmark_render_ascii(renderer, "\\ldots{}");
+    break;
+  case 8216: // lsquo
+    if (escape == NORMAL) {
+      cmark_render_ascii(renderer, "`");
+    } else {
+      cmark_render_code_point(renderer, c);
+    }
+    break;
+  case 8217: // rsquo
+    if (escape == NORMAL) {
+      cmark_render_ascii(renderer, "\'");
+    } else {
+      cmark_render_code_point(renderer, c);
+    }
+    break;
+  case 8220: // ldquo
+    if (escape == NORMAL) {
+      cmark_render_ascii(renderer, "``");
+    } else {
+      cmark_render_code_point(renderer, c);
+    }
+    break;
+  case 8221: // rdquo
+    if (escape == NORMAL) {
+      cmark_render_ascii(renderer, "''");
+    } else {
+      cmark_render_code_point(renderer, c);
+    }
+    break;
+  case 8212: // emdash
+    if (escape == NORMAL) {
+      cmark_render_ascii(renderer, "---");
+    } else {
+      cmark_render_code_point(renderer, c);
+    }
+    break;
+  case 8211: // endash
+    if (escape == NORMAL) {
+      cmark_render_ascii(renderer, "--");
+    } else {
+      cmark_render_code_point(renderer, c);
+    }
+    break;
+  default:
+    cmark_render_code_point(renderer, c);
+  }
+}
+
+typedef enum {
+  NO_LINK,
+  URL_AUTOLINK,
+  EMAIL_AUTOLINK,
+  NORMAL_LINK,
+  INTERNAL_LINK
+} link_type;
+
+static link_type get_link_type(cmark_node *node) {
+  size_t title_len, url_len;
+  cmark_node *link_text;
+  char *realurl;
+  int realurllen;
+  bool isemail = false;
+
+  if (node->type != CMARK_NODE_LINK) {
+    return NO_LINK;
+  }
+
+  const char *url = cmark_node_get_url(node);
+  cmark_chunk url_chunk = cmark_chunk_literal(url);
+
+  if (url && *url == '#') {
+    return INTERNAL_LINK;
+  }
+
+  url_len = strlen(url);
+  if (url_len == 0 || scan_scheme(&url_chunk, 0) == 0) {
+    return NO_LINK;
+  }
+
+  const char *title = cmark_node_get_title(node);
+  title_len = strlen(title);
+  // if it has a title, we can't treat it as an autolink:
+  if (title_len == 0) {
+
+    link_text = node->first_child;
+    cmark_consolidate_text_nodes(link_text);
+
+    if (!link_text)
+      return NO_LINK;
+
+    realurl = (char *)url;
+    realurllen = (int)url_len;
+    if (strncmp(realurl, "mailto:", 7) == 0) {
+      realurl += 7;
+      realurllen -= 7;
+      isemail = true;
+    }
+    if (realurllen == link_text->len &&
+        strncmp(realurl, (char *)link_text->data,
+                link_text->len) == 0) {
+      if (isemail) {
+        return EMAIL_AUTOLINK;
+      } else {
+        return URL_AUTOLINK;
+      }
+    }
+  }
+
+  return NORMAL_LINK;
+}
+
+static int S_get_enumlevel(cmark_node *node) {
+  int enumlevel = 0;
+  cmark_node *tmp = node;
+  while (tmp) {
+    if (tmp->type == CMARK_NODE_LIST &&
+        cmark_node_get_list_type(node) == CMARK_ORDERED_LIST) {
+      enumlevel++;
+    }
+    tmp = tmp->parent;
+  }
+  return enumlevel;
+}
+
+static int S_render_node(cmark_renderer *renderer, cmark_node *node,
+                         cmark_event_type ev_type, int options) {
+  int list_number;
+  int enumlevel;
+  char list_number_string[LIST_NUMBER_STRING_SIZE];
+  bool entering = (ev_type == CMARK_EVENT_ENTER);
+  cmark_list_type list_type;
+  bool allow_wrap = renderer->width > 0 && !(CMARK_OPT_NOBREAKS & options);
+
+  // avoid warning about unused parameter:
+  (void)(options);
+
+  switch (node->type) {
+  case CMARK_NODE_DOCUMENT:
+    break;
+
+  case CMARK_NODE_BLOCK_QUOTE:
+    if (entering) {
+      LIT("\\begin{quote}");
+      CR();
+    } else {
+      LIT("\\end{quote}");
+      BLANKLINE();
+    }
+    break;
+
+  case CMARK_NODE_LIST:
+    list_type = cmark_node_get_list_type(node);
+    if (entering) {
+      LIT("\\begin{");
+      LIT(list_type == CMARK_ORDERED_LIST ? "enumerate" : "itemize");
+      LIT("}");
+      CR();
+      list_number = cmark_node_get_list_start(node);
+      if (list_number > 1) {
+        enumlevel = S_get_enumlevel(node);
+        // latex normally supports only five levels
+        if (enumlevel >= 1 && enumlevel <= 5) {
+          snprintf(list_number_string, LIST_NUMBER_STRING_SIZE, "%d",
+                   list_number - 1); // the next item will increment this
+          LIT("\\setcounter{enum");
+          switch (enumlevel) {
+          case 1: LIT("i"); break;
+          case 2: LIT("ii"); break;
+          case 3: LIT("iii"); break;
+          case 4: LIT("iv"); break;
+          case 5: LIT("v"); break;
+          default: LIT("i"); break;
+          }
+          LIT("}{");
+          OUT(list_number_string, false, NORMAL);
+          LIT("}");
+        }
+        CR();
+      }
+    } else {
+      LIT("\\end{");
+      LIT(list_type == CMARK_ORDERED_LIST ? "enumerate" : "itemize");
+      LIT("}");
+      BLANKLINE();
+    }
+    break;
+
+  case CMARK_NODE_ITEM:
+    if (entering) {
+      LIT("\\item ");
+    } else {
+      CR();
+    }
+    break;
+
+  case CMARK_NODE_HEADING:
+    if (entering) {
+      switch (cmark_node_get_heading_level(node)) {
+      case 1:
+        LIT("\\section");
+        break;
+      case 2:
+        LIT("\\subsection");
+        break;
+      case 3:
+        LIT("\\subsubsection");
+        break;
+      case 4:
+        LIT("\\paragraph");
+        break;
+      case 5:
+        LIT("\\subparagraph");
+        break;
+      }
+      LIT("{");
+    } else {
+      LIT("}");
+      BLANKLINE();
+    }
+    break;
+
+  case CMARK_NODE_CODE_BLOCK:
+    CR();
+    LIT("\\begin{verbatim}");
+    CR();
+    OUT(cmark_node_get_literal(node), false, LITERAL);
+    CR();
+    LIT("\\end{verbatim}");
+    BLANKLINE();
+    break;
+
+  case CMARK_NODE_HTML_BLOCK:
+    break;
+
+  case CMARK_NODE_CUSTOM_BLOCK:
+    CR();
+    OUT(entering ? cmark_node_get_on_enter(node) : cmark_node_get_on_exit(node),
+        false, LITERAL);
+    CR();
+    break;
+
+  case CMARK_NODE_THEMATIC_BREAK:
+    BLANKLINE();
+    LIT("\\begin{center}\\rule{0.5\\linewidth}{\\linethickness}\\end{center}");
+    BLANKLINE();
+    break;
+
+  case CMARK_NODE_PARAGRAPH:
+    if (!entering) {
+      BLANKLINE();
+    }
+    break;
+
+  case CMARK_NODE_TEXT:
+    OUT(cmark_node_get_literal(node), allow_wrap, NORMAL);
+    break;
+
+  case CMARK_NODE_LINEBREAK:
+    LIT("\\\\");
+    CR();
+    break;
+
+  case CMARK_NODE_SOFTBREAK:
+    if (options & CMARK_OPT_HARDBREAKS) {
+      LIT("\\\\");
+      CR();
+    } else if (renderer->width == 0 && !(CMARK_OPT_NOBREAKS & options)) {
+      CR();
+    } else {
+      OUT(" ", allow_wrap, NORMAL);
+    }
+    break;
+
+  case CMARK_NODE_CODE:
+    LIT("\\texttt{");
+    OUT(cmark_node_get_literal(node), false, NORMAL);
+    LIT("}");
+    break;
+
+  case CMARK_NODE_HTML_INLINE:
+    break;
+
+  case CMARK_NODE_CUSTOM_INLINE:
+    OUT(entering ? cmark_node_get_on_enter(node) : cmark_node_get_on_exit(node),
+        false, LITERAL);
+    break;
+
+  case CMARK_NODE_STRONG:
+    if (entering) {
+      LIT("\\textbf{");
+    } else {
+      LIT("}");
+    }
+    break;
+
+  case CMARK_NODE_EMPH:
+    if (entering) {
+      LIT("\\emph{");
+    } else {
+      LIT("}");
+    }
+    break;
+
+  case CMARK_NODE_LINK:
+    if (entering) {
+      const char *url = cmark_node_get_url(node);
+      // requires \usepackage{hyperref}
+      switch (get_link_type(node)) {
+      case URL_AUTOLINK:
+        LIT("\\url{");
+        OUT(url, false, URL);
+        LIT("}");
+        return 0; // Don't process further nodes to avoid double-rendering artefacts
+      case EMAIL_AUTOLINK:
+        LIT("\\href{");
+        OUT(url, false, URL);
+        LIT("}\\nolinkurl{");
+        break;
+      case NORMAL_LINK:
+        LIT("\\href{");
+        OUT(url, false, URL);
+        LIT("}{");
+        break;
+      case INTERNAL_LINK:
+        LIT("\\protect\\hyperlink{");
+        OUT(url + 1, false, URL);
+        LIT("}{");
+        break;
+      case NO_LINK:
+        LIT("{"); // error?
+      }
+    } else {
+      LIT("}");
+    }
+
+    break;
+
+  case CMARK_NODE_IMAGE:
+    if (entering) {
+      LIT("\\protect\\includegraphics{");
+      // requires \include{graphicx}
+      OUT(cmark_node_get_url(node), false, URL);
+      LIT("}");
+      return 0;
+    }
+    break;
+
+  default:
+    assert(false);
+    break;
+  }
+
+  return 1;
+}
+
+char *cmark_render_latex(cmark_node *root, int options, int width) {
+  return cmark_render(root, options, width, outc, S_render_node);
+}

deps/cmark/src/libcmark.pc.in

@@ -0,0 +1,10 @@
+prefix=@CMAKE_INSTALL_PREFIX@
+exec_prefix=@CMAKE_INSTALL_PREFIX@
+libdir=@CMAKE_INSTALL_FULL_LIBDIR@
+includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@
+
+Name: libcmark
+Description: CommonMark parsing, rendering, and manipulation
+Version: @PROJECT_VERSION@
+Libs: -L${libdir} -lcmark
+Cflags: -I${includedir}

deps/cmark/src/main.c

@@ -0,0 +1,213 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include "config.h"
+#include "cmark.h"
+#include "node.h"
+
+#if defined(__OpenBSD__)
+#  include <sys/param.h>
+#  if OpenBSD >= 201605
+#    define USE_PLEDGE
+#    include <unistd.h>
+#  endif
+#endif
+
+#if defined(_WIN32) && !defined(__CYGWIN__)
+#include <io.h>
+#include <fcntl.h>
+#endif
+
+typedef enum {
+  FORMAT_NONE,
+  FORMAT_HTML,
+  FORMAT_XML,
+  FORMAT_MAN,
+  FORMAT_COMMONMARK,
+  FORMAT_LATEX
+} writer_format;
+
+void print_usage(void) {
+  printf("Usage:   cmark [FILE*]\n");
+  printf("Options:\n");
+  printf("  --to, -t FORMAT  Specify output format (html, xml, man, "
+         "commonmark, latex)\n");
+  printf("  --width WIDTH    Specify wrap width (default 0 = nowrap)\n");
+  printf("  --sourcepos      Include source position attribute\n");
+  printf("  --hardbreaks     Treat newlines as hard line breaks\n");
+  printf("  --nobreaks       Render soft line breaks as spaces\n");
+  printf("  --safe           Omit raw HTML and dangerous URLs\n");
+  printf("  --unsafe         Render raw HTML and dangerous URLs\n");
+  printf("  --smart          Use smart punctuation\n");
+  printf("  --validate-utf8  Replace invalid UTF-8 sequences with U+FFFD\n");
+  printf("  --help, -h       Print usage information\n");
+  printf("  --version        Print version\n");
+}
+
+static void print_document(cmark_node *document, writer_format writer,
+                           int options, int width) {
+  char *result;
+
+  switch (writer) {
+  case FORMAT_HTML:
+    result = cmark_render_html(document, options);
+    break;
+  case FORMAT_XML:
+    result = cmark_render_xml(document, options);
+    break;
+  case FORMAT_MAN:
+    result = cmark_render_man(document, options, width);
+    break;
+  case FORMAT_COMMONMARK:
+    result = cmark_render_commonmark(document, options, width);
+    break;
+  case FORMAT_LATEX:
+    result = cmark_render_latex(document, options, width);
+    break;
+  default:
+    fprintf(stderr, "Unknown format %d\n", writer);
+    exit(1);
+  }
+  printf("%s", result);
+  document->mem->free(result);
+}
+
+int main(int argc, char *argv[]) {
+  int i, numfps = 0;
+  int *files;
+  char buffer[4096];
+  cmark_parser *parser;
+  size_t bytes;
+  cmark_node *document;
+  int width = 0;
+  char *unparsed;
+  writer_format writer = FORMAT_HTML;
+  int options = CMARK_OPT_DEFAULT;
+
+#ifdef USE_PLEDGE
+  if (pledge("stdio rpath", NULL) != 0) {
+    perror("pledge");
+    return 1;
+  }
+#endif
+
+#if defined(_WIN32) && !defined(__CYGWIN__)
+  _setmode(_fileno(stdin), _O_BINARY);
+  _setmode(_fileno(stdout), _O_BINARY);
+#endif
+
+  files = (int *)calloc(argc, sizeof(*files));
+
+  for (i = 1; i < argc; i++) {
+    if (strcmp(argv[i], "--version") == 0) {
+      printf("cmark %s", CMARK_VERSION_STRING);
+      printf(" - CommonMark converter\n(C) 2014-2016 John MacFarlane\n");
+      exit(0);
+    } else if (strcmp(argv[i], "--sourcepos") == 0) {
+      options |= CMARK_OPT_SOURCEPOS;
+    } else if (strcmp(argv[i], "--hardbreaks") == 0) {
+      options |= CMARK_OPT_HARDBREAKS;
+    } else if (strcmp(argv[i], "--nobreaks") == 0) {
+      options |= CMARK_OPT_NOBREAKS;
+    } else if (strcmp(argv[i], "--smart") == 0) {
+      options |= CMARK_OPT_SMART;
+    } else if (strcmp(argv[i], "--safe") == 0) {
+      options |= CMARK_OPT_SAFE;
+    } else if (strcmp(argv[i], "--unsafe") == 0) {
+      options |= CMARK_OPT_UNSAFE;
+    } else if (strcmp(argv[i], "--validate-utf8") == 0) {
+      options |= CMARK_OPT_VALIDATE_UTF8;
+    } else if ((strcmp(argv[i], "--help") == 0) ||
+               (strcmp(argv[i], "-h") == 0)) {
+      print_usage();
+      exit(0);
+    } else if (strcmp(argv[i], "--width") == 0) {
+      i += 1;
+      if (i < argc) {
+        width = (int)strtol(argv[i], &unparsed, 10);
+        if (unparsed && strlen(unparsed) > 0) {
+          fprintf(stderr, "failed parsing width '%s' at '%s'\n", argv[i],
+                  unparsed);
+          exit(1);
+        }
+      } else {
+        fprintf(stderr, "--width requires an argument\n");
+        exit(1);
+      }
+    } else if ((strcmp(argv[i], "-t") == 0) || (strcmp(argv[i], "--to") == 0)) {
+      i += 1;
+      if (i < argc) {
+        if (strcmp(argv[i], "man") == 0) {
+          writer = FORMAT_MAN;
+        } else if (strcmp(argv[i], "html") == 0) {
+          writer = FORMAT_HTML;
+        } else if (strcmp(argv[i], "xml") == 0) {
+          writer = FORMAT_XML;
+        } else if (strcmp(argv[i], "commonmark") == 0) {
+          writer = FORMAT_COMMONMARK;
+        } else if (strcmp(argv[i], "latex") == 0) {
+          writer = FORMAT_LATEX;
+        } else {
+          fprintf(stderr, "Unknown format %s\n", argv[i]);
+          exit(1);
+        }
+      } else {
+        fprintf(stderr, "No argument provided for %s\n", argv[i - 1]);
+        exit(1);
+      }
+    } else if (*argv[i] == '-') {
+      print_usage();
+      exit(1);
+    } else { // treat as file argument
+      files[numfps++] = i;
+    }
+  }
+
+  parser = cmark_parser_new(options);
+  for (i = 0; i < numfps; i++) {
+    FILE *fp = fopen(argv[files[i]], "rb");
+    if (fp == NULL) {
+      fprintf(stderr, "Error opening file %s: %s\n", argv[files[i]],
+              strerror(errno));
+      exit(1);
+    }
+
+    while ((bytes = fread(buffer, 1, sizeof(buffer), fp)) > 0) {
+      cmark_parser_feed(parser, buffer, bytes);
+      if (bytes < sizeof(buffer)) {
+        break;
+      }
+    }
+
+    fclose(fp);
+  }
+
+  if (numfps == 0) {
+
+    while ((bytes = fread(buffer, 1, sizeof(buffer), stdin)) > 0) {
+      cmark_parser_feed(parser, buffer, bytes);
+      if (bytes < sizeof(buffer)) {
+        break;
+      }
+    }
+  }
+
+#ifdef USE_PLEDGE
+  if (pledge("stdio", NULL) != 0) {
+    perror("pledge");
+    return 1;
+  }
+#endif
+
+  document = cmark_parser_finish(parser);
+  cmark_parser_free(parser);
+
+  print_document(document, writer, options, width);
+
+  cmark_node_free(document);
+
+  free(files);
+
+  return 0;
+}

deps/cmark/src/man.c

@@ -0,0 +1,281 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+#include "config.h"
+#include "cmark.h"
+#include "node.h"
+#include "buffer.h"
+#include "utf8.h"
+#include "render.h"
+
+#define OUT(s, wrap, escaping) renderer->out(renderer, s, wrap, escaping)
+#define LIT(s) renderer->out(renderer, s, false, LITERAL)
+#define CR() renderer->cr(renderer)
+#define BLANKLINE() renderer->blankline(renderer)
+#define LIST_NUMBER_SIZE 20
+
+// Functions to convert cmark_nodes to groff man strings.
+static void S_outc(cmark_renderer *renderer, cmark_escaping escape, int32_t c,
+                   unsigned char nextc) {
+  (void)(nextc);
+
+  if (escape == LITERAL) {
+    cmark_render_code_point(renderer, c);
+    return;
+  }
+
+  switch (c) {
+  case 46:
+    if (renderer->begin_line) {
+      cmark_render_ascii(renderer, "\\&.");
+    } else {
+      cmark_render_code_point(renderer, c);
+    }
+    break;
+  case 39:
+    if (renderer->begin_line) {
+      cmark_render_ascii(renderer, "\\&'");
+    } else {
+      cmark_render_code_point(renderer, c);
+    }
+    break;
+  case 45:
+    cmark_render_ascii(renderer, "\\-");
+    break;
+  case 92:
+    cmark_render_ascii(renderer, "\\e");
+    break;
+  case 8216: // left single quote
+    cmark_render_ascii(renderer, "\\[oq]");
+    break;
+  case 8217: // right single quote
+    cmark_render_ascii(renderer, "\\[cq]");
+    break;
+  case 8220: // left double quote
+    cmark_render_ascii(renderer, "\\[lq]");
+    break;
+  case 8221: // right double quote
+    cmark_render_ascii(renderer, "\\[rq]");
+    break;
+  case 8212: // em dash
+    cmark_render_ascii(renderer, "\\[em]");
+    break;
+  case 8211: // en dash
+    cmark_render_ascii(renderer, "\\[en]");
+    break;
+  default:
+    cmark_render_code_point(renderer, c);
+  }
+}
+
+static int S_render_node(cmark_renderer *renderer, cmark_node *node,
+                         cmark_event_type ev_type, int options) {
+  cmark_node *tmp;
+  int list_number;
+  bool entering = (ev_type == CMARK_EVENT_ENTER);
+  bool allow_wrap = renderer->width > 0 && !(CMARK_OPT_NOBREAKS & options);
+  struct block_number *new_block_number;
+  cmark_mem *allocator = cmark_get_default_mem_allocator();
+
+  // avoid unused parameter error:
+  (void)(options);
+
+  // indent inside nested lists
+  if (renderer->block_number_in_list_item &&
+      node->type < CMARK_NODE_FIRST_INLINE) {
+    if (entering) {
+      renderer->block_number_in_list_item->number += 1;
+      if (renderer->block_number_in_list_item->number == 2) {
+        CR();
+        LIT(".RS"); // indent
+        CR();
+      }
+    }
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_DOCUMENT:
+    break;
+
+  case CMARK_NODE_BLOCK_QUOTE:
+    if (entering) {
+      CR();
+      LIT(".RS");
+      CR();
+    } else {
+      CR();
+      LIT(".RE");
+      CR();
+    }
+    break;
+
+  case CMARK_NODE_LIST:
+    break;
+
+  case CMARK_NODE_ITEM:
+    if (entering) {
+      new_block_number = allocator->calloc(1, sizeof(struct block_number));
+      new_block_number->number = 0;
+      new_block_number->parent = renderer->block_number_in_list_item;
+      renderer->block_number_in_list_item = new_block_number;
+      CR();
+      LIT(".IP ");
+      if (cmark_node_get_list_type(node->parent) == CMARK_BULLET_LIST) {
+        LIT("\\[bu] 2");
+      } else {
+        list_number = cmark_node_get_list_start(node->parent);
+        tmp = node;
+        while (tmp->prev) {
+          tmp = tmp->prev;
+          list_number += 1;
+        }
+        char list_number_s[LIST_NUMBER_SIZE];
+        snprintf(list_number_s, LIST_NUMBER_SIZE, "\"%d.\" 4", list_number);
+        LIT(list_number_s);
+      }
+      CR();
+    } else {
+      if (renderer->block_number_in_list_item) {
+        if (renderer->block_number_in_list_item->number >= 2) {
+          CR();
+          LIT(".RE"); // de-indent
+        }
+        new_block_number = renderer->block_number_in_list_item;
+        renderer->block_number_in_list_item =
+          renderer->block_number_in_list_item->parent;
+        allocator->free(new_block_number);
+      }
+      CR();
+    }
+    break;
+
+  case CMARK_NODE_HEADING:
+    if (entering) {
+      CR();
+      LIT(cmark_node_get_heading_level(node) == 1 ? ".SH" : ".SS");
+      CR();
+    } else {
+      CR();
+    }
+    break;
+
+  case CMARK_NODE_CODE_BLOCK:
+    CR();
+    LIT(".IP\n.nf\n\\f[C]\n");
+    OUT(cmark_node_get_literal(node), false, NORMAL);
+    CR();
+    LIT("\\f[]\n.fi");
+    CR();
+    break;
+
+  case CMARK_NODE_HTML_BLOCK:
+    break;
+
+  case CMARK_NODE_CUSTOM_BLOCK:
+    CR();
+    OUT(entering ? cmark_node_get_on_enter(node) : cmark_node_get_on_exit(node),
+        false, LITERAL);
+    CR();
+    break;
+
+  case CMARK_NODE_THEMATIC_BREAK:
+    CR();
+    LIT(".PP\n  *  *  *  *  *");
+    CR();
+    break;
+
+  case CMARK_NODE_PARAGRAPH:
+    if (entering) {
+      // no blank line if first paragraph in list:
+      if (node->parent && node->parent->type == CMARK_NODE_ITEM &&
+          node->prev == NULL) {
+        // no blank line or .PP
+      } else {
+        CR();
+        LIT(".PP");
+        CR();
+      }
+    } else {
+      CR();
+    }
+    break;
+
+  case CMARK_NODE_TEXT:
+    OUT(cmark_node_get_literal(node), allow_wrap, NORMAL);
+    break;
+
+  case CMARK_NODE_LINEBREAK:
+    LIT(".PD 0\n.P\n.PD");
+    CR();
+    break;
+
+  case CMARK_NODE_SOFTBREAK:
+    if (options & CMARK_OPT_HARDBREAKS) {
+      LIT(".PD 0\n.P\n.PD");
+      CR();
+    } else if (renderer->width == 0 && !(CMARK_OPT_NOBREAKS & options)) {
+      CR();
+    } else {
+      OUT(" ", allow_wrap, LITERAL);
+    }
+    break;
+
+  case CMARK_NODE_CODE:
+    LIT("\\f[C]");
+    OUT(cmark_node_get_literal(node), allow_wrap, NORMAL);
+    LIT("\\f[]");
+    break;
+
+  case CMARK_NODE_HTML_INLINE:
+    break;
+
+  case CMARK_NODE_CUSTOM_INLINE:
+    OUT(entering ? cmark_node_get_on_enter(node) : cmark_node_get_on_exit(node),
+        false, LITERAL);
+    break;
+
+  case CMARK_NODE_STRONG:
+    if (entering) {
+      LIT("\\f[B]");
+    } else {
+      LIT("\\f[]");
+    }
+    break;
+
+  case CMARK_NODE_EMPH:
+    if (entering) {
+      LIT("\\f[I]");
+    } else {
+      LIT("\\f[]");
+    }
+    break;
+
+  case CMARK_NODE_LINK:
+    if (!entering) {
+      LIT(" (");
+      OUT(cmark_node_get_url(node), allow_wrap, URL);
+      LIT(")");
+    }
+    break;
+
+  case CMARK_NODE_IMAGE:
+    if (entering) {
+      LIT("[IMAGE: ");
+    } else {
+      LIT("]");
+    }
+    break;
+
+  default:
+    assert(false);
+    break;
+  }
+
+  return 1;
+}
+
+char *cmark_render_man(cmark_node *root, int options, int width) {
+  return cmark_render(root, options, width, S_outc, S_render_node);
+}

deps/cmark/src/node.c

@@ -0,0 +1,872 @@
+#include <stdlib.h>
+#include <string.h>
+
+#include "config.h"
+#include "node.h"
+
+static void S_node_unlink(cmark_node *node);
+
+static CMARK_INLINE bool S_is_block(cmark_node *node) {
+  if (node == NULL) {
+    return false;
+  }
+  return node->type >= CMARK_NODE_FIRST_BLOCK &&
+         node->type <= CMARK_NODE_LAST_BLOCK;
+}
+
+static CMARK_INLINE bool S_is_inline(cmark_node *node) {
+  if (node == NULL) {
+    return false;
+  }
+  return node->type >= CMARK_NODE_FIRST_INLINE &&
+         node->type <= CMARK_NODE_LAST_INLINE;
+}
+
+static bool S_can_contain(cmark_node *node, cmark_node *child) {
+  if (node == NULL || child == NULL || node == child) {
+    return false;
+  }
+
+  // Verify that child is not an ancestor of node.
+  if (child->first_child != NULL) {
+    cmark_node *cur = node->parent;
+
+    while (cur != NULL) {
+      if (cur == child) {
+        return false;
+      }
+      cur = cur->parent;
+    }
+  }
+
+  if (child->type == CMARK_NODE_DOCUMENT) {
+    return false;
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_DOCUMENT:
+  case CMARK_NODE_BLOCK_QUOTE:
+  case CMARK_NODE_ITEM:
+    return S_is_block(child) && child->type != CMARK_NODE_ITEM;
+
+  case CMARK_NODE_LIST:
+    return child->type == CMARK_NODE_ITEM;
+
+  case CMARK_NODE_CUSTOM_BLOCK:
+    return true;
+
+  case CMARK_NODE_PARAGRAPH:
+  case CMARK_NODE_HEADING:
+  case CMARK_NODE_EMPH:
+  case CMARK_NODE_STRONG:
+  case CMARK_NODE_LINK:
+  case CMARK_NODE_IMAGE:
+  case CMARK_NODE_CUSTOM_INLINE:
+    return S_is_inline(child);
+
+  default:
+    break;
+  }
+
+  return false;
+}
+
+cmark_node *cmark_node_new_with_mem(cmark_node_type type, cmark_mem *mem) {
+  cmark_node *node = (cmark_node *)mem->calloc(1, sizeof(*node));
+  node->mem = mem;
+  node->type = (uint16_t)type;
+
+  switch (node->type) {
+  case CMARK_NODE_HEADING:
+    node->as.heading.level = 1;
+    break;
+
+  case CMARK_NODE_LIST: {
+    cmark_list *list = &node->as.list;
+    list->list_type = CMARK_BULLET_LIST;
+    list->start = 0;
+    list->tight = false;
+    break;
+  }
+
+  default:
+    break;
+  }
+
+  return node;
+}
+
+cmark_node *cmark_node_new(cmark_node_type type) {
+  extern cmark_mem DEFAULT_MEM_ALLOCATOR;
+  return cmark_node_new_with_mem(type, &DEFAULT_MEM_ALLOCATOR);
+}
+
+// Free a cmark_node list and any children.
+static void S_free_nodes(cmark_node *e) {
+  cmark_mem *mem = e->mem;
+  cmark_node *next;
+  while (e != NULL) {
+    switch (e->type) {
+    case CMARK_NODE_CODE_BLOCK:
+      mem->free(e->data);
+      mem->free(e->as.code.info);
+      break;
+    case CMARK_NODE_TEXT:
+    case CMARK_NODE_HTML_INLINE:
+    case CMARK_NODE_CODE:
+    case CMARK_NODE_HTML_BLOCK:
+      mem->free(e->data);
+      break;
+    case CMARK_NODE_LINK:
+    case CMARK_NODE_IMAGE:
+      mem->free(e->as.link.url);
+      mem->free(e->as.link.title);
+      break;
+    case CMARK_NODE_CUSTOM_BLOCK:
+    case CMARK_NODE_CUSTOM_INLINE:
+      mem->free(e->as.custom.on_enter);
+      mem->free(e->as.custom.on_exit);
+      break;
+    default:
+      break;
+    }
+    if (e->last_child) {
+      // Splice children into list
+      e->last_child->next = e->next;
+      e->next = e->first_child;
+    }
+    next = e->next;
+    mem->free(e);
+    e = next;
+  }
+}
+
+void cmark_node_free(cmark_node *node) {
+  S_node_unlink(node);
+  node->next = NULL;
+  S_free_nodes(node);
+}
+
+cmark_node_type cmark_node_get_type(cmark_node *node) {
+  if (node == NULL) {
+    return CMARK_NODE_NONE;
+  } else {
+    return (cmark_node_type)node->type;
+  }
+}
+
+const char *cmark_node_get_type_string(cmark_node *node) {
+  if (node == NULL) {
+    return "NONE";
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_NONE:
+    return "none";
+  case CMARK_NODE_DOCUMENT:
+    return "document";
+  case CMARK_NODE_BLOCK_QUOTE:
+    return "block_quote";
+  case CMARK_NODE_LIST:
+    return "list";
+  case CMARK_NODE_ITEM:
+    return "item";
+  case CMARK_NODE_CODE_BLOCK:
+    return "code_block";
+  case CMARK_NODE_HTML_BLOCK:
+    return "html_block";
+  case CMARK_NODE_CUSTOM_BLOCK:
+    return "custom_block";
+  case CMARK_NODE_PARAGRAPH:
+    return "paragraph";
+  case CMARK_NODE_HEADING:
+    return "heading";
+  case CMARK_NODE_THEMATIC_BREAK:
+    return "thematic_break";
+  case CMARK_NODE_TEXT:
+    return "text";
+  case CMARK_NODE_SOFTBREAK:
+    return "softbreak";
+  case CMARK_NODE_LINEBREAK:
+    return "linebreak";
+  case CMARK_NODE_CODE:
+    return "code";
+  case CMARK_NODE_HTML_INLINE:
+    return "html_inline";
+  case CMARK_NODE_CUSTOM_INLINE:
+    return "custom_inline";
+  case CMARK_NODE_EMPH:
+    return "emph";
+  case CMARK_NODE_STRONG:
+    return "strong";
+  case CMARK_NODE_LINK:
+    return "link";
+  case CMARK_NODE_IMAGE:
+    return "image";
+  }
+
+  return "<unknown>";
+}
+
+cmark_node *cmark_node_next(cmark_node *node) {
+  if (node == NULL) {
+    return NULL;
+  } else {
+    return node->next;
+  }
+}
+
+cmark_node *cmark_node_previous(cmark_node *node) {
+  if (node == NULL) {
+    return NULL;
+  } else {
+    return node->prev;
+  }
+}
+
+cmark_node *cmark_node_parent(cmark_node *node) {
+  if (node == NULL) {
+    return NULL;
+  } else {
+    return node->parent;
+  }
+}
+
+cmark_node *cmark_node_first_child(cmark_node *node) {
+  if (node == NULL) {
+    return NULL;
+  } else {
+    return node->first_child;
+  }
+}
+
+cmark_node *cmark_node_last_child(cmark_node *node) {
+  if (node == NULL) {
+    return NULL;
+  } else {
+    return node->last_child;
+  }
+}
+
+static bufsize_t cmark_set_cstr(cmark_mem *mem, unsigned char **dst,
+                                const char *src) {
+  unsigned char *old = *dst;
+  bufsize_t len;
+
+  if (src && src[0]) {
+      len = (bufsize_t)strlen(src);
+      *dst = (unsigned char *)mem->realloc(NULL, len + 1);
+      memcpy(*dst, src, len + 1);
+  } else {
+      len = 0;
+      *dst = NULL;
+  }
+  if (old) {
+    mem->free(old);
+  }
+
+  return len;
+}
+
+void *cmark_node_get_user_data(cmark_node *node) {
+  if (node == NULL) {
+    return NULL;
+  } else {
+    return node->user_data;
+  }
+}
+
+int cmark_node_set_user_data(cmark_node *node, void *user_data) {
+  if (node == NULL) {
+    return 0;
+  }
+  node->user_data = user_data;
+  return 1;
+}
+
+const char *cmark_node_get_literal(cmark_node *node) {
+  if (node == NULL) {
+    return NULL;
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_HTML_BLOCK:
+  case CMARK_NODE_TEXT:
+  case CMARK_NODE_HTML_INLINE:
+  case CMARK_NODE_CODE:
+  case CMARK_NODE_CODE_BLOCK:
+    return node->data ? (char *)node->data : "";
+
+  default:
+    break;
+  }
+
+  return NULL;
+}
+
+int cmark_node_set_literal(cmark_node *node, const char *content) {
+  if (node == NULL) {
+    return 0;
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_HTML_BLOCK:
+  case CMARK_NODE_TEXT:
+  case CMARK_NODE_HTML_INLINE:
+  case CMARK_NODE_CODE:
+  case CMARK_NODE_CODE_BLOCK:
+    node->len = cmark_set_cstr(node->mem, &node->data, content);
+    return 1;
+
+  default:
+    break;
+  }
+
+  return 0;
+}
+
+int cmark_node_get_heading_level(cmark_node *node) {
+  if (node == NULL) {
+    return 0;
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_HEADING:
+    return node->as.heading.level;
+
+  default:
+    break;
+  }
+
+  return 0;
+}
+
+int cmark_node_set_heading_level(cmark_node *node, int level) {
+  if (node == NULL || level < 1 || level > 6) {
+    return 0;
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_HEADING:
+    node->as.heading.level = level;
+    return 1;
+
+  default:
+    break;
+  }
+
+  return 0;
+}
+
+cmark_list_type cmark_node_get_list_type(cmark_node *node) {
+  if (node == NULL) {
+    return CMARK_NO_LIST;
+  }
+
+  if (node->type == CMARK_NODE_LIST) {
+    return (cmark_list_type)node->as.list.list_type;
+  } else {
+    return CMARK_NO_LIST;
+  }
+}
+
+int cmark_node_set_list_type(cmark_node *node, cmark_list_type type) {
+  if (!(type == CMARK_BULLET_LIST || type == CMARK_ORDERED_LIST)) {
+    return 0;
+  }
+
+  if (node == NULL) {
+    return 0;
+  }
+
+  if (node->type == CMARK_NODE_LIST) {
+    node->as.list.list_type = (unsigned char)type;
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
+cmark_delim_type cmark_node_get_list_delim(cmark_node *node) {
+  if (node == NULL) {
+    return CMARK_NO_DELIM;
+  }
+
+  if (node->type == CMARK_NODE_LIST) {
+    return (cmark_delim_type)node->as.list.delimiter;
+  } else {
+    return CMARK_NO_DELIM;
+  }
+}
+
+int cmark_node_set_list_delim(cmark_node *node, cmark_delim_type delim) {
+  if (!(delim == CMARK_PERIOD_DELIM || delim == CMARK_PAREN_DELIM)) {
+    return 0;
+  }
+
+  if (node == NULL) {
+    return 0;
+  }
+
+  if (node->type == CMARK_NODE_LIST) {
+    node->as.list.delimiter = (unsigned char)delim;
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
+int cmark_node_get_list_start(cmark_node *node) {
+  if (node == NULL) {
+    return 0;
+  }
+
+  if (node->type == CMARK_NODE_LIST) {
+    return node->as.list.start;
+  } else {
+    return 0;
+  }
+}
+
+int cmark_node_set_list_start(cmark_node *node, int start) {
+  if (node == NULL || start < 0) {
+    return 0;
+  }
+
+  if (node->type == CMARK_NODE_LIST) {
+    node->as.list.start = start;
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
+int cmark_node_get_list_tight(cmark_node *node) {
+  if (node == NULL) {
+    return 0;
+  }
+
+  if (node->type == CMARK_NODE_LIST) {
+    return node->as.list.tight;
+  } else {
+    return 0;
+  }
+}
+
+int cmark_node_set_list_tight(cmark_node *node, int tight) {
+  if (node == NULL) {
+    return 0;
+  }
+
+  if (node->type == CMARK_NODE_LIST) {
+    node->as.list.tight = tight == 1;
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
+const char *cmark_node_get_fence_info(cmark_node *node) {
+  if (node == NULL) {
+    return NULL;
+  }
+
+  if (node->type == CMARK_NODE_CODE_BLOCK) {
+    return node->as.code.info ? (char *)node->as.code.info : "";
+  } else {
+    return NULL;
+  }
+}
+
+int cmark_node_set_fence_info(cmark_node *node, const char *info) {
+  if (node == NULL) {
+    return 0;
+  }
+
+  if (node->type == CMARK_NODE_CODE_BLOCK) {
+    cmark_set_cstr(node->mem, &node->as.code.info, info);
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
+const char *cmark_node_get_url(cmark_node *node) {
+  if (node == NULL) {
+    return NULL;
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_LINK:
+  case CMARK_NODE_IMAGE:
+    return node->as.link.url ? (char *)node->as.link.url : "";
+  default:
+    break;
+  }
+
+  return NULL;
+}
+
+int cmark_node_set_url(cmark_node *node, const char *url) {
+  if (node == NULL) {
+    return 0;
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_LINK:
+  case CMARK_NODE_IMAGE:
+    cmark_set_cstr(node->mem, &node->as.link.url, url);
+    return 1;
+  default:
+    break;
+  }
+
+  return 0;
+}
+
+const char *cmark_node_get_title(cmark_node *node) {
+  if (node == NULL) {
+    return NULL;
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_LINK:
+  case CMARK_NODE_IMAGE:
+    return node->as.link.title ? (char *)node->as.link.title : "";
+  default:
+    break;
+  }
+
+  return NULL;
+}
+
+int cmark_node_set_title(cmark_node *node, const char *title) {
+  if (node == NULL) {
+    return 0;
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_LINK:
+  case CMARK_NODE_IMAGE:
+    cmark_set_cstr(node->mem, &node->as.link.title, title);
+    return 1;
+  default:
+    break;
+  }
+
+  return 0;
+}
+
+const char *cmark_node_get_on_enter(cmark_node *node) {
+  if (node == NULL) {
+    return NULL;
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_CUSTOM_INLINE:
+  case CMARK_NODE_CUSTOM_BLOCK:
+    return node->as.custom.on_enter ? (char *)node->as.custom.on_enter : "";
+  default:
+    break;
+  }
+
+  return NULL;
+}
+
+int cmark_node_set_on_enter(cmark_node *node, const char *on_enter) {
+  if (node == NULL) {
+    return 0;
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_CUSTOM_INLINE:
+  case CMARK_NODE_CUSTOM_BLOCK:
+    cmark_set_cstr(node->mem, &node->as.custom.on_enter, on_enter);
+    return 1;
+  default:
+    break;
+  }
+
+  return 0;
+}
+
+const char *cmark_node_get_on_exit(cmark_node *node) {
+  if (node == NULL) {
+    return NULL;
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_CUSTOM_INLINE:
+  case CMARK_NODE_CUSTOM_BLOCK:
+    return node->as.custom.on_exit ? (char *)node->as.custom.on_exit : "";
+  default:
+    break;
+  }
+
+  return NULL;
+}
+
+int cmark_node_set_on_exit(cmark_node *node, const char *on_exit) {
+  if (node == NULL) {
+    return 0;
+  }
+
+  switch (node->type) {
+  case CMARK_NODE_CUSTOM_INLINE:
+  case CMARK_NODE_CUSTOM_BLOCK:
+    cmark_set_cstr(node->mem, &node->as.custom.on_exit, on_exit);
+    return 1;
+  default:
+    break;
+  }
+
+  return 0;
+}
+
+int cmark_node_get_start_line(cmark_node *node) {
+  if (node == NULL) {
+    return 0;
+  }
+  return node->start_line;
+}
+
+int cmark_node_get_start_column(cmark_node *node) {
+  if (node == NULL) {
+    return 0;
+  }
+  return node->start_column;
+}
+
+int cmark_node_get_end_line(cmark_node *node) {
+  if (node == NULL) {
+    return 0;
+  }
+  return node->end_line;
+}
+
+int cmark_node_get_end_column(cmark_node *node) {
+  if (node == NULL) {
+    return 0;
+  }
+  return node->end_column;
+}
+
+// Unlink a node without adjusting its next, prev, and parent pointers.
+static void S_node_unlink(cmark_node *node) {
+  if (node == NULL) {
+    return;
+  }
+
+  if (node->prev) {
+    node->prev->next = node->next;
+  }
+  if (node->next) {
+    node->next->prev = node->prev;
+  }
+
+  // Adjust first_child and last_child of parent.
+  cmark_node *parent = node->parent;
+  if (parent) {
+    if (parent->first_child == node) {
+      parent->first_child = node->next;
+    }
+    if (parent->last_child == node) {
+      parent->last_child = node->prev;
+    }
+  }
+}
+
+void cmark_node_unlink(cmark_node *node) {
+  S_node_unlink(node);
+
+  node->next = NULL;
+  node->prev = NULL;
+  node->parent = NULL;
+}
+
+int cmark_node_insert_before(cmark_node *node, cmark_node *sibling) {
+  if (node == NULL || sibling == NULL) {
+    return 0;
+  }
+
+  if (!node->parent || !S_can_contain(node->parent, sibling)) {
+    return 0;
+  }
+
+  S_node_unlink(sibling);
+
+  cmark_node *old_prev = node->prev;
+
+  // Insert 'sibling' between 'old_prev' and 'node'.
+  if (old_prev) {
+    old_prev->next = sibling;
+  }
+  sibling->prev = old_prev;
+  sibling->next = node;
+  node->prev = sibling;
+
+  // Set new parent.
+  cmark_node *parent = node->parent;
+  sibling->parent = parent;
+
+  // Adjust first_child of parent if inserted as first child.
+  if (parent && !old_prev) {
+    parent->first_child = sibling;
+  }
+
+  return 1;
+}
+
+int cmark_node_insert_after(cmark_node *node, cmark_node *sibling) {
+  if (node == NULL || sibling == NULL) {
+    return 0;
+  }
+
+  if (!node->parent || !S_can_contain(node->parent, sibling)) {
+    return 0;
+  }
+
+  S_node_unlink(sibling);
+
+  cmark_node *old_next = node->next;
+
+  // Insert 'sibling' between 'node' and 'old_next'.
+  if (old_next) {
+    old_next->prev = sibling;
+  }
+  sibling->next = old_next;
+  sibling->prev = node;
+  node->next = sibling;
+
+  // Set new parent.
+  cmark_node *parent = node->parent;
+  sibling->parent = parent;
+
+  // Adjust last_child of parent if inserted as last child.
+  if (parent && !old_next) {
+    parent->last_child = sibling;
+  }
+
+  return 1;
+}
+
+int cmark_node_replace(cmark_node *oldnode, cmark_node *newnode) {
+  if (!cmark_node_insert_before(oldnode, newnode)) {
+    return 0;
+  }
+  cmark_node_unlink(oldnode);
+  return 1;
+}
+
+int cmark_node_prepend_child(cmark_node *node, cmark_node *child) {
+  if (!S_can_contain(node, child)) {
+    return 0;
+  }
+
+  S_node_unlink(child);
+
+  cmark_node *old_first_child = node->first_child;
+
+  child->next = old_first_child;
+  child->prev = NULL;
+  child->parent = node;
+  node->first_child = child;
+
+  if (old_first_child) {
+    old_first_child->prev = child;
+  } else {
+    // Also set last_child if node previously had no children.
+    node->last_child = child;
+  }
+
+  return 1;
+}
+
+int cmark_node_append_child(cmark_node *node, cmark_node *child) {
+  if (!S_can_contain(node, child)) {
+    return 0;
+  }
+
+  S_node_unlink(child);
+
+  cmark_node *old_last_child = node->last_child;
+
+  child->next = NULL;
+  child->prev = old_last_child;
+  child->parent = node;
+  node->last_child = child;
+
+  if (old_last_child) {
+    old_last_child->next = child;
+  } else {
+    // Also set first_child if node previously had no children.
+    node->first_child = child;
+  }
+
+  return 1;
+}
+
+static void S_print_error(FILE *out, cmark_node *node, const char *elem) {
+  if (out == NULL) {
+    return;
+  }
+  fprintf(out, "Invalid '%s' in node type %s at %d:%d\n", elem,
+          cmark_node_get_type_string(node), node->start_line,
+          node->start_column);
+}
+
+int cmark_node_check(cmark_node *node, FILE *out) {
+  cmark_node *cur;
+  int errors = 0;
+
+  if (!node) {
+    return 0;
+  }
+
+  cur = node;
+  for (;;) {
+    if (cur->first_child) {
+      if (cur->first_child->prev != NULL) {
+        S_print_error(out, cur->first_child, "prev");
+        cur->first_child->prev = NULL;
+        ++errors;
+      }
+      if (cur->first_child->parent != cur) {
+        S_print_error(out, cur->first_child, "parent");
+        cur->first_child->parent = cur;
+        ++errors;
+      }
+      cur = cur->first_child;
+      continue;
+    }
+
+  next_sibling:
+    if (cur == node) {
+      break;
+    }
+    if (cur->next) {
+      if (cur->next->prev != cur) {
+        S_print_error(out, cur->next, "prev");
+        cur->next->prev = cur;
+        ++errors;
+      }
+      if (cur->next->parent != cur->parent) {
+        S_print_error(out, cur->next, "parent");
+        cur->next->parent = cur->parent;
+        ++errors;
+      }
+      cur = cur->next;
+      continue;
+    }
+
+    if (cur->parent->last_child != cur) {
+      S_print_error(out, cur->parent, "last_child");
+      cur->parent->last_child = cur;
+      ++errors;
+    }
+    cur = cur->parent;
+    goto next_sibling;
+  }
+
+  return errors;
+}

deps/cmark/src/node.h

@@ -0,0 +1,92 @@
+#ifndef CMARK_NODE_H
+#define CMARK_NODE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdio.h>
+#include <stdint.h>
+
+#include "config.h"
+#include "cmark.h"
+#include "buffer.h"
+
+typedef struct {
+  int marker_offset;
+  int padding;
+  int start;
+  unsigned char list_type;
+  unsigned char delimiter;
+  unsigned char bullet_char;
+  bool tight;
+} cmark_list;
+
+typedef struct {
+  unsigned char *info;
+  uint8_t fence_length;
+  uint8_t fence_offset;
+  unsigned char fence_char;
+  int8_t fenced;
+} cmark_code;
+
+typedef struct {
+  int internal_offset;
+  int8_t level;
+  bool setext;
+} cmark_heading;
+
+typedef struct {
+  unsigned char *url;
+  unsigned char *title;
+} cmark_link;
+
+typedef struct {
+  unsigned char *on_enter;
+  unsigned char *on_exit;
+} cmark_custom;
+
+enum cmark_node__internal_flags {
+  CMARK_NODE__OPEN = (1 << 0),
+  CMARK_NODE__LAST_LINE_BLANK = (1 << 1),
+  CMARK_NODE__LAST_LINE_CHECKED = (1 << 2),
+};
+
+struct cmark_node {
+  cmark_mem *mem;
+
+  struct cmark_node *next;
+  struct cmark_node *prev;
+  struct cmark_node *parent;
+  struct cmark_node *first_child;
+  struct cmark_node *last_child;
+
+  void *user_data;
+
+  unsigned char *data;
+  bufsize_t len;
+
+  int start_line;
+  int start_column;
+  int end_line;
+  int end_column;
+  uint16_t type;
+  uint16_t flags;
+
+  union {
+    cmark_list list;
+    cmark_code code;
+    cmark_heading heading;
+    cmark_link link;
+    cmark_custom custom;
+    int html_block_type;
+  } as;
+};
+
+CMARK_EXPORT int cmark_node_check(cmark_node *node, FILE *out);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

deps/cmark/src/parser.h

@@ -0,0 +1,42 @@
+#ifndef CMARK_AST_H
+#define CMARK_AST_H
+
+#include <stdio.h>
+#include "references.h"
+#include "node.h"
+#include "buffer.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define MAX_LINK_LABEL_LENGTH 1000
+
+struct cmark_parser {
+  struct cmark_mem *mem;
+  struct cmark_reference_map *refmap;
+  struct cmark_node *root;
+  struct cmark_node *current;
+  int line_number;
+  bufsize_t offset;
+  bufsize_t column;
+  bufsize_t first_nonspace;
+  bufsize_t first_nonspace_column;
+  bufsize_t thematic_break_kill_pos;
+  int indent;
+  bool blank;
+  bool partially_consumed_tab;
+  cmark_strbuf curline;
+  bufsize_t last_line_length;
+  cmark_strbuf linebuf;
+  cmark_strbuf content;
+  int options;
+  bool last_buffer_ended_with_cr;
+  unsigned int total_size;
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

deps/cmark/src/references.c

@@ -0,0 +1,171 @@
+#include "cmark.h"
+#include "utf8.h"
+#include "parser.h"
+#include "references.h"
+#include "inlines.h"
+#include "chunk.h"
+
+static void reference_free(cmark_reference_map *map, cmark_reference *ref) {
+  cmark_mem *mem = map->mem;
+  if (ref != NULL) {
+    mem->free(ref->label);
+    mem->free(ref->url);
+    mem->free(ref->title);
+    mem->free(ref);
+  }
+}
+
+// normalize reference:  collapse internal whitespace to single space,
+// remove leading/trailing whitespace, case fold
+// Return NULL if the reference name is actually empty (i.e. composed
+// solely from whitespace)
+static unsigned char *normalize_reference(cmark_mem *mem, cmark_chunk *ref) {
+  cmark_strbuf normalized = CMARK_BUF_INIT(mem);
+  unsigned char *result;
+
+  if (ref == NULL)
+    return NULL;
+
+  if (ref->len == 0)
+    return NULL;
+
+  cmark_utf8proc_case_fold(&normalized, ref->data, ref->len);
+  cmark_strbuf_trim(&normalized);
+  cmark_strbuf_normalize_whitespace(&normalized);
+
+  result = cmark_strbuf_detach(&normalized);
+  assert(result);
+
+  if (result[0] == '\0') {
+    mem->free(result);
+    return NULL;
+  }
+
+  return result;
+}
+
+void cmark_reference_create(cmark_reference_map *map, cmark_chunk *label,
+                            cmark_chunk *url, cmark_chunk *title) {
+  cmark_reference *ref;
+  unsigned char *reflabel = normalize_reference(map->mem, label);
+
+  /* empty reference name, or composed from only whitespace */
+  if (reflabel == NULL)
+    return;
+
+  assert(map->sorted == NULL);
+
+  ref = (cmark_reference *)map->mem->calloc(1, sizeof(*ref));
+  ref->label = reflabel;
+  ref->url = cmark_clean_url(map->mem, url);
+  ref->title = cmark_clean_title(map->mem, title);
+  ref->age = map->size;
+  ref->next = map->refs;
+
+  if (ref->url != NULL)
+    ref->size += strlen((char*)ref->url);
+  if (ref->title != NULL)
+    ref->size += strlen((char*)ref->title);
+
+  map->refs = ref;
+  map->size++;
+}
+
+static int
+labelcmp(const unsigned char *a, const unsigned char *b) {
+  return strcmp((const char *)a, (const char *)b);
+}
+
+static int
+refcmp(const void *p1, const void *p2) {
+  cmark_reference *r1 = *(cmark_reference **)p1;
+  cmark_reference *r2 = *(cmark_reference **)p2;
+  int res = labelcmp(r1->label, r2->label);
+  return res ? res : ((int)r1->age - (int)r2->age);
+}
+
+static int
+refsearch(const void *label, const void *p2) {
+  cmark_reference *ref = *(cmark_reference **)p2;
+  return labelcmp((const unsigned char *)label, ref->label);
+}
+
+static void sort_references(cmark_reference_map *map) {
+  unsigned int i = 0, last = 0, size = map->size;
+  cmark_reference *r = map->refs, **sorted = NULL;
+
+  sorted = (cmark_reference **)map->mem->calloc(size, sizeof(cmark_reference *));
+  while (r) {
+    sorted[i++] = r;
+    r = r->next;
+  }
+
+  qsort(sorted, size, sizeof(cmark_reference *), refcmp);
+
+  for (i = 1; i < size; i++) {
+    if (labelcmp(sorted[i]->label, sorted[last]->label) != 0)
+      sorted[++last] = sorted[i];
+  }
+  map->sorted = sorted;
+  map->size = last + 1;
+}
+
+// Returns reference if refmap contains a reference with matching
+// label, otherwise NULL.
+cmark_reference *cmark_reference_lookup(cmark_reference_map *map,
+                                        cmark_chunk *label) {
+  cmark_reference **ref = NULL;
+  cmark_reference *r = NULL;
+  unsigned char *norm;
+
+  if (label->len < 1 || label->len > MAX_LINK_LABEL_LENGTH)
+    return NULL;
+
+  if (map == NULL || !map->size)
+    return NULL;
+
+  norm = normalize_reference(map->mem, label);
+  if (norm == NULL)
+    return NULL;
+
+  if (!map->sorted)
+    sort_references(map);
+
+  ref = (cmark_reference **)bsearch(norm, map->sorted, map->size, sizeof(cmark_reference *),
+                refsearch);
+  map->mem->free(norm);
+
+  if (ref != NULL) {
+    r = ref[0];
+    /* Check for expansion limit */
+    if (map->max_ref_size && r->size > map->max_ref_size - map->ref_size)
+      return NULL;
+    map->ref_size += r->size;
+  }
+
+  return r;
+}
+
+void cmark_reference_map_free(cmark_reference_map *map) {
+  cmark_reference *ref;
+
+  if (map == NULL)
+    return;
+
+  ref = map->refs;
+  while (ref) {
+    cmark_reference *next = ref->next;
+    reference_free(map, ref);
+    ref = next;
+  }
+
+  map->mem->free(map->sorted);
+  map->mem->free(map);
+}
+
+cmark_reference_map *cmark_reference_map_new(cmark_mem *mem) {
+  cmark_reference_map *map =
+      (cmark_reference_map *)mem->calloc(1, sizeof(cmark_reference_map));
+  map->mem = mem;
+  return map;
+}

deps/cmark/src/references.h

@@ -0,0 +1,43 @@
+#ifndef CMARK_REFERENCES_H
+#define CMARK_REFERENCES_H
+
+#include "chunk.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct cmark_reference {
+  struct cmark_reference *next;
+  unsigned char *label;
+  unsigned char *url;
+  unsigned char *title;
+  unsigned int age;
+  unsigned int size;
+};
+
+typedef struct cmark_reference cmark_reference;
+
+struct cmark_reference_map {
+  cmark_mem *mem;
+  cmark_reference *refs;
+  cmark_reference **sorted;
+  unsigned int size;
+  unsigned int ref_size;
+  unsigned int max_ref_size;
+};
+
+typedef struct cmark_reference_map cmark_reference_map;
+
+cmark_reference_map *cmark_reference_map_new(cmark_mem *mem);
+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);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

deps/cmark/src/render.c

@@ -0,0 +1,193 @@
+#include <stdlib.h>
+#include "buffer.h"
+#include "cmark.h"
+#include "utf8.h"
+#include "render.h"
+#include "node.h"
+#include "cmark_ctype.h"
+
+static CMARK_INLINE void S_cr(cmark_renderer *renderer) {
+  if (renderer->need_cr < 1) {
+    renderer->need_cr = 1;
+  }
+}
+
+static CMARK_INLINE void S_blankline(cmark_renderer *renderer) {
+  if (renderer->need_cr < 2) {
+    renderer->need_cr = 2;
+  }
+}
+
+static void S_out(cmark_renderer *renderer, const char *source, bool wrap,
+                  cmark_escaping escape) {
+  int length = strlen(source);
+  unsigned char nextc;
+  int32_t c;
+  int i = 0;
+  int last_nonspace;
+  int len;
+  int k = renderer->buffer->size - 1;
+
+  wrap = wrap && !renderer->no_linebreaks;
+
+  if (renderer->in_tight_list_item && renderer->need_cr > 1) {
+    renderer->need_cr = 1;
+  }
+  while (renderer->need_cr) {
+    if (k < 0 || renderer->buffer->ptr[k] == '\n') {
+      k -= 1;
+    } else {
+      cmark_strbuf_putc(renderer->buffer, '\n');
+      if (renderer->need_cr > 1) {
+        cmark_strbuf_put(renderer->buffer, renderer->prefix->ptr,
+                         renderer->prefix->size);
+      }
+    }
+    renderer->column = 0;
+    renderer->last_breakable = 0;
+    renderer->begin_line = true;
+    renderer->begin_content = true;
+    renderer->need_cr -= 1;
+  }
+
+  while (i < length) {
+    if (renderer->begin_line) {
+      cmark_strbuf_put(renderer->buffer, renderer->prefix->ptr,
+                       renderer->prefix->size);
+      // note: this assumes prefix is ascii:
+      renderer->column = renderer->prefix->size;
+    }
+
+    len = cmark_utf8proc_iterate((const uint8_t *)source + i, length - i, &c);
+    if (len == -1) { // error condition
+      return;        // return without rendering rest of string
+    }
+    nextc = source[i + len];
+    if (c == 32 && wrap) {
+      if (!renderer->begin_line) {
+        last_nonspace = renderer->buffer->size;
+        cmark_strbuf_putc(renderer->buffer, ' ');
+        renderer->column += 1;
+        renderer->begin_line = false;
+        renderer->begin_content = false;
+        // skip following spaces
+        while (source[i + 1] == ' ') {
+          i++;
+        }
+        // We don't allow breaks that make a digit the first character
+        // because this causes problems with commonmark output.
+        if (!cmark_isdigit(source[i + 1])) {
+          renderer->last_breakable = last_nonspace;
+        }
+      }
+
+    } else if (escape == LITERAL) {
+      if (c == 10) {
+        cmark_strbuf_putc(renderer->buffer, '\n');
+        renderer->column = 0;
+        renderer->begin_line = true;
+        renderer->begin_content = true;
+        renderer->last_breakable = 0;
+      } else {
+        cmark_render_code_point(renderer, c);
+        renderer->begin_line = false;
+        // we don't set 'begin_content' to false til we've
+        // finished parsing a digit.  Reason:  in commonmark
+        // we need to escape a potential list marker after
+        // a digit:
+        renderer->begin_content =
+            renderer->begin_content && cmark_isdigit(c) == 1;
+      }
+    } else {
+      (renderer->outc)(renderer, escape, c, nextc);
+      renderer->begin_line = false;
+      renderer->begin_content =
+          renderer->begin_content && cmark_isdigit(c) == 1;
+    }
+
+    // If adding the character went beyond width, look for an
+    // earlier place where the line could be broken:
+    if (renderer->width > 0 && renderer->column > renderer->width &&
+        !renderer->begin_line && renderer->last_breakable > 0) {
+
+      // copy from last_breakable to remainder
+      unsigned char *src = renderer->buffer->ptr +
+                           renderer->last_breakable + 1;
+      bufsize_t remainder_len = renderer->buffer->size -
+                                renderer->last_breakable - 1;
+      unsigned char *remainder =
+          (unsigned char *)renderer->mem->realloc(NULL, remainder_len);
+      memcpy(remainder, src, remainder_len);
+      // truncate at last_breakable
+      cmark_strbuf_truncate(renderer->buffer, renderer->last_breakable);
+      // add newline, prefix, and remainder
+      cmark_strbuf_putc(renderer->buffer, '\n');
+      cmark_strbuf_put(renderer->buffer, renderer->prefix->ptr,
+                       renderer->prefix->size);
+      cmark_strbuf_put(renderer->buffer, remainder, remainder_len);
+      renderer->column = renderer->prefix->size + remainder_len;
+      renderer->mem->free(remainder);
+      renderer->last_breakable = 0;
+      renderer->begin_line = false;
+      renderer->begin_content = false;
+    }
+
+    i += len;
+  }
+}
+
+// Assumes no newlines, assumes ascii content:
+void cmark_render_ascii(cmark_renderer *renderer, const char *s) {
+  int origsize = renderer->buffer->size;
+  cmark_strbuf_puts(renderer->buffer, s);
+  renderer->column += renderer->buffer->size - origsize;
+}
+
+void cmark_render_code_point(cmark_renderer *renderer, uint32_t c) {
+  cmark_utf8proc_encode_char(c, renderer->buffer);
+  renderer->column += 1;
+}
+
+char *cmark_render(cmark_node *root, int options, int width,
+                   void (*outc)(cmark_renderer *, cmark_escaping, int32_t,
+                                unsigned char),
+                   int (*render_node)(cmark_renderer *renderer,
+                                      cmark_node *node,
+                                      cmark_event_type ev_type, int options)) {
+  cmark_mem *mem = root->mem;
+  cmark_strbuf pref = CMARK_BUF_INIT(mem);
+  cmark_strbuf buf = CMARK_BUF_INIT(mem);
+  cmark_node *cur;
+  cmark_event_type ev_type;
+  char *result;
+  cmark_iter *iter = cmark_iter_new(root);
+
+  cmark_renderer renderer = {options,
+                             mem,    &buf,    &pref,      0,      width,
+                             0,      0,       true,       true,   false,
+                             false,  NULL,
+                             outc,   S_cr,    S_blankline, S_out};
+
+  while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) {
+    cur = cmark_iter_get_node(iter);
+    if (!render_node(&renderer, cur, ev_type, options)) {
+      // a false value causes us to skip processing
+      // the node's contents.  this is used for
+      // autolinks.
+      cmark_iter_reset(iter, cur, CMARK_EVENT_EXIT);
+    }
+  }
+
+  // ensure final newline
+  if (renderer.buffer->size == 0 || renderer.buffer->ptr[renderer.buffer->size - 1] != '\n') {
+    cmark_strbuf_putc(renderer.buffer, '\n');
+  }
+
+  result = (char *)cmark_strbuf_detach(renderer.buffer);
+
+  cmark_iter_free(iter);
+  cmark_strbuf_free(renderer.prefix);
+  cmark_strbuf_free(renderer.buffer);
+
+  return result;
+}

deps/cmark/src/render.h

@@ -0,0 +1,55 @@
+#ifndef CMARK_RENDER_H
+#define CMARK_RENDER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdlib.h>
+#include "buffer.h"
+
+typedef enum { LITERAL, NORMAL, TITLE, URL } cmark_escaping;
+
+struct block_number {
+  int number;
+  struct block_number *parent;
+};
+
+struct cmark_renderer {
+  int options;
+  cmark_mem *mem;
+  cmark_strbuf *buffer;
+  cmark_strbuf *prefix;
+  int column;
+  int width;
+  int need_cr;
+  bufsize_t last_breakable;
+  bool begin_line;
+  bool begin_content;
+  bool no_linebreaks;
+  bool in_tight_list_item;
+  struct block_number *block_number_in_list_item;
+  void (*outc)(struct cmark_renderer *, cmark_escaping, int32_t, unsigned char);
+  void (*cr)(struct cmark_renderer *);
+  void (*blankline)(struct cmark_renderer *);
+  void (*out)(struct cmark_renderer *, const char *, bool, cmark_escaping);
+};
+
+typedef struct cmark_renderer cmark_renderer;
+
+void cmark_render_ascii(cmark_renderer *renderer, const char *s);
+
+void cmark_render_code_point(cmark_renderer *renderer, uint32_t c);
+
+char *cmark_render(cmark_node *root, int options, int width,
+                   void (*outc)(cmark_renderer *, cmark_escaping, int32_t,
+                                unsigned char),
+                   int (*render_node)(cmark_renderer *renderer,
+                                      cmark_node *node,
+                                      cmark_event_type ev_type, int options));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

deps/cmark/src/scanners.h

@@ -0,0 +1,61 @@
+#include "cmark.h"
+#include "chunk.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+bufsize_t _scan_at(bufsize_t (*scanner)(const unsigned char *), cmark_chunk *c,
+                   bufsize_t offset);
+bufsize_t _scan_scheme(const unsigned char *p);
+bufsize_t _scan_autolink_uri(const unsigned char *p);
+bufsize_t _scan_autolink_email(const unsigned char *p);
+bufsize_t _scan_html_tag(const unsigned char *p);
+bufsize_t _scan_html_comment(const unsigned char *p);
+bufsize_t _scan_html_pi(const unsigned char *p);
+bufsize_t _scan_html_declaration(const unsigned char *p);
+bufsize_t _scan_html_cdata(const unsigned char *p);
+bufsize_t _scan_html_block_start(const unsigned char *p);
+bufsize_t _scan_html_block_start_7(const unsigned char *p);
+bufsize_t _scan_html_block_end_1(const unsigned char *p);
+bufsize_t _scan_html_block_end_2(const unsigned char *p);
+bufsize_t _scan_html_block_end_3(const unsigned char *p);
+bufsize_t _scan_html_block_end_4(const unsigned char *p);
+bufsize_t _scan_html_block_end_5(const unsigned char *p);
+bufsize_t _scan_link_title(const unsigned char *p);
+bufsize_t _scan_spacechars(const unsigned char *p);
+bufsize_t _scan_atx_heading_start(const unsigned char *p);
+bufsize_t _scan_setext_heading_line(const unsigned char *p);
+bufsize_t _scan_open_code_fence(const unsigned char *p);
+bufsize_t _scan_close_code_fence(const unsigned char *p);
+bufsize_t _scan_entity(const unsigned char *p);
+bufsize_t _scan_dangerous_url(const unsigned char *p);
+
+#define scan_scheme(c, n) _scan_at(&_scan_scheme, c, n)
+#define scan_autolink_uri(c, n) _scan_at(&_scan_autolink_uri, c, n)
+#define scan_autolink_email(c, n) _scan_at(&_scan_autolink_email, c, n)
+#define scan_html_tag(c, n) _scan_at(&_scan_html_tag, c, n)
+#define scan_html_comment(c, n) _scan_at(&_scan_html_comment, c, n)
+#define scan_html_pi(c, n) _scan_at(&_scan_html_pi, c, n)
+#define scan_html_declaration(c, n) _scan_at(&_scan_html_declaration, c, n)
+#define scan_html_cdata(c, n) _scan_at(&_scan_html_cdata, c, n)
+#define scan_html_block_start(c, n) _scan_at(&_scan_html_block_start, c, n)
+#define scan_html_block_start_7(c, n) _scan_at(&_scan_html_block_start_7, c, n)
+#define scan_html_block_end_1(c, n) _scan_at(&_scan_html_block_end_1, c, n)
+#define scan_html_block_end_2(c, n) _scan_at(&_scan_html_block_end_2, c, n)
+#define scan_html_block_end_3(c, n) _scan_at(&_scan_html_block_end_3, c, n)
+#define scan_html_block_end_4(c, n) _scan_at(&_scan_html_block_end_4, c, n)
+#define scan_html_block_end_5(c, n) _scan_at(&_scan_html_block_end_5, c, n)
+#define scan_link_title(c, n) _scan_at(&_scan_link_title, c, n)
+#define scan_spacechars(c, n) _scan_at(&_scan_spacechars, c, n)
+#define scan_atx_heading_start(c, n) _scan_at(&_scan_atx_heading_start, c, n)
+#define scan_setext_heading_line(c, n)                                         \
+  _scan_at(&_scan_setext_heading_line, c, n)
+#define scan_open_code_fence(c, n) _scan_at(&_scan_open_code_fence, c, n)
+#define scan_close_code_fence(c, n) _scan_at(&_scan_close_code_fence, c, n)
+#define scan_entity(c, n) _scan_at(&_scan_entity, c, n)
+#define scan_dangerous_url(c, n) _scan_at(&_scan_dangerous_url, c, n)
+
+#ifdef __cplusplus
+}
+#endif

deps/cmark/src/scanners.re

@@ -0,0 +1,344 @@
+#include <stdlib.h>
+#include "chunk.h"
+#include "scanners.h"
+
+bufsize_t _scan_at(bufsize_t (*scanner)(const unsigned char *), cmark_chunk *c, bufsize_t offset)
+{
+	bufsize_t res;
+	unsigned char *ptr = (unsigned char *)c->data;
+
+        if (ptr == NULL || offset > c->len) {
+          return 0;
+        } else {
+	  unsigned char lim = ptr[c->len];
+
+	  ptr[c->len] = '\0';
+	  res = scanner(ptr + offset);
+	  ptr[c->len] = lim;
+        }
+
+	return res;
+}
+
+/*!re2c
+  re2c:define:YYCTYPE  = "unsigned char";
+  re2c:define:YYCURSOR = p;
+  re2c:define:YYMARKER = marker;
+  re2c:define:YYCTXMARKER = marker;
+  re2c:yyfill:enable = 0;
+
+  wordchar = [^\x00-\x20];
+
+  spacechar = [ \t\v\f\r\n];
+
+  reg_char     = [^\\()\x00-\x20];
+
+  escaped_char = [\\][!"#$%&'()*+,./:;<=>?@[\\\]^_`{|}~-];
+
+  tagname = [A-Za-z][A-Za-z0-9-]*;
+
+  blocktagname = 'address'|'article'|'aside'|'base'|'basefont'|'blockquote'|'body'|'caption'|'center'|'col'|'colgroup'|'dd'|'details'|'dialog'|'dir'|'div'|'dl'|'dt'|'fieldset'|'figcaption'|'figure'|'footer'|'form'|'frame'|'frameset'|'h1'|'h2'|'h3'|'h4'|'h5'|'h6'|'head'|'header'|'hr'|'html'|'iframe'|'legend'|'li'|'link'|'main'|'menu'|'menuitem'|'nav'|'noframes'|'ol'|'optgroup'|'option'|'p'|'param'|'section'|'source'|'title'|'summary'|'table'|'tbody'|'td'|'tfoot'|'th'|'thead'|'title'|'tr'|'track'|'ul';
+
+  attributename = [a-zA-Z_:][a-zA-Z0-9:._-]*;
+
+  unquotedvalue = [^ \t\r\n\v\f"'=<>`\x00]+;
+  singlequotedvalue = ['][^'\x00]*['];
+  doublequotedvalue = ["][^"\x00]*["];
+
+  attributevalue = unquotedvalue | singlequotedvalue | doublequotedvalue;
+
+  attributevaluespec = spacechar* [=] spacechar* attributevalue;
+
+  attribute = spacechar+ attributename attributevaluespec?;
+
+  opentag = tagname attribute* spacechar* [/]? [>];
+  closetag = [/] tagname spacechar* [>];
+
+  htmlcomment = "--" ([^\x00-]+ | "-" [^\x00-] | "--" [^\x00>])* "-->";
+
+  processinginstruction = ([^?>\x00]+ | [?][^>\x00] | [>])+;
+
+  declaration = [A-Z]+ [^>\x00]*;
+
+  cdata = "CDATA[" ([^\]\x00]+ | "]" [^\]\x00] | "]]" [^>\x00])*;
+
+  htmltag = opentag | closetag;
+
+  in_parens_nosp   = [(] (reg_char|escaped_char|[\\])* [)];
+
+  in_double_quotes = ["] (escaped_char|[^"\x00])* ["];
+  in_single_quotes = ['] (escaped_char|[^'\x00])* ['];
+  in_parens        = [(] (escaped_char|[^)\x00])* [)];
+
+  scheme           = [A-Za-z][A-Za-z0-9.+-]{1,31};
+*/
+
+// Try to match a scheme including colon.
+bufsize_t _scan_scheme(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+/*!re2c
+  scheme [:] { return (bufsize_t)(p - start); }
+  * { return 0; }
+*/
+}
+
+// Try to match URI autolink after first <, returning number of chars matched.
+bufsize_t _scan_autolink_uri(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+/*!re2c
+  scheme [:][^\x00-\x20<>]*[>]  { return (bufsize_t)(p - start); }
+  * { return 0; }
+*/
+}
+
+// Try to match email autolink after first <, returning num of chars matched.
+bufsize_t _scan_autolink_email(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+/*!re2c
+  [a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+
+    [@]
+    [a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?
+    ([.][a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*
+    [>] { return (bufsize_t)(p - start); }
+  * { return 0; }
+*/
+}
+
+// Try to match an HTML tag after first <, returning num of chars matched.
+bufsize_t _scan_html_tag(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+/*!re2c
+  htmltag { return (bufsize_t)(p - start); }
+  * { return 0; }
+*/
+}
+
+bufsize_t _scan_html_comment(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+/*!re2c
+  htmlcomment { return (bufsize_t)(p - start); }
+  * { return 0; }
+*/
+}
+
+bufsize_t _scan_html_pi(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+/*!re2c
+  processinginstruction { return (bufsize_t)(p - start); }
+  * { return 0; }
+*/
+}
+
+bufsize_t _scan_html_declaration(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+/*!re2c
+  declaration { return (bufsize_t)(p - start); }
+  * { return 0; }
+*/
+}
+
+bufsize_t _scan_html_cdata(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+/*!re2c
+  cdata { return (bufsize_t)(p - start); }
+  * { return 0; }
+*/
+}
+
+// Try to match an HTML block tag start line, returning
+// an integer code for the type of block (1-6, matching the spec).
+// #7 is handled by a separate function, below.
+bufsize_t _scan_html_block_start(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+/*!re2c
+  [<] ('script'|'pre'|'textarea'|'style') (spacechar | [>]) { return 1; }
+  '<!--' { return 2; }
+  '<?' { return 3; }
+  '<!' [A-Za-z] { return 4; }
+  '<![CDATA[' { return 5; }
+  [<] [/]? blocktagname (spacechar | [/]? [>])  { return 6; }
+  * { return 0; }
+*/
+}
+
+// Try to match an HTML block tag start line of type 7, returning
+// 7 if successful, 0 if not.
+bufsize_t _scan_html_block_start_7(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+/*!re2c
+  [<] (opentag | closetag) [\t\n\f ]* [\r\n] { return 7; }
+  * { return 0; }
+*/
+}
+
+// Try to match an HTML block end line of type 1
+bufsize_t _scan_html_block_end_1(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+/*!re2c
+  [^\n\x00]* [<] [/] ('script'|'pre'|'textarea'|'style') [>] { return (bufsize_t)(p - start); }
+  * { return 0; }
+*/
+}
+
+// Try to match an HTML block end line of type 2
+bufsize_t _scan_html_block_end_2(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+/*!re2c
+  [^\n\x00]* '-->' { return (bufsize_t)(p - start); }
+  * { return 0; }
+*/
+}
+
+// Try to match an HTML block end line of type 3
+bufsize_t _scan_html_block_end_3(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+/*!re2c
+  [^\n\x00]* '?>' { return (bufsize_t)(p - start); }
+  * { return 0; }
+*/
+}
+
+// Try to match an HTML block end line of type 4
+bufsize_t _scan_html_block_end_4(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+/*!re2c
+  [^\n\x00]* '>' { return (bufsize_t)(p - start); }
+  * { return 0; }
+*/
+}
+
+// Try to match an HTML block end line of type 5
+bufsize_t _scan_html_block_end_5(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+/*!re2c
+  [^\n\x00]* ']]>' { return (bufsize_t)(p - start); }
+  * { return 0; }
+*/
+}
+
+// Try to match a link title (in single quotes, in double quotes, or
+// in parentheses), returning number of chars matched.  Allow one
+// level of internal nesting (quotes within quotes).
+bufsize_t _scan_link_title(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+/*!re2c
+  ["] (escaped_char|[^"\x00])* ["]   { return (bufsize_t)(p - start); }
+  ['] (escaped_char|[^'\x00])* ['] { return (bufsize_t)(p - start); }
+  [(] (escaped_char|[^()\x00])* [)]  { return (bufsize_t)(p - start); }
+  * { return 0; }
+*/
+}
+
+// Match space characters, including newlines.
+bufsize_t _scan_spacechars(const unsigned char *p)
+{
+  const unsigned char *start = p; \
+/*!re2c
+  [ \t\v\f\r\n]+ { return (bufsize_t)(p - start); }
+  * { return 0; }
+*/
+}
+
+// Match ATX heading start.
+bufsize_t _scan_atx_heading_start(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+/*!re2c
+  [#]{1,6} ([ \t]+|[\r\n])  { return (bufsize_t)(p - start); }
+  * { return 0; }
+*/
+}
+
+// Match setext heading line.  Return 1 for level-1 heading,
+// 2 for level-2, 0 for no match.
+bufsize_t _scan_setext_heading_line(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+/*!re2c
+  [=]+ [ \t]* [\r\n] { return 1; }
+  [-]+ [ \t]* [\r\n] { return 2; }
+  * { return 0; }
+*/
+}
+
+// Scan an opening code fence.
+bufsize_t _scan_open_code_fence(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+/*!re2c
+  [`]{3,} / [^`\r\n\x00]*[\r\n] { return (bufsize_t)(p - start); }
+  [~]{3,} / [^\r\n\x00]*[\r\n] { return (bufsize_t)(p - start); }
+  * { return 0; }
+*/
+}
+
+// Scan a closing code fence with length at least len.
+bufsize_t _scan_close_code_fence(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+/*!re2c
+  [`]{3,} / [ \t]*[\r\n] { return (bufsize_t)(p - start); }
+  [~]{3,} / [ \t]*[\r\n] { return (bufsize_t)(p - start); }
+  * { return 0; }
+*/
+}
+
+// Scans an entity.
+// Returns number of chars matched.
+bufsize_t _scan_entity(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+/*!re2c
+  [&] ([#] ([Xx][A-Fa-f0-9]{1,6}|[0-9]{1,7}) |[A-Za-z][A-Za-z0-9]{1,31} ) [;]
+     { return (bufsize_t)(p - start); }
+  * { return 0; }
+*/
+}
+
+// Returns positive value if a URL begins in a way that is potentially
+// dangerous, with javascript:, vbscript:, file:, or data:, otherwise 0.
+bufsize_t _scan_dangerous_url(const unsigned char *p)
+{
+  const unsigned char *marker = NULL;
+  const unsigned char *start = p;
+/*!re2c
+  'data:image/' ('png'|'gif'|'jpeg'|'webp') { return 0; }
+  'javascript:' | 'vbscript:' | 'file:' | 'data:' { return (bufsize_t)(p - start); }
+  * { return 0; }
+*/
+}
+

deps/cmark/src/utf8.c

@@ -0,0 +1,317 @@
+#include <stdlib.h>
+#include <stdint.h>
+#include <assert.h>
+
+#include "cmark_ctype.h"
+#include "utf8.h"
+
+static const int8_t utf8proc_utf8class[256] = {
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+    2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+    4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0};
+
+static void encode_unknown(cmark_strbuf *buf) {
+  static const uint8_t repl[] = {239, 191, 189};
+  cmark_strbuf_put(buf, repl, 3);
+}
+
+static int utf8proc_charlen(const uint8_t *str, bufsize_t str_len) {
+  int length, i;
+
+  if (!str_len)
+    return 0;
+
+  length = utf8proc_utf8class[str[0]];
+
+  if (!length)
+    return -1;
+
+  if (str_len >= 0 && (bufsize_t)length > str_len)
+    return -str_len;
+
+  for (i = 1; i < length; i++) {
+    if ((str[i] & 0xC0) != 0x80)
+      return -i;
+  }
+
+  return length;
+}
+
+// Validate a single UTF-8 character according to RFC 3629.
+static int utf8proc_valid(const uint8_t *str, bufsize_t str_len) {
+  int length = utf8proc_utf8class[str[0]];
+
+  if (!length)
+    return -1;
+
+  if ((bufsize_t)length > str_len)
+    return -str_len;
+
+  switch (length) {
+  case 2:
+    if ((str[1] & 0xC0) != 0x80)
+      return -1;
+    if (str[0] < 0xC2) {
+      // Overlong
+      return -length;
+    }
+    break;
+
+  case 3:
+    if ((str[1] & 0xC0) != 0x80)
+      return -1;
+    if ((str[2] & 0xC0) != 0x80)
+      return -2;
+    if (str[0] == 0xE0) {
+      if (str[1] < 0xA0) {
+        // Overlong
+        return -length;
+      }
+    } else if (str[0] == 0xED) {
+      if (str[1] >= 0xA0) {
+        // Surrogate
+        return -length;
+      }
+    }
+    break;
+
+  case 4:
+    if ((str[1] & 0xC0) != 0x80)
+      return -1;
+    if ((str[2] & 0xC0) != 0x80)
+      return -2;
+    if ((str[3] & 0xC0) != 0x80)
+      return -3;
+    if (str[0] == 0xF0) {
+      if (str[1] < 0x90) {
+        // Overlong
+        return -length;
+      }
+    } else if (str[0] >= 0xF4) {
+      if (str[0] > 0xF4 || str[1] >= 0x90) {
+        // Above 0x10FFFF
+        return -length;
+      }
+    }
+    break;
+  }
+
+  return length;
+}
+
+void cmark_utf8proc_check(cmark_strbuf *ob, const uint8_t *line,
+                          bufsize_t size) {
+  bufsize_t i = 0;
+
+  while (i < size) {
+    bufsize_t org = i;
+    int charlen = 0;
+
+    while (i < size) {
+      if (line[i] < 0x80 && line[i] != 0) {
+        i++;
+      } else if (line[i] >= 0x80) {
+        charlen = utf8proc_valid(line + i, size - i);
+        if (charlen < 0) {
+          charlen = -charlen;
+          break;
+        }
+        i += charlen;
+      } else if (line[i] == 0) {
+        // ASCII NUL is technically valid but rejected
+        // for security reasons.
+        charlen = 1;
+        break;
+      }
+    }
+
+    if (i > org) {
+      cmark_strbuf_put(ob, line + org, i - org);
+    }
+
+    if (i >= size) {
+      break;
+    } else {
+      // Invalid UTF-8
+      encode_unknown(ob);
+      i += charlen;
+    }
+  }
+}
+
+int cmark_utf8proc_iterate(const uint8_t *str, bufsize_t str_len,
+                           int32_t *dst) {
+  int length;
+  int32_t uc = -1;
+
+  *dst = -1;
+  length = utf8proc_charlen(str, str_len);
+  if (length < 0)
+    return -1;
+
+  switch (length) {
+  case 1:
+    uc = str[0];
+    break;
+  case 2:
+    uc = ((str[0] & 0x1F) << 6) + (str[1] & 0x3F);
+    if (uc < 0x80)
+      uc = -1;
+    break;
+  case 3:
+    uc = ((str[0] & 0x0F) << 12) + ((str[1] & 0x3F) << 6) + (str[2] & 0x3F);
+    if (uc < 0x800 || (uc >= 0xD800 && uc < 0xE000))
+      uc = -1;
+    break;
+  case 4:
+    uc = ((str[0] & 0x07) << 18) + ((str[1] & 0x3F) << 12) +
+         ((str[2] & 0x3F) << 6) + (str[3] & 0x3F);
+    if (uc < 0x10000 || uc >= 0x110000)
+      uc = -1;
+    break;
+  }
+
+  if (uc < 0)
+    return -1;
+
+  *dst = uc;
+  return length;
+}
+
+void cmark_utf8proc_encode_char(int32_t uc, cmark_strbuf *buf) {
+  uint8_t dst[4];
+  bufsize_t len = 0;
+
+  assert(uc >= 0);
+
+  if (uc < 0x80) {
+    dst[0] = (uint8_t)(uc);
+    len = 1;
+  } else if (uc < 0x800) {
+    dst[0] = (uint8_t)(0xC0 + (uc >> 6));
+    dst[1] = 0x80 + (uc & 0x3F);
+    len = 2;
+  } else if (uc == 0xFFFF) {
+    dst[0] = 0xFF;
+    len = 1;
+  } else if (uc == 0xFFFE) {
+    dst[0] = 0xFE;
+    len = 1;
+  } else if (uc < 0x10000) {
+    dst[0] = (uint8_t)(0xE0 + (uc >> 12));
+    dst[1] = 0x80 + ((uc >> 6) & 0x3F);
+    dst[2] = 0x80 + (uc & 0x3F);
+    len = 3;
+  } else if (uc < 0x110000) {
+    dst[0] = (uint8_t)(0xF0 + (uc >> 18));
+    dst[1] = 0x80 + ((uc >> 12) & 0x3F);
+    dst[2] = 0x80 + ((uc >> 6) & 0x3F);
+    dst[3] = 0x80 + (uc & 0x3F);
+    len = 4;
+  } else {
+    encode_unknown(buf);
+    return;
+  }
+
+  cmark_strbuf_put(buf, dst, len);
+}
+
+void cmark_utf8proc_case_fold(cmark_strbuf *dest, const uint8_t *str,
+                              bufsize_t len) {
+  int32_t c;
+
+#define bufpush(x) cmark_utf8proc_encode_char(x, dest)
+
+  while (len > 0) {
+    bufsize_t char_len = cmark_utf8proc_iterate(str, len, &c);
+
+    if (char_len >= 0) {
+#include "case_fold_switch.inc"
+    } else {
+      encode_unknown(dest);
+      char_len = -char_len;
+    }
+
+    str += char_len;
+    len -= char_len;
+  }
+}
+
+// matches anything in the Zs class, plus LF, CR, TAB, FF.
+int cmark_utf8proc_is_space(int32_t uc) {
+  return (uc == 9 || uc == 10 || uc == 12 || uc == 13 || uc == 32 ||
+          uc == 160 || uc == 5760 || (uc >= 8192 && uc <= 8202) || uc == 8239 ||
+          uc == 8287 || uc == 12288);
+}
+
+// matches anything in the P[cdefios] classes.
+int cmark_utf8proc_is_punctuation(int32_t uc) {
+  return (
+      (uc < 128 && cmark_ispunct((char)uc)) || uc == 161 || uc == 167 ||
+      uc == 171 || uc == 182 || uc == 183 || uc == 187 || uc == 191 ||
+      uc == 894 || uc == 903 || (uc >= 1370 && uc <= 1375) || uc == 1417 ||
+      uc == 1418 || uc == 1470 || uc == 1472 || uc == 1475 || uc == 1478 ||
+      uc == 1523 || uc == 1524 || uc == 1545 || uc == 1546 || uc == 1548 ||
+      uc == 1549 || uc == 1563 || uc == 1566 || uc == 1567 ||
+      (uc >= 1642 && uc <= 1645) || uc == 1748 || (uc >= 1792 && uc <= 1805) ||
+      (uc >= 2039 && uc <= 2041) || (uc >= 2096 && uc <= 2110) || uc == 2142 ||
+      uc == 2404 || uc == 2405 || uc == 2416 || uc == 2800 || uc == 3572 ||
+      uc == 3663 || uc == 3674 || uc == 3675 || (uc >= 3844 && uc <= 3858) ||
+      uc == 3860 || (uc >= 3898 && uc <= 3901) || uc == 3973 ||
+      (uc >= 4048 && uc <= 4052) || uc == 4057 || uc == 4058 ||
+      (uc >= 4170 && uc <= 4175) || uc == 4347 || (uc >= 4960 && uc <= 4968) ||
+      uc == 5120 || uc == 5741 || uc == 5742 || uc == 5787 || uc == 5788 ||
+      (uc >= 5867 && uc <= 5869) || uc == 5941 || uc == 5942 ||
+      (uc >= 6100 && uc <= 6102) || (uc >= 6104 && uc <= 6106) ||
+      (uc >= 6144 && uc <= 6154) || uc == 6468 || uc == 6469 || uc == 6686 ||
+      uc == 6687 || (uc >= 6816 && uc <= 6822) || (uc >= 6824 && uc <= 6829) ||
+      (uc >= 7002 && uc <= 7008) || (uc >= 7164 && uc <= 7167) ||
+      (uc >= 7227 && uc <= 7231) || uc == 7294 || uc == 7295 ||
+      (uc >= 7360 && uc <= 7367) || uc == 7379 || (uc >= 8208 && uc <= 8231) ||
+      (uc >= 8240 && uc <= 8259) || (uc >= 8261 && uc <= 8273) ||
+      (uc >= 8275 && uc <= 8286) || uc == 8317 || uc == 8318 || uc == 8333 ||
+      uc == 8334 || (uc >= 8968 && uc <= 8971) || uc == 9001 || uc == 9002 ||
+      (uc >= 10088 && uc <= 10101) || uc == 10181 || uc == 10182 ||
+      (uc >= 10214 && uc <= 10223) || (uc >= 10627 && uc <= 10648) ||
+      (uc >= 10712 && uc <= 10715) || uc == 10748 || uc == 10749 ||
+      (uc >= 11513 && uc <= 11516) || uc == 11518 || uc == 11519 ||
+      uc == 11632 || (uc >= 11776 && uc <= 11822) ||
+      (uc >= 11824 && uc <= 11842) || (uc >= 12289 && uc <= 12291) ||
+      (uc >= 12296 && uc <= 12305) || (uc >= 12308 && uc <= 12319) ||
+      uc == 12336 || uc == 12349 || uc == 12448 || uc == 12539 || uc == 42238 ||
+      uc == 42239 || (uc >= 42509 && uc <= 42511) || uc == 42611 ||
+      uc == 42622 || (uc >= 42738 && uc <= 42743) ||
+      (uc >= 43124 && uc <= 43127) || uc == 43214 || uc == 43215 ||
+      (uc >= 43256 && uc <= 43258) || uc == 43310 || uc == 43311 ||
+      uc == 43359 || (uc >= 43457 && uc <= 43469) || uc == 43486 ||
+      uc == 43487 || (uc >= 43612 && uc <= 43615) || uc == 43742 ||
+      uc == 43743 || uc == 43760 || uc == 43761 || uc == 44011 || uc == 64830 ||
+      uc == 64831 || (uc >= 65040 && uc <= 65049) ||
+      (uc >= 65072 && uc <= 65106) || (uc >= 65108 && uc <= 65121) ||
+      uc == 65123 || uc == 65128 || uc == 65130 || uc == 65131 ||
+      (uc >= 65281 && uc <= 65283) || (uc >= 65285 && uc <= 65290) ||
+      (uc >= 65292 && uc <= 65295) || uc == 65306 || uc == 65307 ||
+      uc == 65311 || uc == 65312 || (uc >= 65339 && uc <= 65341) ||
+      uc == 65343 || uc == 65371 || uc == 65373 ||
+      (uc >= 65375 && uc <= 65381) || (uc >= 65792 && uc <= 65794) ||
+      uc == 66463 || uc == 66512 || uc == 66927 || uc == 67671 || uc == 67871 ||
+      uc == 67903 || (uc >= 68176 && uc <= 68184) || uc == 68223 ||
+      (uc >= 68336 && uc <= 68342) || (uc >= 68409 && uc <= 68415) ||
+      (uc >= 68505 && uc <= 68508) || (uc >= 69703 && uc <= 69709) ||
+      uc == 69819 || uc == 69820 || (uc >= 69822 && uc <= 69825) ||
+      (uc >= 69952 && uc <= 69955) || uc == 70004 || uc == 70005 ||
+      (uc >= 70085 && uc <= 70088) || uc == 70093 ||
+      (uc >= 70200 && uc <= 70205) || uc == 70854 ||
+      (uc >= 71105 && uc <= 71113) || (uc >= 71233 && uc <= 71235) ||
+      (uc >= 74864 && uc <= 74868) || uc == 92782 || uc == 92783 ||
+      uc == 92917 || (uc >= 92983 && uc <= 92987) || uc == 92996 ||
+      uc == 113823);
+}

deps/cmark/src/utf8.h

@@ -0,0 +1,24 @@
+#ifndef CMARK_UTF8_H
+#define CMARK_UTF8_H
+
+#include <stdint.h>
+#include "buffer.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void cmark_utf8proc_case_fold(cmark_strbuf *dest, const uint8_t *str,
+                              bufsize_t len);
+void cmark_utf8proc_encode_char(int32_t uc, cmark_strbuf *buf);
+int cmark_utf8proc_iterate(const uint8_t *str, bufsize_t str_len, int32_t *dst);
+void cmark_utf8proc_check(cmark_strbuf *dest, const uint8_t *line,
+                          bufsize_t size);
+int cmark_utf8proc_is_space(int32_t uc);
+int cmark_utf8proc_is_punctuation(int32_t uc);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

deps/cmark/src/xml.c

@@ -0,0 +1,229 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+
+#include "config.h"
+#include "cmark.h"
+#include "node.h"
+#include "buffer.h"
+
+#define BUFFER_SIZE 100
+#define MAX_INDENT 40
+
+// Functions to convert cmark_nodes to XML strings.
+
+// C0 control characters, U+FFFE and U+FFF aren't allowed in XML.
+static const char XML_ESCAPE_TABLE[256] = {
+    /* 0x00 */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1,
+    /* 0x10 */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    /* 0x20 */ 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* 0x30 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 5, 0,
+    /* 0x40 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* 0x50 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* 0x60 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* 0x70 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* 0x80 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* 0x90 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* 0xA0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* 0xB0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 9,
+    /* 0xC0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* 0xD0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* 0xE0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    /* 0xF0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+};
+
+// U+FFFD Replacement Character encoded in UTF-8
+#define UTF8_REPL "\xEF\xBF\xBD"
+
+static const char *XML_ESCAPES[] = {
+  "", UTF8_REPL, "&quot;", "&amp;", "&lt;", "&gt;"
+};
+
+static void escape_xml(cmark_strbuf *ob, const unsigned char *src,
+                       bufsize_t size) {
+  bufsize_t i = 0, org, esc = 0;
+
+  while (i < size) {
+    org = i;
+    while (i < size && (esc = XML_ESCAPE_TABLE[src[i]]) == 0)
+      i++;
+
+    if (i > org)
+      cmark_strbuf_put(ob, src + org, i - org);
+
+    if (i >= size)
+      break;
+
+    if (esc == 9) {
+      // To replace U+FFFE and U+FFFF with U+FFFD, only the last byte has to
+      // be changed.
+      // We know that src[i] is 0xBE or 0xBF.
+      if (i >= 2 && src[i-2] == 0xEF && src[i-1] == 0xBF) {
+        cmark_strbuf_putc(ob, 0xBD);
+      } else {
+        cmark_strbuf_putc(ob, src[i]);
+      }
+    } else {
+      cmark_strbuf_puts(ob, XML_ESCAPES[esc]);
+    }
+
+    i++;
+  }
+}
+
+static void escape_xml_str(cmark_strbuf *dest, const unsigned char *source) {
+  if (source)
+    escape_xml(dest, source, strlen((char *)source));
+}
+
+struct render_state {
+  cmark_strbuf *xml;
+  int indent;
+};
+
+static CMARK_INLINE void indent(struct render_state *state) {
+  int i;
+  for (i = 0; i < state->indent && i < MAX_INDENT; i++) {
+    cmark_strbuf_putc(state->xml, ' ');
+  }
+}
+
+static int S_render_node(cmark_node *node, cmark_event_type ev_type,
+                         struct render_state *state, int options) {
+  cmark_strbuf *xml = state->xml;
+  bool literal = false;
+  cmark_delim_type delim;
+  bool entering = (ev_type == CMARK_EVENT_ENTER);
+  char buffer[BUFFER_SIZE];
+
+  if (entering) {
+    indent(state);
+    cmark_strbuf_putc(xml, '<');
+    cmark_strbuf_puts(xml, cmark_node_get_type_string(node));
+
+    if (options & CMARK_OPT_SOURCEPOS && node->start_line != 0) {
+      snprintf(buffer, BUFFER_SIZE, " sourcepos=\"%d:%d-%d:%d\"",
+               node->start_line, node->start_column, node->end_line,
+               node->end_column);
+      cmark_strbuf_puts(xml, buffer);
+    }
+
+    literal = false;
+
+    switch (node->type) {
+    case CMARK_NODE_DOCUMENT:
+      cmark_strbuf_puts(xml, " xmlns=\"http://commonmark.org/xml/1.0\"");
+      break;
+    case CMARK_NODE_TEXT:
+    case CMARK_NODE_CODE:
+    case CMARK_NODE_HTML_BLOCK:
+    case CMARK_NODE_HTML_INLINE:
+      cmark_strbuf_puts(xml, " xml:space=\"preserve\">");
+      escape_xml(xml, node->data, node->len);
+      cmark_strbuf_puts(xml, "</");
+      cmark_strbuf_puts(xml, cmark_node_get_type_string(node));
+      literal = true;
+      break;
+    case CMARK_NODE_LIST:
+      switch (cmark_node_get_list_type(node)) {
+      case CMARK_ORDERED_LIST:
+        cmark_strbuf_puts(xml, " type=\"ordered\"");
+        snprintf(buffer, BUFFER_SIZE, " start=\"%d\"",
+                 cmark_node_get_list_start(node));
+        cmark_strbuf_puts(xml, buffer);
+        delim = cmark_node_get_list_delim(node);
+        if (delim == CMARK_PAREN_DELIM) {
+          cmark_strbuf_puts(xml, " delim=\"paren\"");
+        } else if (delim == CMARK_PERIOD_DELIM) {
+          cmark_strbuf_puts(xml, " delim=\"period\"");
+        }
+        break;
+      case CMARK_BULLET_LIST:
+        cmark_strbuf_puts(xml, " type=\"bullet\"");
+        break;
+      default:
+        break;
+      }
+      snprintf(buffer, BUFFER_SIZE, " tight=\"%s\"",
+               (cmark_node_get_list_tight(node) ? "true" : "false"));
+      cmark_strbuf_puts(xml, buffer);
+      break;
+    case CMARK_NODE_HEADING:
+      snprintf(buffer, BUFFER_SIZE, " level=\"%d\"", node->as.heading.level);
+      cmark_strbuf_puts(xml, buffer);
+      break;
+    case CMARK_NODE_CODE_BLOCK:
+      if (node->as.code.info) {
+        cmark_strbuf_puts(xml, " info=\"");
+        escape_xml_str(xml, node->as.code.info);
+        cmark_strbuf_putc(xml, '"');
+      }
+      cmark_strbuf_puts(xml, " xml:space=\"preserve\">");
+      escape_xml(xml, node->data, node->len);
+      cmark_strbuf_puts(xml, "</");
+      cmark_strbuf_puts(xml, cmark_node_get_type_string(node));
+      literal = true;
+      break;
+    case CMARK_NODE_CUSTOM_BLOCK:
+    case CMARK_NODE_CUSTOM_INLINE:
+      cmark_strbuf_puts(xml, " on_enter=\"");
+      escape_xml_str(xml, node->as.custom.on_enter);
+      cmark_strbuf_putc(xml, '"');
+      cmark_strbuf_puts(xml, " on_exit=\"");
+      escape_xml_str(xml, node->as.custom.on_exit);
+      cmark_strbuf_putc(xml, '"');
+      break;
+    case CMARK_NODE_LINK:
+    case CMARK_NODE_IMAGE:
+      cmark_strbuf_puts(xml, " destination=\"");
+      escape_xml_str(xml, node->as.link.url);
+      cmark_strbuf_putc(xml, '"');
+      if (node->as.link.title) {
+        cmark_strbuf_puts(xml, " title=\"");
+        escape_xml_str(xml, node->as.link.title);
+        cmark_strbuf_putc(xml, '"');
+      }
+      break;
+    default:
+      break;
+    }
+    if (node->first_child) {
+      state->indent += 2;
+    } else if (!literal) {
+      cmark_strbuf_puts(xml, " /");
+    }
+    cmark_strbuf_puts(xml, ">\n");
+
+  } else if (node->first_child) {
+    state->indent -= 2;
+    indent(state);
+    cmark_strbuf_puts(xml, "</");
+    cmark_strbuf_puts(xml, cmark_node_get_type_string(node));
+    cmark_strbuf_puts(xml, ">\n");
+  }
+
+  return 1;
+}
+
+char *cmark_render_xml(cmark_node *root, int options) {
+  char *result;
+  cmark_strbuf xml = CMARK_BUF_INIT(root->mem);
+  cmark_event_type ev_type;
+  cmark_node *cur;
+  struct render_state state = {&xml, 0};
+
+  cmark_iter *iter = cmark_iter_new(root);
+
+  cmark_strbuf_puts(state.xml, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
+  cmark_strbuf_puts(state.xml,
+                    "<!DOCTYPE document SYSTEM \"CommonMark.dtd\">\n");
+  while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) {
+    cur = cmark_iter_get_node(iter);
+    S_render_node(cur, ev_type, &state, options);
+  }
+  result = (char *)cmark_strbuf_detach(&xml);
+
+  cmark_iter_free(iter);
+  return result;
+}