commonmarker 0.9.2 → 0.10.0

data/ext/commonmarker/cmark/src/CMakeLists.txt

@@ -126,6 +126,7 @@ endif(MSVC)
 set(CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_NO_WARNINGS ON)
 include (InstallRequiredSystemLibraries)
 install(TARGETS ${PROGRAM} ${LIBRARY} ${STATICLIBRARY}
+  EXPORT cmark
   RUNTIME DESTINATION bin
   LIBRARY DESTINATION ${LIB_INSTALL_DIR}
   ARCHIVE DESTINATION ${LIB_INSTALL_DIR}
@@ -138,6 +139,8 @@ install(FILES
   DESTINATION include
   )
 
+install(EXPORT cmark DESTINATION ${LIB_INSTALL_DIR}/cmake)
+
 # Feature tests
 include(CheckIncludeFile)
 include(CheckCSourceCompiles)

data/ext/commonmarker/cmark/src/blocks.c

@@ -59,8 +59,8 @@ static void S_parser_feed(cmark_parser *parser, const unsigned char *buffer,
 static void S_process_line(cmark_parser *parser, const unsigned char *buffer,
                            bufsize_t bytes);
 
-static cmark_node *make_block(cmark_mem *mem, cmark_node_type tag, int start_line,
-                              int start_column) {
+static cmark_node *make_block(cmark_mem *mem, cmark_node_type tag,
+                              int start_line, int start_column) {
   cmark_node *e;
 
   e = (cmark_node *)mem->calloc(1, sizeof(*e));
@@ -222,24 +222,6 @@ static bool ends_with_blank_line(cmark_node *node) {
   return false;
 }
 
-// Break out of all containing lists
-static int break_out_of_lists(cmark_parser *parser, cmark_node **bptr) {
-  cmark_node *container = *bptr;
-  cmark_node *b = parser->root;
-  // find first containing NODE_LIST:
-  while (b && S_type(b) != CMARK_NODE_LIST) {
-    b = b->last_child;
-  }
-  if (b) {
-    while (container && container != b) {
-      container = finalize(parser, container);
-    }
-    finalize(parser, b);
-    *bptr = b->parent;
-  }
-  return 0;
-}
-
 static cmark_node *finalize(cmark_parser *parser, cmark_node *b) {
   bufsize_t pos;
   cmark_node *item;
@@ -247,7 +229,8 @@ static cmark_node *finalize(cmark_parser *parser, cmark_node *b) {
   cmark_node *parent;
 
   parent = b->parent;
-  assert(b->flags & CMARK_NODE__OPEN); // shouldn't call finalize on closed blocks
+  assert(b->flags &
+         CMARK_NODE__OPEN); // shouldn't call finalize on closed blocks
   b->flags &= ~CMARK_NODE__OPEN;
 
   if (parser->curline.size == 0) {
@@ -361,7 +344,8 @@ static cmark_node *add_child(cmark_parser *parser, cmark_node *parent,
     parent = finalize(parser, parent);
   }
 
-  cmark_node *child = make_block(parser->mem, block_type, parser->line_number, start_column);
+  cmark_node *child =
+      make_block(parser->mem, block_type, parser->line_number, start_column);
   child->parent = parent;
 
   if (parent->last_child) {
@@ -377,8 +361,8 @@ static cmark_node *add_child(cmark_parser *parser, cmark_node *parent,
 
 // Walk through node and all children, recursively, parsing
 // string content into inline content where appropriate.
-static void process_inlines(cmark_mem *mem, cmark_node *root, cmark_reference_map *refmap,
-                            int options) {
+static void process_inlines(cmark_mem *mem, cmark_node *root,
+                            cmark_reference_map *refmap, int options) {
   cmark_iter *iter = cmark_iter_new(root);
   cmark_node *cur;
   cmark_event_type ev_type;
@@ -398,11 +382,13 @@ static void process_inlines(cmark_mem *mem, cmark_node *root, cmark_reference_ma
 // Attempts to parse a list item marker (bullet or enumerated).
 // On success, returns length of the marker, and populates
 // data with the details.  On failure, returns 0.
-static bufsize_t parse_list_marker(cmark_mem *mem, cmark_chunk *input, bufsize_t pos,
+static bufsize_t parse_list_marker(cmark_mem *mem, cmark_chunk *input,
+                                   bufsize_t pos, bool interrupts_paragraph,
                                    cmark_list **dataptr) {
   unsigned char c;
   bufsize_t startpos;
   cmark_list *data;
+  bufsize_t i;
 
   startpos = pos;
   c = peek_at(input, pos);
@@ -412,6 +398,18 @@ static bufsize_t parse_list_marker(cmark_mem *mem, cmark_chunk *input, bufsize_t
     if (!cmark_isspace(peek_at(input, pos))) {
       return 0;
     }
+
+    if (interrupts_paragraph) {
+      i = pos;
+      // require non-blank content after list marker:
+      while (S_is_space_or_tab(peek_at(input, i))) {
+        i++;
+      }
+      if (peek_at(input, i) == '\n') {
+        return 0;
+      }
+    }
+
     data = (cmark_list *)mem->calloc(1, sizeof(*data));
     data->marker_offset = 0; // will be adjusted later
     data->list_type = CMARK_BULLET_LIST;
@@ -432,12 +430,26 @@ static bufsize_t parse_list_marker(cmark_mem *mem, cmark_chunk *input, bufsize_t
       // This also seems to be the limit for 'start' in some browsers.
     } while (digits < 9 && cmark_isdigit(peek_at(input, pos)));
 
+    if (interrupts_paragraph && start != 1) {
+      return 0;
+    }
     c = peek_at(input, pos);
     if (c == '.' || c == ')') {
       pos++;
       if (!cmark_isspace(peek_at(input, pos))) {
         return 0;
       }
+      if (interrupts_paragraph) {
+        // require non-blank content after list marker:
+        i = pos;
+        while (S_is_space_or_tab(peek_at(input, i))) {
+          i++;
+        }
+        if (S_is_line_end_char(peek_at(input, i))) {
+          return 0;
+        }
+      }
+
       data = (cmark_list *)mem->calloc(1, sizeof(*data));
       data->marker_offset = 0; // will be adjusted later
       data->list_type = CMARK_ORDERED_LIST;
@@ -655,7 +667,8 @@ static void S_advance_offset(cmark_parser *parser, cmark_chunk *input,
 }
 
 static bool S_last_child_is_open(cmark_node *container) {
-  return container->last_child && (container->last_child->flags & CMARK_NODE__OPEN);
+  return container->last_child &&
+         (container->last_child->flags & CMARK_NODE__OPEN);
 }
 
 static bool parse_block_quote_prefix(cmark_parser *parser, cmark_chunk *input) {
@@ -849,6 +862,8 @@ static void open_new_blocks(cmark_parser *parser, cmark_node **container,
 
     if (!indented && peek_at(input, parser->first_nonspace) == '>') {
 
+      bufsize_t blockquote_startpos = parser->first_nonspace;
+
       S_advance_offset(parser, input,
                        parser->first_nonspace + 1 - parser->offset, false);
       // optional following character
@@ -856,18 +871,19 @@ static void open_new_blocks(cmark_parser *parser, cmark_node **container,
         S_advance_offset(parser, input, 1, true);
       }
       *container = add_child(parser, *container, CMARK_NODE_BLOCK_QUOTE,
-                             parser->offset + 1);
+                             blockquote_startpos + 1);
 
     } else if (!indented && (matched = scan_atx_heading_start(
                                  input, parser->first_nonspace))) {
       bufsize_t hashpos;
       int level = 0;
+      bufsize_t heading_startpos = parser->first_nonspace;
 
       S_advance_offset(parser, input,
                        parser->first_nonspace + matched - parser->offset,
                        false);
-      *container =
-          add_child(parser, *container, CMARK_NODE_HEADING, parser->offset + 1);
+      *container = add_child(parser, *container, CMARK_NODE_HEADING,
+                             heading_startpos + 1);
 
       hashpos = cmark_chunk_strchr(input, '#', parser->first_nonspace);
 
@@ -917,9 +933,11 @@ static void open_new_blocks(cmark_parser *parser, cmark_node **container,
       *container = add_child(parser, *container, CMARK_NODE_THEMATIC_BREAK,
                              parser->first_nonspace + 1);
       S_advance_offset(parser, input, input->len - 1 - parser->offset, false);
-    } else if ((matched =
-                    parse_list_marker(parser->mem, input, parser->first_nonspace, &data)) &&
+    } else if ((matched = parse_list_marker(
+                    parser->mem, input, parser->first_nonspace,
+                    (*container)->type == CMARK_NODE_PARAGRAPH, &data)) &&
                (!indented || cont_type == CMARK_NODE_LIST)) {
+
       // Note that we can have new list items starting with >= 4
       // spaces indent, as long as the list container is still open.
       int i = 0;
@@ -1015,8 +1033,7 @@ static void add_text_to_container(cmark_parser *parser, cmark_node *container,
   const cmark_node_type ctype = S_type(container);
   const bool last_line_blank =
       (parser->blank && ctype != CMARK_NODE_BLOCK_QUOTE &&
-       ctype != CMARK_NODE_HEADING &&
-       ctype != CMARK_NODE_THEMATIC_BREAK &&
+       ctype != CMARK_NODE_HEADING && ctype != CMARK_NODE_THEMATIC_BREAK &&
        !(ctype == CMARK_NODE_CODE_BLOCK && container->as.code.fenced) &&
        !(ctype == CMARK_NODE_ITEM && container->first_child == NULL &&
          container->start_line == parser->line_number));
@@ -1144,10 +1161,6 @@ static void S_process_line(cmark_parser *parser, const unsigned char *buffer,
 
   container = last_matched_container;
 
-  // check to see if we've hit 2nd blank line, break out of list:
-  if (parser->blank && S_last_line_blank(container))
-    break_out_of_lists(parser, &container);
-
   open_new_blocks(parser, &container, &input, all_matched);
 
   add_text_to_container(parser, container, last_matched_container, &input);

data/ext/commonmarker/cmark/src/buffer.c

@@ -21,7 +21,8 @@ unsigned char cmark_strbuf__initbuf[1];
 #define MIN(x, y) ((x < y) ? x : y)
 #endif
 
-void cmark_strbuf_init(cmark_mem *mem, cmark_strbuf *buf, bufsize_t initial_size) {
+void cmark_strbuf_init(cmark_mem *mem, cmark_strbuf *buf,
+                       bufsize_t initial_size) {
   buf->mem = mem;
   buf->asize = 0;
   buf->size = 0;
@@ -50,8 +51,8 @@ void cmark_strbuf_grow(cmark_strbuf *buf, bufsize_t target_size) {
   new_size += 1;
   new_size = (new_size + 7) & ~7;
 
-  buf->ptr = (unsigned char *)buf->mem->realloc(
-		buf->asize ? buf->ptr : NULL, new_size);
+  buf->ptr = (unsigned char *)buf->mem->realloc(buf->asize ? buf->ptr : NULL,
+                                                new_size);
   buf->asize = new_size;
 }
 
@@ -112,8 +113,7 @@ void cmark_strbuf_put(cmark_strbuf *buf, const unsigned char *data,
 }
 
 void cmark_strbuf_puts(cmark_strbuf *buf, const char *string) {
-  cmark_strbuf_put(buf, (const unsigned char *)string,
-                   strlen(string));
+  cmark_strbuf_put(buf, (const unsigned char *)string, strlen(string));
 }
 
 void cmark_strbuf_copy_cstr(char *data, bufsize_t datasize,

data/ext/commonmarker/cmark/src/buffer.h

@@ -23,7 +23,8 @@ typedef struct {
 
 extern unsigned char cmark_strbuf__initbuf[];
 
-#define CMARK_BUF_INIT(mem) {mem, cmark_strbuf__initbuf, 0, 0}
+#define CMARK_BUF_INIT(mem)                                                    \
+  { mem, cmark_strbuf__initbuf, 0, 0 }
 
 /**
  * Initialize a cmark_strbuf structure.
@@ -31,7 +32,8 @@ extern unsigned char cmark_strbuf__initbuf[];
  * 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);
+void cmark_strbuf_init(cmark_mem *mem, cmark_strbuf *buf,
+                       bufsize_t initial_size);
 
 /**
  * Grow the buffer to hold at least `target_size` bytes.

data/ext/commonmarker/cmark/src/chunk.h

@@ -57,7 +57,8 @@ static CMARK_INLINE bufsize_t
   return p ? (bufsize_t)(p - ch->data) : ch->len;
 }
 
-static CMARK_INLINE const char *cmark_chunk_to_cstr(cmark_mem *mem, cmark_chunk *c) {
+static CMARK_INLINE const char *cmark_chunk_to_cstr(cmark_mem *mem,
+                                                    cmark_chunk *c) {
   unsigned char *str;
 
   if (c->alloc) {
@@ -74,10 +75,9 @@ static CMARK_INLINE const char *cmark_chunk_to_cstr(cmark_mem *mem, cmark_chunk
   return (char *)str;
 }
 
-static CMARK_INLINE void cmark_chunk_set_cstr(cmark_mem *mem, cmark_chunk *c, const char *str) {
-  if (c->alloc) {
-    mem->free(c->data);
-  }
+static CMARK_INLINE void cmark_chunk_set_cstr(cmark_mem *mem, cmark_chunk *c,
+                                              const char *str) {
+  unsigned char *old = c->alloc ? c->data : NULL;
   if (str == NULL) {
     c->len = 0;
     c->data = NULL;
@@ -88,6 +88,9 @@ static CMARK_INLINE void cmark_chunk_set_cstr(cmark_mem *mem, cmark_chunk *c, co
     c->alloc = 1;
     memcpy(c->data, str, c->len + 1);
   }
+  if (old != NULL) {
+    mem->free(old);
+  }
 }
 
 static CMARK_INLINE cmark_chunk cmark_chunk_literal(const char *data) {

data/ext/commonmarker/cmark/src/cmark.c

@@ -12,17 +12,19 @@ const char *cmark_version_string() { return CMARK_VERSION_STRING; }
 
 static void *xcalloc(size_t nmem, size_t size) {
   void *ptr = calloc(nmem, size);
-  if (!ptr) abort();
+  if (!ptr)
+    abort();
   return ptr;
 }
 
 static void *xrealloc(void *ptr, size_t size) {
   void *new_ptr = realloc(ptr, size);
-  if (!new_ptr) abort();
+  if (!new_ptr)
+    abort();
   return new_ptr;
 }
 
-cmark_mem DEFAULT_MEM_ALLOCATOR = { xcalloc, xrealloc, free };
+cmark_mem DEFAULT_MEM_ALLOCATOR = {xcalloc, xrealloc, free};
 
 char *cmark_markdown_to_html(const char *text, size_t len, int options) {
   cmark_node *doc;

data/ext/commonmarker/cmark/src/cmark.h

@@ -95,12 +95,11 @@ typedef struct cmark_iter cmark_iter;
  * 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 *);
+  void *(*calloc)(size_t, size_t);
+  void *(*realloc)(void *, size_t);
+  void (*free)(void *);
 } cmark_mem;
 
-
 /**
  * ## Creating and Destroying Nodes
  */
@@ -112,9 +111,11 @@ typedef struct cmark_mem {
 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
+ * 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);
+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.
  */

data/ext/commonmarker/cmark/src/commonmark.c

@@ -29,8 +29,7 @@ static CMARK_INLINE void outc(cmark_renderer *renderer, cmark_escaping escape,
   char encoded[ENCODED_SIZE];
 
   needs_escaping =
-      c < 0x80 &&
-      escape != LITERAL &&
+      c < 0x80 && escape != LITERAL &&
       ((escape == NORMAL &&
         (c == '*' || c == '_' || c == '[' || c == ']' || c == '#' || c == '<' ||
          c == '>' || c == '\\' || c == '`' || c == '!' ||
@@ -41,9 +40,9 @@ static CMARK_INLINE void outc(cmark_renderer *renderer, cmark_escaping escape,
           !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 == URL &&
+        (c == '`' || c == '<' || c == '>' || cmark_isspace(c) || c == '\\' ||
+         c == ')' || c == '(')) ||
        (escape == TITLE &&
         (c == '`' || c == '<' || c == '>' || c == '"' || c == '\\')));
 
@@ -268,7 +267,7 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node,
 
   case CMARK_NODE_CODE_BLOCK:
     first_in_list_item = node->prev == NULL && node->parent &&
-          node->parent->type == CMARK_NODE_ITEM;
+                         node->parent->type == CMARK_NODE_ITEM;
 
     if (!first_in_list_item) {
       BLANKLINE();
@@ -348,10 +347,9 @@ static int S_render_node(cmark_renderer *renderer, cmark_node *node,
     if (CMARK_OPT_HARDBREAKS & options) {
       LIT("  ");
       CR();
-    } else if (!renderer->no_linebreaks &&
-		renderer->width == 0 &&
-		!(CMARK_OPT_HARDBREAKS & options) &&
-                !(CMARK_OPT_NOBREAKS & options)) {
+    } else if (!renderer->no_linebreaks && renderer->width == 0 &&
+               !(CMARK_OPT_HARDBREAKS & options) &&
+               !(CMARK_OPT_NOBREAKS & options)) {
       CR();
     } else {
       OUT(" ", allow_wrap, LITERAL);

data/ext/commonmarker/cmark/src/config.h.in

@@ -69,14 +69,6 @@ CMARK_INLINE int c99_snprintf(char *outBuf, size_t size, const char *format, ...
 
 #endif
 
-#ifdef _WIN32
-# include <BaseTsd.h>
-  typedef SSIZE_T ssize_t;
-  typedef SIZE_T size_t;
-#else
-# include <sys/types.h>
-#endif
-
 #ifdef __cplusplus
 }
 #endif

data/ext/commonmarker/cmark/src/inlines.c

@@ -34,19 +34,28 @@ typedef struct delimiter {
   struct delimiter *previous;
   struct delimiter *next;
   cmark_node *inl_text;
-  bufsize_t position;
   unsigned char delim_char;
   bool can_open;
   bool can_close;
-  bool active;
 } delimiter;
 
+typedef struct bracket {
+  struct bracket *previous;
+  struct delimiter *previous_delimiter;
+  cmark_node *inl_text;
+  bufsize_t position;
+  bool image;
+  bool active;
+  bool bracket_after;
+} bracket;
+
 typedef struct {
   cmark_mem *mem;
   cmark_chunk input;
   bufsize_t pos;
   cmark_reference_map *refmap;
   delimiter *last_delim;
+  bracket *last_bracket;
 } subject;
 
 static CMARK_INLINE bool S_is_line_end_char(char c) {
@@ -63,7 +72,8 @@ static void subject_from_buf(cmark_mem *mem, subject *e, cmark_strbuf *buffer,
 static bufsize_t subject_find_special_char(subject *subj, int options);
 
 // Create an inline with a literal string value.
-static CMARK_INLINE cmark_node *make_literal(cmark_mem *mem, cmark_node_type t, cmark_chunk s) {
+static CMARK_INLINE cmark_node *make_literal(cmark_mem *mem, cmark_node_type t,
+                                             cmark_chunk s) {
   cmark_node *e = (cmark_node *)mem->calloc(1, sizeof(*e));
   cmark_strbuf_init(mem, &e->content, 0);
   e->type = t;
@@ -80,7 +90,8 @@ static CMARK_INLINE cmark_node *make_simple(cmark_mem *mem, cmark_node_type t) {
 }
 
 // Like make_str, but parses entities.
-static cmark_node *make_str_with_entities(cmark_mem *mem, cmark_chunk *content) {
+static cmark_node *make_str_with_entities(cmark_mem *mem,
+                                          cmark_chunk *content) {
   cmark_strbuf unescaped = CMARK_BUF_INIT(mem);
 
   if (houdini_unescape_html(&unescaped, content->data, content->len)) {
@@ -105,7 +116,8 @@ static cmark_chunk chunk_clone(cmark_mem *mem, cmark_chunk *src) {
   return c;
 }
 
-static cmark_chunk cmark_clean_autolink(cmark_mem *mem, cmark_chunk *url, int is_email) {
+static cmark_chunk cmark_clean_autolink(cmark_mem *mem, cmark_chunk *url,
+                                        int is_email) {
   cmark_strbuf buf = CMARK_BUF_INIT(mem);
 
   cmark_chunk_trim(url);
@@ -122,7 +134,8 @@ static cmark_chunk cmark_clean_autolink(cmark_mem *mem, cmark_chunk *url, int is
   return cmark_chunk_buf_detach(&buf);
 }
 
-static CMARK_INLINE cmark_node *make_autolink(cmark_mem *mem, cmark_chunk url, int is_email) {
+static CMARK_INLINE cmark_node *make_autolink(cmark_mem *mem, cmark_chunk url,
+                                              int is_email) {
   cmark_node *link = make_simple(mem, CMARK_NODE_LINK);
   link->as.link.url = cmark_clean_autolink(mem, &url, is_email);
   link->as.link.title = cmark_chunk_literal("");
@@ -139,6 +152,7 @@ static void subject_from_buf(cmark_mem *mem, subject *e, cmark_strbuf *buffer,
   e->pos = 0;
   e->refmap = refmap;
   e->last_delim = NULL;
+  e->last_bracket = NULL;
 }
 
 static CMARK_INLINE int isbacktick(int c) { return (c == '`'); }
@@ -342,6 +356,15 @@ static void remove_delimiter(subject *subj, delimiter *delim) {
   free(delim);
 }
 
+static void pop_bracket(subject *subj) {
+  bracket *b;
+  if (subj->last_bracket == NULL)
+    return;
+  b = subj->last_bracket;
+  subj->last_bracket = subj->last_bracket->previous;
+  free(b);
+}
+
 static void push_delimiter(subject *subj, unsigned char c, bool can_open,
                            bool can_close, cmark_node *inl_text) {
   delimiter *delim = (delimiter *)subj->mem->calloc(1, sizeof(delimiter));
@@ -354,11 +377,24 @@ static void push_delimiter(subject *subj, unsigned char c, bool can_open,
   if (delim->previous != NULL) {
     delim->previous->next = delim;
   }
-  delim->position = subj->pos;
-  delim->active = true;
   subj->last_delim = delim;
 }
 
+static void push_bracket(subject *subj, bool image, cmark_node *inl_text) {
+  bracket *b = (bracket *)subj->mem->calloc(1, sizeof(bracket));
+  if (subj->last_bracket != NULL) {
+    subj->last_bracket->bracket_after = true;
+  }
+  b->image = image;
+  b->active = true;
+  b->inl_text = inl_text;
+  b->previous = subj->last_bracket;
+  b->previous_delimiter = subj->last_delim;
+  b->position = subj->pos;
+  b->bracket_after = false;
+  subj->last_bracket = b;
+}
+
 // Assumes the subject has a c at the current position.
 static cmark_node *handle_delim(subject *subj, unsigned char c, bool smart) {
   bufsize_t numdelims;
@@ -450,6 +486,7 @@ static void process_emphasis(subject *subj, delimiter *stack_bottom) {
   delimiter *opener;
   delimiter *old_closer;
   bool opener_found;
+  bool odd_match;
   delimiter *openers_bottom[128];
 
   // initialize openers_bottom:
@@ -465,15 +502,22 @@ static void process_emphasis(subject *subj, delimiter *stack_bottom) {
 
   // now move forward, looking for closers, and handling each
   while (closer != NULL) {
-    if (closer->can_close &&
-        (closer->delim_char == '*' || closer->delim_char == '_' ||
-         closer->delim_char == '"' || closer->delim_char == '\'')) {
+    if (closer->can_close) {
       // Now look backwards for first matching opener:
       opener = closer->previous;
       opener_found = false;
+      odd_match = false;
       while (opener != NULL && opener != stack_bottom &&
              opener != openers_bottom[closer->delim_char]) {
-        if (opener->delim_char == closer->delim_char && opener->can_open) {
+        // interior closer of size 2 can't match opener of size 1
+        // or of size 1 can't match 2
+        odd_match = (closer->can_open || opener->can_close) &&
+                    ((opener->inl_text->as.literal.len +
+                      closer->inl_text->as.literal.len) %
+                         3 ==
+                     0);
+        if (opener->delim_char == closer->delim_char && opener->can_open &&
+            !odd_match) {
           opener_found = true;
           break;
         }
@@ -503,8 +547,12 @@ static void process_emphasis(subject *subj, delimiter *stack_bottom) {
         }
         closer = closer->next;
       }
-      if (!opener_found) {
-        // set lower bound for future searches for openers:
+      if (!opener_found && !odd_match) {
+        // set lower bound for future searches for openers
+        // (we don't do this with 'odd_match' set because
+        // a ** that didn't match an earlier * might turn into
+        // an opener, and the * might be matched by something
+        // else.
         openers_bottom[old_closer->delim_char] = old_closer->previous;
         if (!old_closer->can_open) {
           // we can remove a closer that can't be an
@@ -755,27 +803,21 @@ static cmark_node *handle_close_bracket(subject *subj) {
   bufsize_t starturl, endurl, starttitle, endtitle, endall;
   bufsize_t n;
   bufsize_t sps;
-  cmark_reference *ref;
-  bool is_image = false;
+  cmark_reference *ref = NULL;
   cmark_chunk url_chunk, title_chunk;
   cmark_chunk url, title;
-  delimiter *opener;
+  bracket *opener;
   cmark_node *inl;
   cmark_chunk raw_label;
   int found_label;
   cmark_node *tmp, *tmpnext;
+  bool is_image;
 
   advance(subj); // advance past ]
   initial_pos = subj->pos;
 
-  // look through list of delimiters for a [ or !
-  opener = subj->last_delim;
-  while (opener) {
-    if (opener->delim_char == '[' || opener->delim_char == '!') {
-      break;
-    }
-    opener = opener->previous;
-  }
+  // get last [ or ![
+  opener = subj->last_bracket;
 
   if (opener == NULL) {
     return make_str(subj->mem, cmark_chunk_literal("]"));
@@ -783,14 +825,13 @@ static cmark_node *handle_close_bracket(subject *subj) {
 
   if (!opener->active) {
     // take delimiter off stack
-    remove_delimiter(subj, opener);
+    pop_bracket(subj);
     return make_str(subj->mem, cmark_chunk_literal("]"));
   }
 
   // If we got here, we matched a potential link/image text.
-  is_image = opener->delim_char == '!';
-
   // Now we check to see if it's a link/image.
+  is_image = opener->image;
 
   // First, look for an inline link.
   if (peek_char(subj) == '(' &&
@@ -830,20 +871,23 @@ static cmark_node *handle_close_bracket(subject *subj) {
   // skip spaces
   raw_label = cmark_chunk_literal("");
   found_label = link_label(subj, &raw_label);
-  if (!found_label || raw_label.len == 0) {
-    cmark_chunk_free(subj->mem, &raw_label);
-    raw_label = cmark_chunk_dup(&subj->input, opener->position,
-                                initial_pos - opener->position - 1);
-  }
-
   if (!found_label) {
     // If we have a shortcut reference link, back up
     // to before the spacse we skipped.
     subj->pos = initial_pos;
   }
 
-  ref = cmark_reference_lookup(subj->refmap, &raw_label);
-  cmark_chunk_free(subj->mem, &raw_label);
+  if ((!found_label || raw_label.len == 0) && !opener->bracket_after) {
+    cmark_chunk_free(subj->mem, &raw_label);
+    raw_label = cmark_chunk_dup(&subj->input, opener->position,
+                                initial_pos - opener->position - 1);
+    found_label = true;
+  }
+
+  if (found_label) {
+    ref = cmark_reference_lookup(subj->refmap, &raw_label);
+    cmark_chunk_free(subj->mem, &raw_label);
+  }
 
   if (ref != NULL) { // found
     url = chunk_clone(subj->mem, &ref->url);
@@ -855,7 +899,7 @@ static cmark_node *handle_close_bracket(subject *subj) {
 
 noMatch:
   // If we fall through to here, it means we didn't match a link:
-  remove_delimiter(subj, opener); // remove this opener from delimiter list
+  pop_bracket(subj); // remove this opener from delimiter list
   subj->pos = initial_pos;
   return make_str(subj->mem, cmark_chunk_literal("]"));
 
@@ -875,16 +919,16 @@ match:
   // Free the bracket [:
   cmark_node_free(opener->inl_text);
 
-  process_emphasis(subj, opener);
+  process_emphasis(subj, opener->previous_delimiter);
+  pop_bracket(subj);
 
   // Now, if we have a link, we also want to deactivate earlier link
   // delimiters. (This code can be removed if we decide to allow links
   // inside links.)
-  remove_delimiter(subj, opener);
   if (!is_image) {
-    opener = subj->last_delim;
+    opener = subj->last_bracket;
     while (opener != NULL) {
-      if (opener->delim_char == '[') {
+      if (!opener->image) {
         if (!opener->active) {
           break;
         } else {
@@ -1005,7 +1049,7 @@ static int parse_inline(subject *subj, cmark_node *parent, int options) {
   case '[':
     advance(subj);
     new_inl = make_str(subj->mem, cmark_chunk_literal("["));
-    push_delimiter(subj, '[', true, false, new_inl);
+    push_bracket(subj, false, new_inl);
     break;
   case ']':
     new_inl = handle_close_bracket(subj);
@@ -1015,7 +1059,7 @@ static int parse_inline(subject *subj, cmark_node *parent, int options) {
     if (peek_char(subj) == '[') {
       advance(subj);
       new_inl = make_str(subj->mem, cmark_chunk_literal("!["));
-      push_delimiter(subj, '!', false, true, new_inl);
+      push_bracket(subj, true, new_inl);
     } else {
       new_inl = make_str(subj->mem, cmark_chunk_literal("!"));
     }
@@ -1040,8 +1084,8 @@ static int parse_inline(subject *subj, cmark_node *parent, int options) {
 }
 
 // Parse inlines from parent's string_content, adding as children of parent.
-extern void cmark_parse_inlines(cmark_mem *mem, cmark_node *parent, cmark_reference_map *refmap,
-                                int options) {
+extern void cmark_parse_inlines(cmark_mem *mem, cmark_node *parent,
+                                cmark_reference_map *refmap, int options) {
   subject subj;
   subject_from_buf(mem, &subj, &parent->content, refmap);
   cmark_chunk_rtrim(&subj.input);
@@ -1050,6 +1094,10 @@ extern void cmark_parse_inlines(cmark_mem *mem, cmark_node *parent, cmark_refere
     ;
 
   process_emphasis(&subj, NULL);
+  // free bracket stack
+  while (subj.last_bracket) {
+    pop_bracket(&subj);
+  }
 }
 
 // Parse zero or more space characters, including at most one newline.