commonmarker 0.17.5 → 0.17.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e4e7274f40d6711782c78b1bc37386aa100bd8cd
-  data.tar.gz: 7282e60be23d6a3639b39ae141db93a139ef8877
+  metadata.gz: 59c20d40eba9c5219f78e92f0741d8fb2d9f29da
+  data.tar.gz: 44156b81161f96642c89cddc2f416589a85be867
 SHA512:
-  metadata.gz: 8cf250dc6f362023b915fa34a60a09488ec010a43afe8ce7c1b1cfa2c215a430a4bd484f296afcb989b38dfec4abbc64f554e66f8898304df9b0d83365863fa4
-  data.tar.gz: 323c1b64b5edff338fa02661d06ecdcb508306d866be0d6412c1503e321439aa3648c6ee8cc6ba1fb733af33c960798c50d2c293ff13e8e2827aa20c02849ed0
+  metadata.gz: d7e13f4d09487c68da35dc9aeeb0cbdd3806191411d9c155acfac088f96c5cdc9790019f037a771836a4cab533aa83c04b334ca3c6e5baef2daedd6681f0d71c
+  data.tar.gz: 1560c72e0bc98a990563409c6178993b1d2807ce5817a1552a88436b3242de2badbf8991e05222614737fa3b922e35d70ee85ef136cec1fcc5f946d4a9a5fb7b

data/README.md

@@ -135,6 +135,7 @@ CommonMarker accepts the same options that CMark does, as symbols. Note that the
 | `:SMART`            | Use smart punctuation (curly quotes, etc.).
 | `:VALIDATE_UTF8`    | Replace illegal sequences with the replacement character `U+FFFD`.
 | `:LIBERAL_HTML_TAG` | Support liberal parsing of inline HTML tags.
+| `:FOOTNOTES`        | Parse footnotes.
 
 ### Render options
 

data/ext/commonmarker/cmark/CMakeLists.txt

@@ -18,7 +18,7 @@ set(PROJECT_NAME "cmark")
 
 set(PROJECT_VERSION_MAJOR 0)
 set(PROJECT_VERSION_MINOR 28)
-set(PROJECT_VERSION_PATCH 0)
+set(PROJECT_VERSION_PATCH 3)
 set(PROJECT_VERSION_GFM 11)
 set(PROJECT_VERSION ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}.gfm.${PROJECT_VERSION_GFM} )
 

data/ext/commonmarker/cmark/README.md

@@ -65,8 +65,9 @@ There are also libraries that wrap `libcmark` for
 [Lua](https://github.com/jgm/cmark-lua),
 [Perl](https://metacpan.org/release/CommonMark),
 [Python](https://pypi.python.org/pypi/paka.cmark),
-[R](https://cran.r-project.org/package=commonmark) and
-[Scala](https://github.com/sparsetech/cmark-scala).
+[R](https://cran.r-project.org/package=commonmark),
+[Scala](https://github.com/sparsetech/cmark-scala) and
+[Node.js](https://github.com/killa123/node-cmark).
 
 Installing
 ----------

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

@@ -22,5 +22,5 @@ if(MSVC)
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4706 /D_CRT_SECURE_NO_WARNINGS")
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /TP")
 elseif(CMAKE_COMPILER_IS_GNUCC OR "${CMAKE_C_COMPILER_ID}" STREQUAL "Clang")
-  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -std=c99 -pedantic")
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wextra -std=c99 -pedantic -D_BSD_SOURCE -D_POSIX_SOURCE")
 endif()

data/ext/commonmarker/cmark/api_test/main.c

@@ -989,6 +989,95 @@ static void test_pathological_regressions(test_batch_runner *runner) {
   }
 }
 
+static void source_pos(test_batch_runner *runner) {
+  static const char markdown[] =
+    "# Hi *there*.\n"
+    "\n"
+    "Hello &ldquo; <http://www.google.com>\n"
+    "there `hi` -- [okay](www.google.com (ok)).\n"
+    "\n"
+    "> 1. Okay.\n"
+    ">    Sure.\n"
+    ">\n"
+    "> 2. Yes, okay.\n"
+    ">    ![ok](hi \"yes\")\n";
+
+  cmark_node *doc = cmark_parse_document(markdown, sizeof(markdown) - 1, CMARK_OPT_DEFAULT);
+  char *xml = cmark_render_xml(doc, CMARK_OPT_DEFAULT | CMARK_OPT_SOURCEPOS);
+  STR_EQ(runner, xml, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+                      "<!DOCTYPE document SYSTEM \"CommonMark.dtd\">\n"
+                      "<document sourcepos=\"1:1-10:20\" xmlns=\"http://commonmark.org/xml/1.0\">\n"
+                      "  <heading sourcepos=\"1:1-1:13\" level=\"1\">\n"
+                      "    <text sourcepos=\"1:3-1:5\">Hi </text>\n"
+                      "    <emph sourcepos=\"1:6-1:12\">\n"
+                      "      <text sourcepos=\"1:7-1:11\">there</text>\n"
+                      "    </emph>\n"
+                      "    <text sourcepos=\"1:13-1:13\">.</text>\n"
+                      "  </heading>\n"
+                      "  <paragraph sourcepos=\"3:1-4:42\">\n"
+                      "    <text sourcepos=\"3:1-3:14\">Hello “ </text>\n"
+                      "    <link sourcepos=\"3:15-3:37\" destination=\"http://www.google.com\" title=\"\">\n"
+                      "      <text sourcepos=\"3:16-3:36\">http://www.google.com</text>\n"
+                      "    </link>\n"
+                      "    <softbreak />\n"
+                      "    <text sourcepos=\"4:1-4:6\">there </text>\n"
+                      "    <code sourcepos=\"4:8-4:9\">hi</code>\n"
+                      "    <text sourcepos=\"4:11-4:14\"> -- </text>\n"
+                      "    <link sourcepos=\"4:15-4:41\" destination=\"www.google.com\" title=\"ok\">\n"
+                      "      <text sourcepos=\"4:16-4:19\">okay</text>\n"
+                      "    </link>\n"
+                      "    <text sourcepos=\"4:42-4:42\">.</text>\n"
+                      "  </paragraph>\n"
+                      "  <block_quote sourcepos=\"6:1-10:20\">\n"
+                      "    <list sourcepos=\"6:3-10:20\" type=\"ordered\" start=\"1\" delim=\"period\" tight=\"false\">\n"
+                      "      <item sourcepos=\"6:3-8:1\">\n"
+                      "        <paragraph sourcepos=\"6:6-7:10\">\n"
+                      "          <text sourcepos=\"6:6-6:10\">Okay.</text>\n"
+                      "          <softbreak />\n"
+                      "          <text sourcepos=\"7:6-7:10\">Sure.</text>\n"
+                      "        </paragraph>\n"
+                      "      </item>\n"
+                      "      <item sourcepos=\"9:3-10:20\">\n"
+                      "        <paragraph sourcepos=\"9:6-10:20\">\n"
+                      "          <text sourcepos=\"9:6-9:15\">Yes, okay.</text>\n"
+                      "          <softbreak />\n"
+                      "          <image sourcepos=\"10:6-10:20\" destination=\"hi\" title=\"yes\">\n"
+                      "            <text sourcepos=\"10:8-10:9\">ok</text>\n"
+                      "          </image>\n"
+                      "        </paragraph>\n"
+                      "      </item>\n"
+                      "    </list>\n"
+                      "  </block_quote>\n"
+                      "</document>\n",
+         "sourcepos are as expected");
+  free(xml);
+  cmark_node_free(doc);
+}
+
+static void ref_source_pos(test_batch_runner *runner) {
+  static const char markdown[] =
+    "Let's try [reference] links.\n"
+    "\n"
+    "[reference]: https://github.com (GitHub)\n";
+
+  cmark_node *doc = cmark_parse_document(markdown, sizeof(markdown) - 1, CMARK_OPT_DEFAULT);
+  char *xml = cmark_render_xml(doc, CMARK_OPT_DEFAULT | CMARK_OPT_SOURCEPOS);
+  STR_EQ(runner, xml, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+                      "<!DOCTYPE document SYSTEM \"CommonMark.dtd\">\n"
+                      "<document sourcepos=\"1:1-3:40\" xmlns=\"http://commonmark.org/xml/1.0\">\n"
+                      "  <paragraph sourcepos=\"1:1-1:28\">\n"
+                      "    <text sourcepos=\"1:1-1:10\">Let's try </text>\n"
+                      "    <link sourcepos=\"1:11-1:21\" destination=\"https://github.com\" title=\"GitHub\">\n"
+                      "      <text sourcepos=\"1:12-1:20\">reference</text>\n"
+                      "    </link>\n"
+                      "    <text sourcepos=\"1:22-1:28\"> links.</text>\n"
+                      "  </paragraph>\n"
+                      "</document>\n",
+         "sourcepos are as expected");
+  free(xml);
+  cmark_node_free(doc);
+}
+
 int main() {
   int retval;
   test_batch_runner *runner = test_batch_runner_new();
@@ -1016,6 +1105,8 @@ int main() {
   test_safe(runner);
   test_feed_across_line_ending(runner);
   test_pathological_regressions(runner);
+  source_pos(runner);
+  ref_source_pos(runner);
 
   test_print_summary(runner);
   retval = test_ok(runner) ? 0 : 1;

data/ext/commonmarker/cmark/changelog.txt

@@ -1,3 +1,26 @@
+[0.28.3]
+
+  * Include GNUInstallDirs in src/CMakeLists.txt (Nick Wellnhofer, #240).
+    This fixes build problems on some cmake versions (#241).
+
+[0.28.2]
+
+  * Fixed regression in install dest for static library (#238).
+    Due to a mistake, 0.28.1 installed libcmark.a into include/.
+
+[0.28.1]
+
+  * `--smart`: open quote can never occur right after `]` or `)` (#227).
+  * Fix quadratic behavior in `finalize` (Vicent Marti).
+  * Don't use `CMAKE_INSTALL_LIBDIR` to create `libcmark.pc` (#236).
+    This wasn't getting set in processing `libcmark.pc.in`, and we
+    were getting the wrong entry in `libcmark.pc`.
+    The new approach sets an internal `libdir` variable to
+    `lib${LIB_SUFFIX}`.  This variable is used both to set the
+    install destination and in the libcmark.pc.in template.
+  * Update README.md, replace `make astyle` with `make format`
+    (Nguyễn Thái Ngọc Duy).
+
 [0.28.0.gfm.11]
 
   * Do not output empty `<tbody>` in table extension.
@@ -32,7 +55,7 @@
   * Add `core_extensions_ensure_registered`.
   * Add sourcepos information for inlines.
 
-[0.28]
+[0.28.0]
 
   * Update spec.
   * Use unsigned integer when shifting (Phil Turnbull).

data/ext/commonmarker/cmark/extensions/core-extensions.c

@@ -4,6 +4,7 @@
 #include "table.h"
 #include "tagfilter.h"
 #include "registry.h"
+#include "plugin.h"
 
 static int core_extensions_registration(cmark_plugin *plugin) {
   cmark_plugin_register_syntax_extension(plugin, create_table_extension());

data/ext/commonmarker/cmark/extensions/core-extensions.h

@@ -7,6 +7,7 @@ extern "C" {
 
 #include <cmark_extension_api.h>
 #include "cmarkextensions_export.h"
+#include <stdint.h>
 
 CMARKEXTENSIONS_EXPORT
 void core_extensions_ensure_registered(void);

data/ext/commonmarker/cmark/extensions/strikethrough.c

@@ -1,5 +1,6 @@
 #include "strikethrough.h"
 #include <parser.h>
+#include <render.h>
 
 cmark_node_type CMARK_NODE_STRIKETHROUGH;
 
@@ -150,7 +151,7 @@ cmark_syntax_extension *create_strikethrough_extension(void) {
   special_chars = cmark_llist_append(mem, special_chars, (void *)'~');
   cmark_syntax_extension_set_special_inline_chars(ext, special_chars);
 
-  cmark_syntax_extension_set_emphasis(ext, true);
+  cmark_syntax_extension_set_emphasis(ext, 1);
 
   return ext;
 }

data/ext/commonmarker/cmark/extensions/table.c

@@ -4,6 +4,7 @@
 #include <parser.h>
 #include <references.h>
 #include <string.h>
+#include <render.h>
 
 #include "ext_scanners.h"
 #include "strikethrough.h"

data/ext/commonmarker/cmark/man/man3/cmark-gfm.3

@@ -1,4 +1,4 @@
-.TH cmark-gfm 3 "April 03, 2017" "LOCAL" "Library Functions Manual"
+.TH cmark-gfm 3 "November 09, 2017" "LOCAL" "Library Functions Manual"
 .SH
 NAME
 .PP
@@ -40,6 +40,7 @@ typedef enum {
   CMARK_NODE_PARAGRAPH      = CMARK_NODE_TYPE_BLOCK | 0x0008,
   CMARK_NODE_HEADING        = CMARK_NODE_TYPE_BLOCK | 0x0009,
   CMARK_NODE_THEMATIC_BREAK = CMARK_NODE_TYPE_BLOCK | 0x000a,
+  CMARK_NODE_FOOTNOTE_DEFINITION = CMARK_NODE_TYPE_BLOCK | 0x000b,
 
   /* Inline */
   CMARK_NODE_TEXT          = CMARK_NODE_TYPE_INLINE | 0x0001,
@@ -52,6 +53,7 @@ typedef enum {
   CMARK_NODE_STRONG        = CMARK_NODE_TYPE_INLINE | 0x0008,
   CMARK_NODE_LINK          = CMARK_NODE_TYPE_INLINE | 0x0009,
   CMARK_NODE_IMAGE         = CMARK_NODE_TYPE_INLINE | 0x000a,
+  CMARK_NODE_FOOTNOTE_REFERENCE = CMARK_NODE_TYPE_INLINE | 0x000b,
 } cmark_node_type;
 .RE
 \f[]
@@ -780,6 +782,20 @@ responsibility to free the returned buffer.
 As for \f[I]cmark_render_commonmark\f[], but specifying the allocator to
 use for the resulting string.
 
+.PP
+\fIchar *\f[] \fBcmark_render_plaintext\f[](\fIcmark_node *root\f[], \fIint options\f[], \fIint width\f[])
+
+.PP
+Render a \f[I]node\f[] tree as a plain text document. It is the caller's
+responsibility to free the returned buffer.
+
+.PP
+\fIchar *\f[] \fBcmark_render_plaintext_with_mem\f[](\fIcmark_node *root\f[], \fIint options\f[], \fIint width\f[], \fIcmark_mem *mem\f[])
+
+.PP
+As for \f[I]cmark_render_plaintext\f[], but specifying the allocator to
+use for the resulting string.
+
 .PP
 \fIchar *\f[] \fBcmark_render_latex\f[](\fIcmark_node *root\f[], \fIint options\f[], \fIint width\f[])
 
@@ -917,6 +933,30 @@ dashes.
 .PP
 Use GitHub\-style  tags for code blocks instead of .
 
+.PP
+.nf
+\fC
+.RS 0n
+#define CMARK_OPT_LIBERAL_HTML_TAG (1 << 12)
+.RE
+\f[]
+.fi
+
+.PP
+Be liberal in interpreting inline HTML tags.
+
+.PP
+.nf
+\fC
+.RS 0n
+#define CMARK_OPT_FOOTNOTES (1 << 13)
+.RE
+\f[]
+.fi
+
+.PP
+Parse footnotes.
+
 .SS
 Version information
 

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

@@ -2,6 +2,8 @@ if(${CMAKE_VERSION} VERSION_GREATER "3.3")
     cmake_policy(SET CMP0063 NEW)
 endif()
 
+include(GNUInstallDirs)
+
 set(LIBRARY "libcmark-gfm")
 set(STATICLIBRARY "libcmark-gfm_static")
 set(HEADERS
@@ -13,6 +15,8 @@ set(HEADERS
   iterator.h
   chunk.h
   references.h
+  footnotes.h
+  map.h
   utf8.h
   scanners.h
   inlines.h
@@ -34,6 +38,8 @@ set(LIBRARY_SOURCES
   utf8.c
   buffer.c
   references.c
+  footnotes.c
+  map.c
   render.c
   man.c
   xml.c
@@ -139,19 +145,21 @@ endif(MSVC)
 
 set(CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_NO_WARNINGS ON)
 
+set(libdir lib${LIB_SUFFIX})
+
 include (InstallRequiredSystemLibraries)
 install(TARGETS ${PROGRAM} ${CMARK_INSTALL}
   EXPORT cmark-gfm
   RUNTIME DESTINATION bin
-  LIBRARY DESTINATION lib${LIB_SUFFIX}
-  ARCHIVE DESTINATION lib${LIB_SUFFIX}
+  LIBRARY DESTINATION ${libdir}
+  ARCHIVE DESTINATION ${libdir}
   )
 
 if(CMARK_SHARED OR CMARK_STATIC)
   configure_file(${CMAKE_CURRENT_SOURCE_DIR}/libcmark-gfm.pc.in
     ${CMAKE_CURRENT_BINARY_DIR}/libcmark-gfm.pc @ONLY)
   install(FILES ${CMAKE_CURRENT_BINARY_DIR}/libcmark-gfm.pc
-    DESTINATION lib${LIB_SUFFIX}/pkgconfig)
+    DESTINATION ${libdir}/pkgconfig)
 
   install(FILES
     cmark.h
@@ -161,7 +169,7 @@ if(CMARK_SHARED OR CMARK_STATIC)
     DESTINATION include
     )
 
-  install(EXPORT cmark-gfm DESTINATION lib${LIB_SUFFIX}/cmake-gfm)
+  install(EXPORT cmark-gfm DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake)
 endif()
 
 # Feature tests

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

@@ -21,6 +21,7 @@
 #include "inlines.h"
 #include "houdini.h"
 #include "buffer.h"
+#include "footnotes.h"
 
 #define CODE_INDENT 4
 #define TAB_STOP 4
@@ -97,7 +98,7 @@ static void cmark_parser_dispose(cmark_parser *parser) {
     cmark_node_free(parser->root);
 
   if (parser->refmap)
-    cmark_reference_map_free(parser->refmap);
+    cmark_map_free(parser->refmap);
 }
 
 static void cmark_parser_reset(cmark_parser *parser) {
@@ -389,7 +390,7 @@ static cmark_node *add_child(cmark_parser *parser, cmark_node *parent,
   return child;
 }
 
-void cmark_manage_extensions_special_characters(cmark_parser *parser, bool add) {
+void cmark_manage_extensions_special_characters(cmark_parser *parser, int add) {
   cmark_llist *tmp_ext;
 
   for (tmp_ext = parser->inline_syntax_extensions; tmp_ext; tmp_ext=tmp_ext->next) {
@@ -408,7 +409,7 @@ void cmark_manage_extensions_special_characters(cmark_parser *parser, bool add)
 // Walk through node and all children, recursively, parsing
 // string content into inline content where appropriate.
 static void process_inlines(cmark_parser *parser,
-                            cmark_reference_map *refmap, int options) {
+                            cmark_map *refmap, int options) {
   cmark_iter *iter = cmark_iter_new(parser->root);
   cmark_node *cur;
   cmark_event_type ev_type;
@@ -429,6 +430,84 @@ static void process_inlines(cmark_parser *parser,
   cmark_iter_free(iter);
 }
 
+static int sort_footnote_by_ix(const void *_a, const void *_b) {
+  cmark_footnote *a = *(cmark_footnote **)_a;
+  cmark_footnote *b = *(cmark_footnote **)_b;
+  return (int)a->ix - (int)b->ix;
+}
+
+static void process_footnotes(cmark_parser *parser) {
+  // * Collect definitions in a map.
+  // * Iterate the references in the document in order, assigning indices to
+  //   definitions in the order they're seen.
+  // * Write out the footnotes at the bottom of the document in index order.
+
+  cmark_map *map = cmark_footnote_map_new(parser->mem);
+
+  cmark_iter *iter = cmark_iter_new(parser->root);
+  cmark_node *cur;
+  cmark_event_type ev_type;
+
+  while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) {
+    cur = cmark_iter_get_node(iter);
+    if (ev_type == CMARK_EVENT_EXIT && cur->type == CMARK_NODE_FOOTNOTE_DEFINITION) {
+      cmark_node_unlink(cur);
+      cmark_footnote_create(map, cur);
+    }
+  }
+
+  cmark_iter_free(iter);
+  iter = cmark_iter_new(parser->root);
+  unsigned int ix = 0;
+
+  while ((ev_type = cmark_iter_next(iter)) != CMARK_EVENT_DONE) {
+    cur = cmark_iter_get_node(iter);
+    if (ev_type == CMARK_EVENT_EXIT && cur->type == CMARK_NODE_FOOTNOTE_REFERENCE) {
+      cmark_footnote *footnote = (cmark_footnote *)cmark_map_lookup(map, &cur->as.literal);
+      if (footnote) {
+        if (!footnote->ix)
+          footnote->ix = ++ix;
+
+        char n[32];
+        snprintf(n, sizeof(n), "%d", footnote->ix);
+        cmark_chunk_free(parser->mem, &cur->as.literal);
+        cmark_strbuf buf = CMARK_BUF_INIT(parser->mem);
+        cmark_strbuf_puts(&buf, n);
+
+        cur->as.literal = cmark_chunk_buf_detach(&buf);
+      } else {
+        cmark_node *text = (cmark_node *)parser->mem->calloc(1, sizeof(*text));
+        cmark_strbuf_init(parser->mem, &text->content, 0);
+        text->type = (uint16_t) CMARK_NODE_TEXT;
+
+        cmark_strbuf buf = CMARK_BUF_INIT(parser->mem);
+        cmark_strbuf_puts(&buf, "[^");
+        cmark_strbuf_put(&buf, cur->as.literal.data, cur->as.literal.len);
+        cmark_strbuf_putc(&buf, ']');
+
+        text->as.literal = cmark_chunk_buf_detach(&buf);
+        cmark_node_insert_after(cur, text);
+        cmark_node_free(cur);
+      }
+    }
+  }
+
+  cmark_iter_free(iter);
+
+  if (map->sorted) {
+    qsort(map->sorted, map->size, sizeof(cmark_map_entry *), sort_footnote_by_ix);
+    for (unsigned int i = 0; i < map->size; ++i) {
+      cmark_footnote *footnote = (cmark_footnote *)map->sorted[i];
+      if (!footnote->ix)
+        continue;
+      cmark_node_append_child(parser->root, footnote->node);
+      footnote->node = NULL;
+    }
+  }
+
+  cmark_map_free(map);
+}
+
 // 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.
@@ -533,6 +612,8 @@ static cmark_node *finalize_document(cmark_parser *parser) {
 
   finalize(parser, parser->root);
   process_inlines(parser, parser->refmap, parser->options);
+  if (parser->options & CMARK_OPT_FOOTNOTES)
+    process_footnotes(parser);
 
   return parser->root;
 }
@@ -759,6 +840,18 @@ static bool parse_block_quote_prefix(cmark_parser *parser, cmark_chunk *input) {
   return res;
 }
 
+static bool parse_footnote_definition_block_prefix(cmark_parser *parser, cmark_chunk *input,
+                                                   cmark_node *container) {
+  if (parser->indent >= 4) {
+    S_advance_offset(parser, input, 4, true);
+    return true;
+  } else if (input->len > 0 && (input->data[0] == '\n' || (input->data[0] == '\r' && input->data[1] == '\n'))) {
+    return true;
+  }
+
+  return false;
+}
+
 static bool parse_node_item_prefix(cmark_parser *parser, cmark_chunk *input,
                                    cmark_node *container) {
   bool res = false;
@@ -913,6 +1006,10 @@ static cmark_node *check_open_blocks(cmark_parser *parser, cmark_chunk *input,
       if (parser->blank)
         goto done;
       break;
+		case CMARK_NODE_FOOTNOTE_DEFINITION:
+			if (!parse_footnote_definition_block_prefix(parser, input, container))
+				goto done;
+			break;
     default:
       break;
     }
@@ -1024,6 +1121,21 @@ 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 (!indented &&
+               parser->options & CMARK_OPT_FOOTNOTES &&
+               (matched = scan_footnote_definition(input, parser->first_nonspace))) {
+      cmark_chunk c = cmark_chunk_dup(input, parser->first_nonspace + 2, matched - 2);
+      cmark_chunk_to_cstr(parser->mem, &c);
+
+      while (c.data[c.len - 1] != ']')
+        --c.len;
+      --c.len;
+
+      S_advance_offset(parser, input, parser->first_nonspace + matched - parser->offset, false);
+      *container = add_child(parser, *container, CMARK_NODE_FOOTNOTE_DEFINITION, parser->first_nonspace + matched + 1);
+      (*container)->as.literal = c;
+
+      (*container)->internal_offset = matched;
     } else if ((!indented || cont_type == CMARK_NODE_LIST) &&
                (matched = parse_list_marker(
                     parser->mem, input, parser->first_nonspace,