](https://crates.io/crates/markdown-it-footnote)
+
+A [markdown-it.rs](https://crates.io/crates/markdown-it) plugin to process footnotes.
+
+It is based on the [pandoc definition](http://johnmacfarlane.net/pandoc/README.html#footnotes):
+
+```md
+Normal footnote:
+
+Here is a footnote reference,[^1] and another.[^longnote]
+
+Here is an inline note.^[my note is here!]
+
+[^1]: Here is the footnote.
+
+[^longnote]: Here's one with multiple blocks.
+
+ Subsequent paragraphs are indented to show that they
+belong to the previous footnote.
+```
+
+See the [tests](tests/fixtures) for more examples.
+
+## Usage
+
+To load the full plugin:
+
+```rust
+let parser = &mut markdown_it::MarkdownIt::new();
+markdown_it::plugins::cmark::add(parser);
+
+md_footnote::add(parser);
+
+let ast = parser.parse("Example^[my note]");
+let html = ast.render();
+```
+
+Alternatively, you can load the separate components:
+
+```rust
+let parser = &mut markdown_it::MarkdownIt::new();
+markdown_it::plugins::cmark::add(parser);
+
+md_footnote::definitions::add(md);
+md_footnote::references::add(md);
+md_footnote::inline::add(md);
+md_footnote::collect::add(md);
+md_footnote::back_refs::add(md);
+```
+
+Which have the following roles:
+
+- `definitions`: parse footnote definitions, e.g. `[^1]: foo`
+- `references`: parse footnote references, e.g. `[^1]`
+- `inline`: parse inline footnotes, e.g. `^[foo]`
+- `collect`: collect footnote definitions (removing duplicate/unreferenced ones) and move them to be the last child of the root node.
+- `back_refs`: add anchor(s) to footnote definitions, with links back to the reference(s)
diff --git a/crates/lib/md-footnote/src/back_refs.rs b/crates/lib/md-footnote/src/back_refs.rs
new file mode 100644
index 0000000..060ff02
--- /dev/null
+++ b/crates/lib/md-footnote/src/back_refs.rs
@@ -0,0 +1,107 @@
+//! Plugin to add anchor(s) to footnote definitions,
+//! with links back to the reference(s).
+//!
+//! ```rust
+//! let parser = &mut markdown_it::MarkdownIt::new();
+//! markdown_it::plugins::cmark::add(parser);
+//! md_footnote::references::add(parser);
+//! md_footnote::definitions::add(parser);
+//! md_footnote::back_refs::add(parser);
+//! let root = parser.parse("[^label]\n\n[^label]: This is a footnote");
+//! let mut names = vec![];
+//! root.walk(|node,_| { names.push(node.name()); });
+//! assert_eq!(names, vec![
+//! "markdown_it::parser::core::root::Root",
+//! "markdown_it::plugins::cmark::block::paragraph::Paragraph",
+//! "md_footnote::references::FootnoteReference",
+//! "md_footnote::definitions::FootnoteDefinition",
+//! "markdown_it::plugins::cmark::block::paragraph::Paragraph",
+//! "markdown_it::parser::inline::builtin::skip_text::Text",
+//! "md_footnote::back_refs::FootnoteRefAnchor",
+//! ]);
+//! ```
+use markdown_it::{
+ MarkdownIt, Node, NodeValue,
+ parser::core::{CoreRule, Root},
+ plugins::cmark::block::paragraph::Paragraph,
+};
+
+use crate::{FootnoteMap, definitions::FootnoteDefinition};
+
+pub fn add(md: &mut MarkdownIt) {
+ // insert this rule into parser
+ md.add_rule::normal paragraph
+Here is a footnote reference,[1] and another.[2]
+This paragraph won't be part of the note, because it +isn't indented.
+Here is the footnote. ↩︎
+Here's one with multiple blocks.
+Subsequent paragraphs are indented to show that they +belong to the previous footnote.
+{ some.code }
+The whole paragraph can be indented, or just the first +line. In this way, multi-paragraph footnotes work like +multi-paragraph list items. ↩︎
+b
+++
bar +baz ↩︎
+[^ foo]: bar baz
+[^foo +]: bar baz
diff --git a/crates/lib/md-footnote/tests/fixtures/5.md b/crates/lib/md-footnote/tests/fixtures/5.md new file mode 100644 index 0000000..6c58dcd --- /dev/null +++ b/crates/lib/md-footnote/tests/fixtures/5.md @@ -0,0 +1,19 @@ +Duplicate footnotes: + +...... + +[^xxxxx] [^xxxxx] + +[^xxxxx]: foo + +...... + + +foo ↩︎
+terminates here
+abc
+def +hij
+++ ↩︎block
+
Here is an inline note.[1]
+Inlines notes are easier to write, since +you don't have to pick an identifier and move down to type the +note. ↩︎
+foo[1]
+bar ↩︎
+Example[1]
+